Files
pipelines/android
alan 8b39c087fd Animate the active stage and executed edges in the run graph
Show what is happening while a run is live. The executing stage now carries a
subtle pulsing halo (replacing the blink) and a live ticking elapsed badge
derived from the run's current visit start. Executed edges carry a directional
flow of light dots along the path; a finished stage settles into its static
colour. A finished run never animates, the animation pauses when the graph is
off screen, and with the system animation setting disabled it falls back to a
static but clearly marked running state.

The per-frame visual state and should-animate decision live in pure functions
(GraphMotion.kt, Format.kt secondsSince; GraphSemantics exposes executing and
currentStageStartedAt) with unit tests and no frame-timing assertions. Adds
GraphMotionTest and extends GraphSemanticsTest and FormatTest.
2026-10-16 09:52:57 +01:00
..

Pipelines Android client

A native Android (Kotlin + Jetpack Compose Material 3) client for an existing Pipelines server. All execution, model credentials, definitions and run history stay on the server; the app only speaks the existing WebSocket protocol.

Scope and safety

  • Trusted LAN/VPN only. The Pipelines API has no authentication and is not internet-safe. Do not expose the server to untrusted networks.
  • No secrets. The app stores no credentials, tokens or provider keys and sends no auth headers. Only the server URL and workspace path are persisted as plain, non-secret preferences.
  • No hardcoded server. The server URL and workspace path must be entered explicitly by the user; there is no default/disposable address baked in.
  • The app does not run Docker, execute stages, or reimplement any Go parsing/execution logic. android/ contains only the client.

Requirements

  • JDK 17 (see compileOptions / kotlinOptions.jvmTarget).
  • Android SDK with a platform and build-tools matching compileSdk = 35 (app/build.gradle.kts), and ANDROID_HOME/ANDROID_SDK_ROOT set.
  • Gradle 8.9+ (AGP 8.7.2, Kotlin 2.0.21).

The version numbers above are deliberate defaults chosen without a discovered SDK; adjust compileSdk, targetSdk, and the versions in gradle/libs.versions.toml to whatever is actually installed. If a required SDK/Gradle component is missing, fix the environment rather than downloading untracked artifacts.

Gradle wrapper

gradle/wrapper/gradle-wrapper.jar is a generated binary and is intentionally not committed. Generate a working wrapper on a machine with Gradle installed:

cd android
gradle wrapper --gradle-version 8.9

Until then, build with a locally installed Gradle:

cd android
gradle :app:assembleDebug

Build, test and install

cd android
gradle :app:testDebugUnitTest      # protocol/URL/graph unit tests
gradle :app:assembleDebug          # debug APK
gradle :app:lintDebug              # Android lint
# install on a connected device/emulator:
gradle :app:installDebug
adb shell am start -n net.awan.pipelines/.MainActivity

Capturing screenshots

Never write adb … screencap to a file through exec-out or a redirect: on a device with more than one display (e.g. the fold emulator's inner and cover panels) screencap prints a [Warning] Multiple displays were found… line to stderr, adb folds it into the stream, and the .png ends up 100+ KB of text while adb still exits 0. Such a file must never be cited as evidence. Capture on the device to a file, pull it, name the display explicitly, and validate the bytes before use:

android/scripts/capture_png.sh -s <serial> <out.png>   # capture + validate
android/scripts/capture_png.sh --check <file.png>      # validate an existing file

The helper resolves the primary SurfaceFlinger display id (dumpsys SurfaceFlinger --display-id, the id screencap -d expects - not the logical dumpsys display id), captures -d <id> to /sdcard, pulls, and checks the PNG magic bytes (and the reported type). A file that is not a real image is deleted and the helper exits non-zero, so a bad capture stops the run with blocked instead of reaching an approval. Every UI-capturing run must use this helper and state in its evidence that each image was validated.

Configuration

Open the Settings tab and enter:

  • Server URL — ws://HOST:PORT/connect (LAN/VPN) or wss://…/connect (proxy/VPN). A path is optional and defaults to /connect, matching the Go server's GET /connect. http(s), userinfo and fragments are rejected with a specific message.
  • Workspace path — an absolute directory that already exists on the execution server. This is not the phone's storage. For Docker, mount the host directory at the same absolute path with the owner's UID/GID so the server can resolve it (see docs/docker.md and compose.yaml). The field flags a non-absolute path and will not save it, mirroring the repository's start-run guard.

Tap Connect to open the single shared WebSocket (probed with ping, showing the server build). Reconnect uses bounded exponential backoff; Disconnect stops it.

Features

  • Pipeline list (search/refresh, empty/error/loading states), pipeline details (version list, content hash, source) and the workflow graph.
  • Workflow graph composable: content-sized stage nodes laid out in one row in declaration order, with #failure/#success terminals sharing a lower row and arrows entering their top borders (an error -> #failure route leaves its source's bottom); labelled outcome edges (error* marks the implicit fallback), loops and branches, pan/zoom, and run highlighting (under a run the executed stage/route is a solid full-colour stroke with an arrowhead and a filled, normal-bordered node, while a not-executed one is a dashed, arrowless muted stroke with a hollow, dashed-bordered node and a muted label; an executed success/error route is drawn noticeably heavier with a stronger same-hue stroke and a larger arrowhead so pass/fail dominates; a one-line legend names both states) plus a screen-reader description. Edges are drawn as axis-aligned orthogonal polylines like the TUI (routePoints computes the path once per layout and stores it on EdgeLayout.points), and each arrowhead points along its route's final segment rather than the from-to chord. Pinch zoom is anchored to the gesture centroid: the pure zoomAbout keeps the content point under the fingers fixed (clamped to MIN_SCALE/MAX_SCALE) and the existing pan clamp is applied afterwards, so the content no longer slides away from the fingers.
  • One shared graph-panel height (collapsedGraphHeight/expandedGraphHeight) replaces the former 360.dp and 340.dp literals, so both detail screens render the graph at the same size: about 58% of the window height floored at a height that still fits a 4-stage graph with its terminal row. The graph's TopEnd control cluster pairs "Fit graph to view" with an expand/collapse toggle that grows the panel to about the full window height; the expanded state is stored in rememberSaveable and the panel refits on resize. Because the panel lives inside each screen's verticalScroll column, growing it only extends it below the fold, so expanding also requests BringIntoViewRequester to scroll the taller panel back into the visible viewport instead of leaving the graph centred off-screen.
  • Dark-first Material 3 theme with an app-owned colour scheme (no dynamic/ wallpaper colour): the dark scheme is the default and the window background and system bars are dark so launching shows no light flash; a complete light scheme is retained for when it is explicitly requested.
  • Consistent Material 3 top app bars on Pipelines, Runs and Settings (and the existing back/refresh/start/cancel/retry bars on the detail screens).
  • Both detail screens are tabbed via one shared ui/components/DetailTabs.kt: run detail exposes Summary, Graph, Input, Output, Evidence and Timeline, pipeline detail Summary, Graph and Source, with Summary first and the default. Every tab carries a meaningful icon alongside its label. The section index stays fixed and visible while the selected section's panel swaps in place behind a short Crossfade: selecting a section is an ordinary tab change with no lateral motion, so there is nothing to swipe — the sections are not a left-to-right pager. Only navigation between levels (list → detail → stage pane) slides, via SlidingPaneStack. Only the selected section is composed at rest, each section is a single LazyColumn, and each section's own saved state (its list scroll position) is kept under its stable tab key through a rememberSaveableStateHolder, so returning to a section never resets its scroll. The Graph tab keeps the full-height WorkflowGraph panel with its Fit and expand controls. Narrow windows show a horizontally scrolling PrimaryScrollableTabRow; wide windows show an always-visible selectable rail (icon + label, no collapse control). selectedIndex is the single source of truth and a tap reports the new index through onSelect. The tabs carry real tab semantics (Role.Tab + selected state), so selection is never conveyed by colour alone, and the selected index is rememberSaveable (survives recomposition, configuration change and process death) and clamped by clampTabIndex.
  • The Source tab fills the whole tab area and renders the parsed definition instead of dumping the raw markdown: one collapsible section per stage (name · type) holding labelled blocks for prompt, output, tools, configs, edges (outcomes with their resolved targets, #success/#failure named as terminals), memory, limits and notification policy, skipping what a stage does not have. The rows come from the same stageDefinitionFields/StageFieldRow the stage detail sheet uses, so the two views cannot diverge. The exact source stays available behind a "Raw" toggle and a whole-definition copy action.
  • The Summary tab carries what each page header carried: for a run the status/outcome/executing chip row, recorded + completed visits, pipeline id/version, stage, workspace, content hash, start/finish/duration and the failure diagnostic; for a pipeline the name, id/version, stages, content hash, created/updated, latest version/version-created and the version list.
  • Code-like content (Input, Output, Source, session transcripts, per-field and evidence data, diagnostics) renders through one themed ui/components/ CodeBlock.kt card: surfaceContainer role, default rounded shape, a small label header, a whole-block copy action (LocalClipboardManager) and monospace at the shared size/line height, with a bounded height that scrolls internally instead of pushing the page. maxHeight = null renders a block unbounded so the surrounding page scrolls as a whole (the Source tab uses this); the default bounded behaviour is unchanged for every other caller. Blank content renders nothing, and no raw bordered monospace box remains.
  • Inside each tab the existing LazyListScope.collapsibleSection (SectionHeader) provides inner sections where content naturally breaks down: Output per result field, Input per labelled part, Steps per stage group and Evidence per entry. Each defaults to expanded and its collapsed set is rememberSaveable, so it survives configuration changes; the sections are items of the tab's single LazyColumn, so no scrollable nests inside a same-direction scrollable.
  • Foldable-responsive layout driven by window size (ui/WindowSize.kt, isWideLayout(widthDp) at a 600dp breakpoint, read from LocalConfiguration.current.screenWidthDp): both window widths use one adaptive sliding pane stack (ui/components/SlidingPaneStack.kt) — pane 0 is the pipeline (or run) list, pane 1 the selected detail and pane 2 the selected stage/graph node. On a narrow window there is no stack and no peek: every opened pane is a full-window screen that slides in over the last, and Back, the back gesture or the pane's own back control returns one level with nothing left over on the left. On a wide window the panes stack, but the space the covered panes reserve is one fixed budget shared between them (PEEK_BUDGET_DP), so the active (topmost) pane's left edge is always exactly the budget and its width never shrinks as levels are added; the leftmost strip is widened first so it stays tappable after the gesture inset, and the rest of the budget is split evenly. Tapping a covered pane's peek closes every pane to its right. There is no collapse control, no collapsed strip and no master-pane width constant any more. The section index presentation does follow the window width: a narrow window shows the tab row across the top, a wide window the always-visible side rail, with the text column capped at a comfortable width and the graph using the extra width. No material3-adaptive dependency is added.
  • Both detail screens' sections are still collapsible via the shared SectionHeader: tapping a header toggles it, an animated chevron rotates with the state, the header sticks to the top of the list while its content scrolls under an opaque background, and the state is exposed to accessibility ("Steps, expanded"). Expanded state is rememberSaveable, per section and per screen, defaulting to expanded. Real lists (versions, steps, session evidence) are items of the one outer list, so nothing nests a scrollable.
  • Steps render as a timeline in run detail: a leading status glyph connected to the next step by an outcome-coloured line (kept aligned with the step title), the stage with its sequence and an outcome chip. A step's metadata is a set of aligned label/value rows (KeyValueRow) — paired side by side in two columns on a wide window and stacked in one column on a narrow one — with a single consistent vertical rhythm (one bottom gap per step, no doubled gap when a step has no expandable detail) and full-width monospace evidence cards. Every retained field stays: status, outcome, duration, visit/maxVisits/limitReached/ model target, target, session id, agent active, diagnostic and, behind the collapsed-by-default detail, input, output, transcript, file changes (including binary/truncated and skipped) and notification receipts.
  • The runs list is grouped by day (Today/Yesterday/date, newest first) under sticky headers, with the usage aggregates as a metrics block (total, average via formatDuration, and colour-coded succeeded/failed/canceled/interrupted/ active counts). Each card shows the pipeline name with a version chip, a colour-coded status chip with a distinct icon per state (running/queued/succeeded/failed/canceled/interrupted/active/unknown), a meta row (run id, start time, duration) and the diagnostic only when non-blank, clamped to two lines. The raw resultPreview is no longer printed, and progress is shown honestly (completed visits + current stage, with an indeterminate indicator while executing; no invented total).
  • One centralised type scale (ui/theme/Typography.kt, passed to MaterialTheme and exposed as named roles) defines the screen/app-bar title, section header, card title, subtitle/meta, body and monospace data, applied on the list and both detail screens.
  • Run history with server usage aggregates, and run details with steps (status/outcome/diagnostic/session/transcript/file changes/notifications/ control evidence). Session evidence is scoped to the selected run and each record is rendered (sequence/session id/backend/directory/data/diagnostic) on demand via get_run_evidence; it is never part of the 1s poll.
  • A shared connection banner above every screen surfaces a distinct Idle/Connecting/Disconnected state with a Reconnect action (and stays hidden while connected), so a dropped connection is not just a generic request error.
  • Start run (confirmation dialog; sends PipelineID, Version, a reused request_key ≤128 chars, the configured absolute workspace and input.prompt) and cancel run (confirmation; sends the RunID, then refreshes). Retry is offered only for terminal failed runs.
  • A run being polled at a fixed 1s interval is stopped as soon as it is no longer executing.

Architecture

data/protocol   kotlinx.serialization models mirroring internal/protocol/*
                (Message, Graph/Stage, RunDetail/RunStep, UsageStats, …) plus
                GraphSemantics reproducing internal/tui/graph.go rules.
data/transport  ServerUrl validation (mirrors internal/client/config.go) and
                PipelinesClient — one reused WebSocket, serialized requests,
                client ids matched against replies, unsolicited envelopes
                dropped, bounded reconnect backoff.
data            SettingsRepository (non-secret prefs) and PipelinesRepository
                (typed request builders + per-session graph/detail cache).
ui              Compose Material 3 screens, one AppViewModel, navigation.

Verification status

Verified on macOS with the host toolchain (JDK 17 from Android Studio, ANDROID_HOME=/Users/alan/Library/Android/sdk, Gradle 8.11.1 --offline):

  • :app:compileDebugKotlin, :app:assembleDebug and :app:testDebugUnitTest all succeed; 53 unit tests, 0 failures (protocol model, graph semantics, server URL, workflow-graph layout including the terminal row, bottom exits, back edges, orthogonal routing/axis alignment, arrowhead direction, the shared panel height and the new zoomAbout anchor/clamp cases, plus duration formatting, run-state mapping and run day-grouping). Re-run with --rerun-tasks to confirm.
  • The debug APK was installed and driven on the Pixel_Fold_API_36 emulator (Android 16, adb shell cmd uimode night yes) against a live server at ws://10.0.2.2:8080/connect with workspace /Users/alan/repos/pipelines. Settings, pipeline list (all 9 pipelines), pipeline detail, the workflow graph, run history and run detail were captured to captures/ and captures/style_pass/ (both git-ignored) and reviewed.
  • adb logcat for the app package contained no FATAL EXCEPTION, Compose or other runtime exception during the sweep.
  • The orthogonal-edge / resizable-panel pass was verified the same way: a baseline APK was built from the pre-change tree and installed, then the new build was installed and driven to the 4-stage pipeline-detail graph and a run-detail graph with the executed route highlighted. captures/graph_pass/ (git-ignored) holds pipeline_detail_before/after and run_detail_before/after pairs plus a panned state and the expanded panel after tapping the toggle (pipeline_detail_expanded_after, run_detail_panned_after, run_detail_expanded_after). A review of that pass found the expanded panel scrolled below the fold (blank) and the PNGs prefixed by an adb stderr warning, so the expand now scrolls the panel into view and the after-captures were re-taken with a display id (adb exec-out screencap -p -d <display-id>) so no warning leaks into the files. adb logcat showed no FATAL EXCEPTION and no app/Compose exception during the sweep.

Known limitations of that run: pinch-zoom could not be driven through adb (single-touch pan only) and one portrait Fold viewport was used. A follow-up pass fitted the graph to its viewport on first layout, clamped panning so the content cannot leave the view, added a "Fit graph to view" action, connected on launch when a server URL is already saved, and made the completed/recorded visit wording and the outcome-label contrast consistent. The fitted graph still sits slightly above the box's vertical centre, because the layout box includes padding that is not drawn. A later style pass made the theme dark-first (app-owned scheme; the launch window/bar colours match it) and moved the #failure/#success terminals to a lower row beneath the stage row; before/after captures for the theme, graph and app bar/style are under captures/style_pass/ (*_before.png are the pre-change baseline referenced by the task, *_after.png are the new build).

The Runs-area pass (centroid zoom, collapsible sticky sections, runs list, steps timeline, type hierarchy) was verified the same way on the Pixel_Fold_API_36 emulator (dark mode, adb shell cmd uimode night yes) against the live server: the debug APK was installed, the list/detail/step flows were driven with adb shell input and uiautomator dump, and captures were written to captures/runs_pass/ (git-ignored): runs_list_top, runs_list_scrolled_sticky (a 13 Oct 2026 header pinned under the app bar), runs_list_states, runs_card_interrupted, run_detail_top, run_detail_graph_collapsed, run_detail_steps, run_detail_step_expanded, run_detail_sticky_section (a Steps, expanded header pinned mid-list), pipeline_detail_sections, pipeline_detail_section_collapsed, pipeline_graph_panned and pipeline_graph_fit. adb logcat for the app package contained no FATAL EXCEPTION or Compose/other runtime exception during the sweep. As before, adb cannot synthesise a two-finger pinch, so the centroid-anchored zoom is verified primarily by the zoomAbout unit tests and the on-device graph was exercised with pan + "Fit graph to view" only.

The tabs / code-block / foldable pass was verified on the same Pixel_Fold_API_36 emulator (dark mode, adb shell cmd uimode night yes) against the live server: :app:testDebugUnitTest reported 60 tests, 0 failures (including new WindowSizeTest for isWideLayout at 400/600/800 and DetailTabsTest for the tab lists and clampTabIndex) and :app:assembleDebug succeeded. The debug APK was installed and driven; captures were written to captures/tabs_pass/ (git-ignored): every run-detail tab (05_run_summary, 06_run_graph, 07_run_input, 08_run_output, 10_run_evidence, 11_run_steps), every pipeline-detail tab (01_pipeline_summary, 02_pipeline_graph, 03_pipeline_source), a long Input/Output block showing the themed card scrolling internally (07_run_input/08_run_output, whose block ScrollView measures the 320dp cap), a collapsed inner section (09_run_output_collapsed, "input, collapsed"), a step's expanded evidence code blocks (12_run_step_expanded) and the wide two-pane layouts with the vertical tab rail (13_wide_runs_split, 14_wide_run_summary, 15_wide_pipelines_split, 16_wide_pipeline_summary, 17_wide_pipeline_graph). Tab-selection persistence across a configuration change was exercised by switching wm density 390→401 with the run detail open; the selected tab stayed selected (18_before_config, 18_after_config). adb logcat for the app package contained no FATAL EXCEPTION and no Compose/other runtime exception.

The space-usage pass (collapsible icon rail, roomier Steps, rendered Source tab) was verified on the same Pixel_Fold_API_36 emulator (dark mode after adb shell cmd uimode night yes) against the live server at ws://10.0.2.2:8080/connect:

  • :app:testDebugUnitTest reported 76 tests, 0 failures (up from 60: new StageDetailSheetTest for the stage/step field derivation and StepMetaTest for the step metadata pairing + details predicate, plus the icon/rail-width assertions in DetailTabsTest and the file-change/notification formatting in FormatTest). :app:assembleDebug and :app:installDebug succeeded; the install reported Installed on 1 device (the emulator — no physical device was attached at install time).
  • Captures were written with adb -s emulator-5554 shell screencap -p /sdcard/shot.png followed by adb -s emulator-5554 pull (never exec-out … >), to captures/space_pass/ (git-ignored): narrow_pipeline_top_tabs (narrow window, tabs across the top), source_tab_narrow (rendered definition) and source_tab_raw_narrow (the Raw toggle revealing the exact markdown), wide_source_rail_expanded (icon+label rail, Source tab) and wide_source_rail_collapsed (icon-only rail, content visibly wider), wide_run_steps_expanded and wide_run_steps_expanded_rail_collapsed (a step with the two-column metadata grid — Status/Outcome, Duration/Visit, Target/Session — and full-width Input/ Output/File-changes/Transcript cards), plus wide_graph_stage_sheet (tapping a stage on the Graph tab still opens the refactored StageDetailSheet). No clipping, even step spacing and a height-filling Source tab were confirmed by eye.
  • Rail-collapse persistence across a configuration change was exercised by collapsing the rail on a detail screen and switching wm density 390→401: the activity recreated and the collapsed strip stayed collapsed (Expand tabs was still the control's description after the change; capture wide_detail_rail_collapsed_config_change). The saved tab index is clamped by clampTabIndex (unit-tested), so a stale index never indexes out of bounds.
  • The wide layout was exercised by resizing the emulated display (adb shell wm size 2000x3400, ≈820dp at density 390) and reset afterwards (wm size reset); the attached Pixel 10 Pro Fold was never used and no run was started from the app.
  • adb -s emulator-5554 logcat -d contained 0 FATAL EXCEPTION lines and 0 E AndroidRuntime lines. The emulator was stopped with adb emu kill; no qemu-system-aarch64-headless process survived.

Because adb cannot physically fold the phone, the wide two-pane/rail layout was exercised on the emulator by resizing the emulated display (adb shell wm size 2000x3400, ≈820dp at density 390) and the narrow single-pane layout at the default width (1080px ≈ 443dp); the attached Pixel 10 Pro Fold was not used to drive the app. Note that :app:installDebug installs to every connected device: that Gradle task therefore also (re)installed the debug APK on the attached Pixel 10 Pro Fold; all device-driving commands targeted the emulator serial (adb -s emulator-5554) explicitly. The emulator was stopped with adb emu kill plus kill -9 of the surviving qemu-system-aarch64-headless.

Distinct graph colours, Timeline + visit tabs, real list pane, floating pill

Four UI changes were verified on the same Pixel_Fold_API_36 emulator (dark mode after adb shell cmd uimode night yes) against the live server at ws://10.0.2.2:8080/connect. Nothing in the Pipelines server, its Go source, Docker/compose files or the installer was touched, no run was started from the app, and the attached Pixel 10 Pro Fold was never driven (the debug APK was installed with adb -s emulator-5554 install -r, not :app:installDebug, so the physical device was not re-installed by this pass either).

  • Graph colours. GraphPalette is a curated, fixed palette plus a pure deterministic outcome→index mapping (no hashCode() % 4). error stays the theme error role and success the theme tertiary (positive); every other outcome uses one palette colour for both its edge stroke and its label text. Node fills differ by kind (GraphNodeKind: terminal success, terminal failure, model, ntfy, other/custom); a selected stage inverts (light fill / dark text) plus a 4px border, and executed-vs-dimmed alpha still applies on top. WCAG contrast is measured: GraphPaletteTest checks the helper against known reference ratios (white/black 21, #777/white 4.48) and asserts every palette colour is ≥ 4.5:1 against DarkSurface 0xFF0E1513 (measured values range from 8.63:1, approved, to 13.78:1, fast; success 11.73:1 and error 10.89:1 as the dark scheme supplies them).
  • Timeline + visit tabs. The run-detail Steps tab is renamed Timeline (key kept steps); it renders one compact line per recorded visit (stage, visit number, outcome chip, duration and a brief diagnostic/target description) and nothing else — the heavy evidence moved entirely into the shared StageDetailSheet. The sheet now takes a stage's ordered runSteps plus an initialVisitIndex and shows a visit 1..N tab row only when there is more than one visit; the timeline opens on the tapped visit and the graph on the most recent. runStepFields gained the step Input/Output blocks, so the sheet still carries status, outcome, duration, visit/max/limit, model target, target, session, agent, diagnostic, transcript, input, output, file changes, notifications and the stage definition.
  • Real list pane. Pipelines and runs now share one ListRow (a single flat Surface, thin HorizontalDivider, leading element + title + secondary line, no per-row elevation) instead of a card per item. The selected row uses the same tonal secondaryContainer/onSecondaryContainer treatment as the tab rail and destinations, exposed as selectable selected state; opening a row selects it and Back clears it. The wide list pane collapses to a 56dp strip (rememberSaveable), with the freed width going to the detail.
  • Floating destination pill. The bottom NavigationBar is replaced by a floating rounded Surface at the bottom right holding the three destinations as 48dp icon targets, inset by the Scaffold's system-bar padding plus 16dp; selected state is a tonal circle plus Role.Tab selected semantics (not colour alone). The same pill is used on both window widths (no compact strip); the app reserves 88dp at the bottom so no scrollable content is hidden behind it.
  • Icons. Icons are taken from material-icons-extended (already declared in app/build.gradle.kts/libs.versions.toml, BOM-managed — no new dependency and no non-offline Gradle invocation was needed; the artifact was already in the cache). Mapping: Pipelines → AccountTree, Runs → History, Settings → Settings; Graph tab → Hub, Timeline → AutoMirrored.List, Input → AutoMirrored.Input, Output → AutoMirrored.Send, Evidence → AutoMirrored.FactCheck, Source → Code; run statuses → Running AutoMirrored.DirectionsRun, Queued Schedule, Succeeded CheckCircle, Failed Error, Canceled Cancel, Interrupted PauseCircle, Active Bolt, Unknown AutoMirrored.HelpOutline. The debug APK is ~17 MB; note that app/build.gradle.kts sets release { isMinifyEnabled = false }, so R8 does not strip unused extended icons in the current release config (that stripping only applies to a minified build).
  • :app:testDebugUnitTest reported 93 tests, 0 failures (new GraphPaletteTest, TimelineTest, PipelinesNavTest; extended StageDetailSheetTest and DetailTabsTest; StepMetaTest was removed with the inline metadata grid it covered). :app:assembleDebug succeeded.
  • Captures were written with adb -s emulator-5554 shell screencap -p /sdcard/shot.png followed by adb -s emulator-5554 pull (never exec-out … >), to captures/nav_timeline_pass/ (git-ignored): 01_launch, 02_runs_narrow (narrow lists + pill), 04_timeline (the concise Timeline tab), 05_sheet_from_timeline_visits (sheet from the timeline opening on the tapped visit 1, with visit tabs), 05b_sheet_single_visit_no_tabs (a single-visit stage shows no tab row), 06_sheet_run_section (Input/Output in the sheet), 07_run_graph (executed route highlighted), 08_sheet_from_graph (same stage opened from the graph, on the most recent visit 2), 09_pipeline_4stage_graph + _2x, 10_pipeline_1stage_graph + _2x, 11_wide_pane_expanded, 12_wide_pane_selected, 13_wide_pane_collapsed, 14_wide_runs_pane, 15_wide_run_detail, and the icon close crops 16_pill_wide_2x, 17_tabs_wide_2x, 18_runstatus_icons_2x, 18b_failed_status_2x, 19_pill_narrow_2x.
  • adb -s emulator-5554 logcat -d contained 0 FATAL EXCEPTION lines and no Compose runtime exception. The wide layout was exercised with adb shell wm size 2000x3400 (≈820dp at density 390); the emulator was stopped with adb emu kill plus kill -9 of any surviving qemu-system-aarch64-headless.

Per-visit artifacts, collapsed defaults, single top inset, APK publish (15 Oct 2026)

Four changes were implemented in android/ only. Nothing in the Pipelines server, its Go source, Docker/compose files or the installer was touched, no run was started from the app, and the 8 MiB per-file artifact cap (internal/server/artifacts.go maxArtifactFileBytes) was left unchanged.

  • Artifacts. RunStep now models the server's artifacts (StageArtifact{name, size_bytes, content_type, url}), artifacts_skipped and artifacts_truncated with the exact internal/protocol/runs.go wire names. ui/graph/Artifacts.kt renders one row per file (name, humanBytes size, content type) with an open (ACTION_VIEW) and a copy-link action, an inline image thumbnail (OkHttp + BitmapFactory with inSampleSize off the main thread, bytes cached once per URL) and a full-size view on tap; other types get a type icon. URLs are resolved by ServerUrl.resolveArtifactUrl against the configured server URL (ws→http/wss→https, /connect dropped), never a hardcoded host; with no URL configured the actions are disabled and a hint is shown. Empty/partial states reuse the TUI strings from internal/tui/file_changes.go. The Timeline rows carry a subtle AttachFile indicator (hasArtifacts) with a per-visit contentDescription.
  • Collapsed defaults + self-describing titles. SectionExpansionState now persists the set of expanded keys (default empty), so every inner section in the run detail (input/output/evidence) and pipeline detail (Versions, Source) starts collapsed while operator choices still survive configuration changes. Evidence section titles are built by evidenceSectionTitle, e.g. Evidence - step 4, ui_reviewer visit 1, opencode, correlating SessionEvidence.sequence with the run's steps once per data change; a blank field key already falls back to its prefix and never yields an empty title.
  • Top inset. The outer Scaffold in PipelinesApp now uses contentWindowInsets = WindowInsets(0, 0, 0, 0) so the inner Material 3 app bars own the status-bar inset exactly once (removing the duplicate top band); the floating pill clears the navigation bar via windowInsetsPadding(WindowInsets.navigationBars). While the connection banner is visible it owns the status-bar inset (padding inside its Surface) and the NavHost below consumes statusBars so the app bar is not double-padded.
  • APK publish. :app:assembleDebug produced app/build/outputs/apk/debug/app-debug.apk (18,181,943 bytes, sha256 41c9df314da40bb19df7e3d90f27a83339a275768cefee537c4ba796efe01eab, rebuilt after the follow-up fixes below), copied to ~/.local/share/pipelines/data/artifacts/58/1/pipelines-debug-d00bd37.apk (d00bd37 = short SHA of the last commit touching android/) with a matching shasum -a 256. At 17.3 MiB it exceeds the 8 MiB per-file inventory cap (internal/server/artifacts.go maxArtifactFileBytes = 8 << 20), so it is served by direct URL but deliberately absent from the step inventory.

Follow-up fixes (code review of the first pass)

  • ui/graph/Artifacts.kt hoists its derivations with remember(step) / remember(artifact.url, configuredServerUrl) / remember(artifact) so the summary text, the partial-capture notes, the resolved URL, the image test and the meta line are computed once per data change, never per recomposition.
  • ArtifactBytesCache is a byte-bounded LruCache (16 MiB) rather than an unbounded map, so a long session cannot retain every fetched artifact.
  • artifactCaptureNotes returns no notes for an empty artifact list, matching internal/tui/file_changes.go artifactLines (which returns nothing when the list is empty); the empty-state summary is unchanged.
  • The field-section title fallback is the pure fieldSectionTitle, covered by TimelineTest#fieldSectionTitleFallsBackToPrefixAndIsNeverEmpty.

Evidence actually obtained in this pass (macOS, JDK 17 from Homebrew openjdk@17, Gradle 8.11.1 from the wrapper cache, ANDROID_HOME=/Users/alan/Library/Android/sdk):

  • :app:testDebugUnitTest reported 103 tests, 0 failures (new ProtocolModelTest#runStepArtifactsParseWithExactWireNamesOrAbsent, FormatTest cases for humanBytes/artifactMetaLine/artifactsSummary/ artifactCaptureNotes, ServerUrlTest#resolvesArtifactUrlAgainstTheConfiguredServerUrl and resolveArtifactUrlReturnsNullWhenUnconfiguredOrBlank, DetailTabsTest#sectionsStartCollapsedAndToggleIsRemembered, and TimelineTest cases for hasArtifacts/evidenceSectionTitle/fieldSectionTitle).
  • :app:assembleDebug succeeded (18,181,943-byte debug APK).
  • :app:lintDebug still reports the two pre-existing NewApi errors for android:windowLightNavigationBar (minSdk 26) in res/values/themes.xml and res/values-night/themes.xml; those files were not modified by this change.

Verified against the live server (running as pipelines-server -addr 0.0.0.0:8080, the app configured ws://10.0.2.2:8080/connect; LAN address 10.0.0.249 from ipconfig getifaddr en0):

  • The published APK is served at http://10.0.0.249:8080/artifacts/58/1/pipelines-debug-d00bd37.apk (LAN), not a hardcoded localhost/10.0.2.2 host. curl -I returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 18181943; a streamed GET piped to shasum -a 256 returned 41c9df314da40bb19df7e3d90f27a83339a275768cefee537c4ba796efe01eab, equal to the local app-debug.apk.
  • Run 55 step 4's real artifacts are served: curl -I http://10.0.0.249:8080/artifacts/55/4/graph_crop_error_rejected.png → 200, image/png, 52,168 bytes and .../swatch_error_vs_rejected.png → 200, image/png, 5,008 bytes.
  • The server has no HTTP inventory endpoint (only GET /artifacts/…, GET /healthz, GET /connect); the step inventory is delivered over the websocket and clips entries larger than maxArtifactFileBytes (8 MiB), so the 17.3 MiB APK is intentionally absent from it.

Not verified in this pass — no device was attached (adb devices listed no devices, and no emulator was running): the on-device/emulator narrow/wide before/after screenshots for the top inset and the collapsed sections, the logcat sweep and the install on the Pixel 10 Pro Fold. The previous pass's emulator screenshots for the artifacts sheet (narrow/wide run detail) are in ~/.local/share/pipelines/data/artifacts/58/3/.

Sliding master/detail, right-opening sections, no collapse (15 Oct 2026)

Superseded by the pane-stack pass below (same day): the shared host is now ui/components/SlidingPaneStack.kt (three levels), Back no longer steps the section index, and the stage detail is a pane — there is no SlidingMasterDetail.kt, RightSlidingPanel or ModalBottomSheet in the tree. The bullets and evidence here record what that pass did at the time.

The collapse-based master/detail interaction was replaced by a sliding one, in android/ only. No Pipelines server/Go/Docker/installer file was touched, no run was started from the app, and colours, the graph and the information shown are unchanged — only the navigation model and its geometry.

  • Removed, not repaired. CollapsedListPane, the onTogglePane parameter and the "Collapse list pane" IconButton on both list top bars, LIST_PANE_WIDTH (360.dp) and COLLAPSED_LIST_PANE_WIDTH (56.dp), and the observed-side rail collapse (RailToggle, railWidthDp, COLLAPSED_RAIL_WIDTH_DP, WIDE_RAIL_WIDTH_DP collapse branch, "Collapse tabs") are all gone; the wide rail is always visible as the section index. ui/CollapseRemovalTest.kt scans src/main/java for those identifiers and fails if any return. The old full-screen pipeline/{id}/{version} and run/{id} routes were removed, so destinationSelected is a plain route equality.
  • One shared host, one slide. ui/components/SlidingMasterDetail.kt is used by both the Pipelines and Runs destinations at both window widths: the list fills the window and the detail overlays it, sliding in from the right via a single animateDpAsState(spring()) until a peek strip stays visible; a rapid run of taps only retargets that one animator, so the pane always settles fully open or fully closed (never half-slid). The detail width is measuredWidth - peek (never hardcoded) and the list behind is hidden from accessibility and made non-interactive while the detail is open, so TalkBack focus follows the visible pane and a tap can never select a row through the peek.
  • The peek geometry is derived, with one named token. PEEK_WIDTH_DP (56.dp) is the only new dimension literal; the actual peek is peekWidthDp(minimumInteractive, startInset) = maxOf(PEEK_WIDTH_DP, minimumInteractive + startInset), so the tappable strip left after the left system-gesture inset is still at least LocalMinimumInteractiveComponentSize (48dp). The strip is positioned clear of the status/nav bars and the gesture area by offsetting/­sizing it with WindowInsets.systemBars ∪ WindowInsets.systemGestures (read once per layout), and it carries the content description "Back to list". No other numeric literals were added (the animation uses the default spring() with no literal).
  • Sections open to the right. DetailTabs keeps the index fixed in place and moves the section bodies into a HorizontalPager (compose-foundation, already in the BOM): a tap or a swipe slides the section in, later sections from the right and earlier ones from the left. Back (ui/PaneState.kt backStep) is one level — section > 0 → previous section, section 0 → list, list → app exit — and the peek tap, the detail's back arrow and the system Back button/gesture all run that same step. PredictiveBackHandler handles the gesture; android:enableOnBackInvokedCallback="true" was added to the manifest.
  • Saved state. PaneSelection (pane, item id/version, section index) is all primitives with a Saver, so the open pane and selected section survive rotation, configuration change and process death. rememberPagerState also saves the pager page.
  • Secondary surface. The wide stage-detail overlay reuses the same right-slide (RightSlidingPanel); on a narrow window it deliberately keeps its ModalBottomSheet (a right panel on a phone-width window would crowd the content, and the sheet is the platform-appropriate narrow surface). The overlay is hosted at the screen level, a sibling of the tabs, so it covers the whole detail pane rather than being nested inside a pager page (a pager-nested copy sized to zero). The pure helpers in StageDetailSheet.kt are unchanged, so no information changed.

Evidence obtained in this pass (macOS, JDK 17 from Homebrew openjdk@17, Gradle 8.11.1 from the wrapper cache, ANDROID_HOME=/Users/alan/Library/Android/sdk):

  • :app:testDebugUnitTest reported 112 tests, 0 failures (new PaneStateTest — pane open, backStep at section > 0 / section 0 / list, section ordering and slide direction, Saver round trip and primitive payload; new CollapseRemovalTest; new SlidingMasterDetailTest for peekWidthDp; DetailTabsTest updated and PipelinesNavTest updated for the removed routes).

  • :app:assembleDebug succeeded. :app:lintDebug still reports only the two pre-existing NewApi errors for android:windowLightNavigationBar (minSdk 26) in res/values/themes.xml and res/values-night/themes.xml; those files were not modified.

  • grep over app/src/main for the banned collapse identifiers returned nothing.

  • The debug APK was installed and driven on the attached Pixel 10 Pro Fold (adb -s 58281FDCG000JF, inner display 2076x2152, density 330 ≈ 1006dp wide) against a live server (ws://10.0.0.249:8080/connect):

    • Tapping a pipeline row slid the detail in; uiautomator dump showed the "Back to list" strip at [61,185][160,1904] (48dp wide, offset past the ~30dp left gesture inset and below the status bar) with the list rows absent from the accessibility tree; tapping the strip's centre closed the detail and restored all nine rows. A tap in the gesture area (x = 30 < 61) selected no row (the list is blocked).
    • Tapping the Graph rail tab (and the narrow top tab row) changed the section while the rail/tab row and the strip stayed in place; the selected rail node exposed selected="true".
    • adb shell input swipe 5 1000 900 1000 250 (predictive-back gesture) closed the detail at section 0, and from Source (section 2) stepped back to Graph (section 1) — one level.
    • A live wm density change 330 → 300 → 330 kept the pane open and the section selected; the narrow layout (wm size 1080x2340, ≈524dp) showed the full-width list, the top tab row index and a 48dp strip, and both the section tab and the strip back worked there.
    • adb logcat for the package contained no FATAL EXCEPTION or AndroidRuntime error during the sweep, and no run was started from the app.
  • :app:testDebugUnitTest and the APK build were re-run after the final code change; the beats above are the final-build run.

    • The wide sequence was captured to captures/ (git-ignored) and mirrored to the run artifacts: slide-W1-list, slide-W2-detail-peek (detail slid in, 48dp strip on the left), slide-W3-section (Graph tab selected, index still in place), slide-W4-back-section (strip tapped once, back to Summary) and slide-W5-closed-list (strip tapped again, list restored, byte-identical to slide-W1-list); the narrow window (wm size 1080x2340, ≈524dp) has the same set slide-N1…slide-N5 (top tab row, N3 graph, N4 back to Summary, N5 closed, identical to N1).
    • The wide stage-detail overlay was driven from both entry points: tapping a timeline row (W8-timeline, W7-stage-overlay: the panel slid in with the "Close stage details" strip at [221,477][320,1838], the planner heading and the Definition section, dismissed by tapping the strip) and tapping a graph node (W9-graph-stage-overlay).
  • APK publish. app/build/outputs/apk/debug/app-debug.apk (18,184,868 bytes, sha256 7942795c1d979a66e4759a0c3e3f0399d60e256b29ba4a7266dfc52142245ac8) was copied to ~/.local/share/pipelines/data/artifacts/59/2/pipelines-debug-059c85a.apk (059c85a = git log -1 --format=%h -- android/). curl -I http://10.0.0.249:8080/artifacts/59/2/pipelines-debug-059c85a.apk (LAN address from python3 scripts/lan-address.py, never localhost/10.0.2.2) returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 18184868; a streamed GET | shasum -a 256 returned 7942795c1d979a66e4759a0c3e3f0399d60e256b29ba4a7266dfc52142245ac8, equal to the local file. At 17.3 MiB it exceeds the 8 MiB per-file inventory cap (internal/server/artifacts.go), so it is served by direct URL only.

Not verified in this pass: onOpenRun from a pipeline detail to a freshly started run cannot be exercised without starting a run, so that path is kept compiling and functional but untested; the predictive-back gesture's frame-by-frame preview is not driven through adb, so its behaviour (one level back) is verified but not its animation; a real hardware fold to the narrow cover display was not exercised (narrow was produced with wm size); the emulator (emulator-5554) was not used, the physical Pixel was.

Superseded by the adaptive pane navigation pass below (same day): the stack is now SlidingPaneStack(depth, wide, …) with a single fixed peek budget (PEEK_BUDGET_DP) shared between covered panes, and a narrow window shows no peek at all. The paneOffsetDp/peekWidthDp helpers named here no longer exist; the bullets record what that pass did at the time.

This pass turned the stage detail into a real pane, made the stack behave like Back at every level, and added an artifacts gallery to the summary.

  • The stage detail is a pane, not a popup. StageDetailSheet and its ModalBottomSheet/RightSlidingPanel branches are gone. StageDetailPane (ui/graph/StageDetailPane.kt) is the stage level of the stack, wrapped in the same Scaffold/TopAppBar with a back arrow as the other panes. Both entry points — a Timeline row and a graph node — now set PaneSelection(pane = Stage, stageKey, stageVisit) and open it as the rightmost pane; the covered graph/timeline is hidden from accessibility and blocked, so nothing leaks through.
  • Headline-first content. The identity/result facts (Status, Outcome, Target, Duration, Visit, Model target; STAGE_HEADLINE_LABELS) are rendered outside any collapsible, so a freshly opened pane never reads as empty. Definition, Input, Output, Artifacts and the remaining run evidence are collapsible via the shared SectionHeader + rememberSectionExpansion(stageKey). runStepFields, stageDefinitionFields, StageFieldRow, StageTypeChip, controlVisitLabel, numberFields/terminalFields and the visit tab row are all kept.
  • One three-level stack. ui/components/SlidingPaneStack.kt replaces SlidingMasterDetail: pane 0 fills the host, panes 1 and 2 overlay it at paneOffsetDp(level, peek) = peek * level and paneWidthDp(hostWidth, level, peek) = hostWidth - peek * level (derived from the one named PEEK_WIDTH_DP token and the measured width; no new offsets). Each covered pane keeps exactly one peek visible and its peek strip is tappable, calling onPopTo(level) to close every pane to its right. MasterPane { List, Detail, Stage }, depth, MAX_PANE_DEPTH = 2, backStep (one pane per step, no section stepping) and popTo(selection, level) are the pure model; PaneSelection carries stageKey/stageVisit and its saver encodes six primitives.
  • Back and the outside tap agree. PredictiveBackHandler is enabled for depth >= 1 and the system Back button/gesture, the peek tap and the pane's back arrow all run the same one-level step; backStep(Stage) → Detail, backStep(Detail) → List, list → app exit.
  • Artifacts gallery. ui/ArtifactGroups.kt has the pure runArtifactGroups(steps) (grouped by stage then visit from runTimeline, stable order, duplicate names kept, empty run → empty) and artifactsEmptyMessage(executing). ArtifactGallery (ui/graph/Artifacts.kt) renders each group's image artifacts as a non-lazy chunked grid of thumbnails (a tap opens the full-size dialog) and its non-images as rows with name, humanBytes size, content type and open/copy; the Summary tab shows the run gallery and the stage pane's Artifacts section shows that visit's group plus the unchanged Artifacts · N recorded summary and capture notes. Every url resolves through ServerUrl.resolveArtifactUrl (no hardcoded host), and ArtifactImage/ArtifactBytesCache remain the single loader.

Evidence obtained in this pass (macOS, JDK 17 from Homebrew openjdk@17, Gradle 8.11.1 from the wrapper cache, ANDROID_HOME=/Users/alan/Library/Android/sdk, --offline):

  • gradle :app:testDebugUnitTest reported 122 tests, 0 failures (rewritten PaneStateTest — three levels, depth, MAX_PANE_DEPTH, backStep at each level, popTo levels and the six-primitive saver; renamed SlidingPaneStackTest — peekWidthDp plus paneOffsetDp/paneWidthDp; new ArtifactGroupsTest — grouping/order, duplicates kept, empty run, visit numbers vs runTimeline, running-vs-finished empty message; StageDetailSheetTest gained the headline/evidence split assertions). CollapseRemovalTest still passes.
  • gradle :app:assembleDebug succeeded (18,198,400 bytes). gradle :app:lintDebug still reports only the two pre-existing NewApi errors for android:windowLightNavigationBar in res/values/themes.xml and res/values-night/themes.xml.
  • rg -n 'ModalBottomSheet|StageDetailSheet' android/app/src/main and rg -n 'https?://' android/app/src/main/java/net/awan/pipelines/ui/graph both return nothing; git diff --stat shows no change under android/gradle or the build.gradle.kts dependency blocks.
  • On emulator-5554 (2076x2152, density 390 ≈ 851dp wide; never the attached Pixel) against the live server ws://10.0.0.75:8080/connect (LAN address from python3 -c importing scripts/lan-address.py; the script has no __main__, so it prints nothing when run directly):
    • Summary of run 58 showed the grouped gallery (reviewer · visit 1 header, then a grid of Preview of …png); tapping a thumbnail opened the full-size dialog (02_sheet_ui_reviewer_top.png); a non-image row showed EVIDENCE.md, 3.0 KiB · text/plain; charset=utf-8, Open/Copy enabled="true".
    • Tapping the Timeline row reviewer · visit 1 opened the stage pane as level 2 with two peeks visible (Back to runs at [73,165][190,1859], Back to run at [190,165][380,1859]) and the headline facts shown unexpanded (reviewer/model, Status completed, Outcome rejected, Duration 7m 41s, Visit 1 / 3, Target implementer); Definition/Input/Output/Artifacts/This run were collapsed. Tapping the graph node Stage reviewer opened the same pane (Status completed, Outcome success, Visit 2 / 3, Target ui_reviewer).
    • Tapping the detail peek (285 1000) → depth 1 (Back to runs only); tapping the list peek (130 1000) → depth 0 (list, no strips). input keyevent 4 at depth 2 → depth 1, at depth 1 → depth 0; the predictive-back swipe input swipe 5 1000 900 1000 250 at depth 2 → depth 1.
    • settings put system user_rotation 1 (config change) kept depth 2 and the reviewer/visit 1 selection; after am kill net.awan.pipelines (verified pidof empty) the relaunch restored the same depth and selection.
    • The stage pane's Artifacts section expanded to Artifacts · 6 recorded plus the visit's thumbnails; run 60 (executing) showed the run empty state Artifacts · capture pending.
    • adb logcat -d | grep -c 'FATAL EXCEPTION' and … | grep -c 'E AndroidRuntime' both returned 0; no run was started from the app.
  • APK publish. app/build/outputs/apk/debug/app-debug.apk was copied to …/artifacts/60/2/pipelines-debug-059c85a.apk (059c85a = git log -1 --format=%h -- android/); shasum -a 256 matched. curl -I http://10.0.0.75:8080/artifacts/60/2/pipelines-debug-059c85a.apk returned 200 with Content-Type: application/vnd.android.package-archive and a Content-Length; a streamed GET | shasum -a 256 equalled the local file. At 17.3 MiB it exceeds the server's 8 MiB per-file inventory cap, so it is served by direct URL only.

Not verified in this pass: a different graph node tapped while the stage pane is open is not reachable because the covered graph is intentionally blocked, so the "selection replaces the rightmost pane at depth 2" invariant is covered by the PaneStateTest bound/popTo tests rather than by a device tap; the unconfigured (disabled open/copy) gallery row and the finished-run "no artifacts recorded" empty state were not exercised (only the running "capture pending" one); the predictive-back animation frames and pinch-zoom were not driven through adb; the narrow layout was not separately exercised (the stage pane no longer branches on width); the physical Pixel was not touched.

A review of the pane-stack pass found the gallery grid used a fixed 96dp tile (ARTIFACT_TILE_DP) in three columns, so the row overflowed a narrow (phone) pane and clipped the third thumbnail. Fixed in ui/graph/Artifacts.kt:

  • Derived tile size. ArtifactGallery now measures the row once with BoxWithConstraints and calls the pure artifactTileDp(availableWidth, columns, spacing, preferred) (the widest that fits, capped at the preferred ARTIFACT_TILE_DP), so three tiles and their gaps always fit the pane. The only new named token is ARTIFACT_TILE_SPACING_DP (8.dp), shared by the row arrangement and the fitting; no magic offsets.
  • Dead code removed. ArtifactRow no longer carries an unreachable image branch (the gallery passes it only non-image artifacts); it renders the file glyph, name and artifactMetaLine with open/copy.
  • No duplicated derivation. runArtifactGroups reuses runTimeline's display visit number (entries → (stage, sequence) → visit) instead of re-deriving control.visit ?: index + 1.
  • Docs corrected. The current-architecture bullet and the superseded SlidingMasterDetail/RightSlidingPanel/ModalBottomSheet references above were updated; the previous pass's section is marked superseded.
  • New unit test ui/graph/ArtifactGalleryTest: narrow width shrinks the tile so the row never overflows, a width that fits keeps the preferred tile, exact fit and degenerate inputs.

Evidence obtained in this follow-up (macOS, JDK 17 from Homebrew openjdk@17, Gradle 8.11.1 from the wrapper cache, ANDROID_HOME=/Users/alan/Library/Android/sdk, --offline):

  • gradle :app:testDebugUnitTest reported 127 tests, 0 failures, 0 errors (the 5 new ArtifactGalleryTest cases included); CollapseRemovalTest still passes. gradle :app:assembleDebug succeeded (17,830,569 bytes). gradle :app:lintDebug still reports only the two pre-existing NewApi errors for android:windowLightNavigationBar in res/values/themes.xml and res/values-night/themes.xml.
  • rg -n 'ModalBottomSheet|StageDetailSheet|RightSlidingPanel|SlidingMasterDetail' android/app/src/main and rg -n 'https?://' android/app/src/main/java/net/awan/pipelines/ui/graph both return nothing; git diff --stat shows no change under android/gradle or the build.gradle.kts dependency blocks.
  • On emulator-5554 (never the attached Pixel) against the live server ws://10.0.0.75:8080/connect:
    • Run 58 Summary showed the gallery grouped by stage/visit; at the wide (851dp, density 390) size the tiles measured 234px (96dp).
    • Setting wm size 1080x1920 + wm density 480 (360dp): the Summary gallery's three tiles measured 78dp and the third's right edge ([798,492][1032,582] → x=1032) coincided with the pane content edge — no clipping. In the depth-2 stage pane (Artifacts, expanded) the three tiles measured 52dp ([516,796][672,952], [696,…][852,…], [876,…][1032,…]) and also reached the pane edge exactly; the non-image emulator.log row showed 10.8 KiB · text/plain; charset=utf-8 with enabled Open/Copy.
    • Timeline row → stage pane (depth 2, two peeks) and graph node → stage pane both opened with the headline facts visible (reviewer/model, Status completed, Outcome rejected/success, Duration, Visit, Target) and every other section collapsed. Detail peek (285 1000) → depth 1; list peek (131 1000) → depth 0; input keyevent 4 at depth 2 → depth 1 and at depth 1 → depth 0; the predictive-back swipe input swipe 5 1000 900 1000 250 at depth 2 → depth 1.
    • A wm density 480 → 440 change kept depth 2 with the reviewer visit-1 selection and the expanded Artifacts section; after am kill net.awan.pipelines (verified pidof empty) and relaunch, the same depth and selection returned.
    • adb -s emulator-5554 logcat -d contained 0 FATAL EXCEPTION and 0 E AndroidRuntime lines; no run was started from the app.
  • APK publish. app/build/outputs/apk/debug/app-debug.apk (17,830,569 bytes, sha256 6ac6004e9d4bc29d30457cc99009c226df7157dae2b41f07fa7c8a7a46a40498) was copied to …/artifacts/60/4/pipelines-debug-059c85a.apk (059c85a = git log -1 --format=%h -- android/); shasum -a 256 matched. curl -I http://10.0.0.75:8080/artifacts/60/4/pipelines-debug-059c85a.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 17830569; a streamed GET | shasum -a 256 equalled the local file.

Not verified in this follow-up: a different graph node tapped while the stage pane is open (the covered graph stays blocked, so the replace-the-rightmost invariant is covered by the PaneStateTest bound/popTo tests only); the explicit gallery empty states (the run 60 card already carried artifacts during this sweep, so neither the "capture pending" nor the finished "no artifacts recorded" message was seen on device — both are covered by ArtifactGroupsTest/artifactsEmptyMessage); the unconfigured (disabled open/copy) gallery row; the predictive-back animation frames and pinch-zoom (adb cannot drive a two-finger pinch).

Adaptive pane navigation and a fixed peek budget (15 Oct 2026)

The pane stack was made adaptive to the window width and its peek space changed from one peek per level to a single fixed budget shared between the covered panes. android/ only; nothing in the Pipelines server, its Go source, the Docker/compose files, the installer or the dependency blocks was touched, no run was started from the app, and the attached Pixel 10 Pro Fold was never installed on or driven (the debug APK was installed with adb -s emulator-5554 install -r).

  • Narrow windows: no stack, no peek. SlidingPaneStack gained a wide parameter (the callers pass the existing isWideLayout value). On a narrow window the peek budget is 0.dp, so every pane's open offset is 0 and each pane is a full-window screen; a covered pane is fully hidden, there is no strip and nothing is left over on the left. Tapping a list row or a stage/graph node opens the pane with the existing spring() slide from the right edge; Back, the predictive-back gesture and the pane's own top-bar back control all run the same one-level backStep.
  • Wide windows: one fixed peek budget. The total space the covered panes reserve is PEEK_BUDGET_DP (224.dp, a named token), never peek * level, so the stack consumes the same width however deep it gets. paneOpenOffsetsDp places the active pane at exactly the budget — its width is therefore hostWidth - budget at every depth, constant as levels are added — and shares the budget between the covered panes, widening the leftmost strip first so that after the left gesture inset (systemBars ∪ systemGestures) its tappable part is still at least PEEK_WIDTH_DP (56.dp) and the platform minimum interactive size, then splitting the rest evenly. At two levels the one covered pane takes the whole budget; at three the budget is split in two; at four (four panes, three covered) it is split in three.
  • Named tokens, no literals. PEEK_WIDTH_DP (56.dp), PEEK_BUDGET_DP (224.dp) and MIN_ACTIVE_PANE_WIDTH_DP (320.dp) live beside the stack; peekBudgetDp clamps the budget so the active pane never collapses on a small host (hostWidth - MIN_ACTIVE_PANE_WIDTH_DP), and paneWidthDp is never negative. Everything else is derived from the measured width and the insets.
  • Both models keep the other pane rules: opening and closing are exact mirrors (the same offsets and spring() retarget in reverse), panes are opaque, the peek strips are inset inside the status/nav bars and the gesture area, and a section inside a detail is a selection on its own tab row, never a navigation level.

Evidence obtained in this pass (macOS, JDK 17 from Homebrew openjdk@17, Gradle 8.11.1 from the wrapper cache, ANDROID_HOME=/Users/alan/Library/Android/sdk, --offline):

  • gradle :app:testDebugUnitTest reported 130 tests, 0 failures, 0 errors (the rewritten SlidingPaneStackTest has 8 cases: narrow spends no peek at any depth, the wide active pane's width is constant across depths, four levels share the one fixed budget with every strip at least the named minimum, the first strip clears the gesture inset, the budget clamps so the active pane never collapses, a tiny host never yields negative geometry, offsets are monotonic and deterministic, and widths are host-less-offset and never negative).
  • gradle :app:assembleDebug succeeded (17,990,397-byte debug APK, sha256 b7ba9d600031f09472b06fff4c06cd50ec93b995cf7b1f7bf8a2115846a8e602).
  • On emulator-5554 (2076x2152, density 390 ≈ 852dp wide; never the attached Pixel) against the live server ws://10.0.0.75:8080/connect, driven with adb shell input and uiautomator dump:
    • Wide, uiautomator dump of the peek strips: at two levels the single strip was [73,165]–[546,1859], i.e. [30dp, 224dp] — the whole budget after the ~30dp left gesture inset; at three levels the two strips were [73,165]–[273, 1859] and [273,165]–[546,1859], i.e. [30dp,112dp] and [112dp,224dp]. The active pane therefore starts at 224dp at both depths — its width is constant — and the two covered strips sum to the same 224dp budget.
    • Narrow (wm size 1080x1920, wm density 480, ≈360dp): the list, the detail and the stage pane each filled the window (uiautomator dump listed no Back to … strips at any depth), a row tap opened the detail (Summary tab present) and the predictive-back swipe input swipe 5 1000 900 1000 250 returned to the list.
    • adb -s emulator-5554 logcat -d contained 0 FATAL EXCEPTION and 0 E AndroidRuntime lines after a clean sweep; no run was started from the app.
    • Screenshots and recordings were written to the run's artifacts directory: wide-1-level-list.png, wide-2-levels-detail.png, wide-3-levels-stage.png, narrow-1-level-list.png, narrow-2-levels-detail.png, narrow-3-levels-stage.png, wide-open-close.mp4 (opening two and three levels then closing) and narrow-open-close.mp4 (opening and closing the detail). The four-level layout (four panes, three covered) is not reachable in the app, which has exactly three pane levels (MasterPane.List/Detail/Stage); the shared budget at four levels is covered exactly by the SlidingPaneStackTest geometry cases instead.
  • APK publish. app/build/outputs/apk/debug/app-debug.apk was copied to …/artifacts/61/1/pipelines-debug-wip-5314542.apk (5314542 = git rev-parse --short HEAD); shasum -a 256 matched. curl -I http://10.0.0.75:8080/artifacts/61/1/pipelines-debug-wip-5314542.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 17990397; a streamed GET | shasum -a 256 equalled the local file. At 17.2 MiB it exceeds the server's 8 MiB per-file inventory cap, so it is served by direct URL only.

Not verified in this pass: the four-level layout on a device (unreachable — the app has three pane levels); the predictive-back animation frames (adb cannot drive a two-finger pinch and the frame-by-frame preview is not captured); the wide recording's final close-detail frame lands at the end of the clip. The narrow layout was produced with wm size/wm density (a real hardware fold was not exercised).

Sections change in place, not sideways (15 Oct 2026)

Selecting a section in a run or pipeline detail now swaps the section body in place instead of sliding it in from the side. android/ only; nothing in the Pipelines server, its Go source, the Docker/compose files or the installer was touched, no run was started from the app, no dependency was added, and the attached Pixel 10 Pro Fold was not installed on or driven (every device command targeted emulator-5554).

  • In-place swap instead of a pager. ui/components/DetailTabs.kt no longer uses a HorizontalPager for the section bodies. The selected section cross-fades in place behind a Crossfade (SECTION_SWAP_MILLIS = 180), so a tap on the rail/tab row is an ordinary tab change with no lateral motion and nothing to swipe. Crossfade comes from androidx.compose.animation:animation, already on the compile classpath transitively via androidx.compose.foundation (no new dependency was declared; gradle/libs.versions.toml and the dependency blocks are unchanged). Only the selected section is composed at rest.
  • Level navigation still slides. The SlidingPaneStack (list → detail → stage pane) is untouched, so navigation between levels keeps its spring() slide; only the section selector inside a detail changed.
  • The rail's selected state is kept. The narrow PrimaryScrollableTabRow and the wide selectable rail are unchanged; selection is still Role.Tab + selected semantics plus the tonal container, never colour alone.
  • A section's scroll position is not reset on return. Each section's saved state (its LazyColumn scroll) is kept under its stable tab key with rememberSaveableStateHolder().SaveableStateProvider(tab.key), so leaving and returning to a section restores where the operator left off (this matches the previous pager's per-page saved state).
  • The two call sites' stale "pager composes only the visible section" comments were updated; no other behaviour changed.

Evidence obtained in this pass (macOS, JDK 17 from Homebrew openjdk@17, Gradle 8.11.1 from the wrapper cache, ANDROID_HOME=/Users/alan/Library/Android/sdk, --offline):

  • gradle :app:testDebugUnitTest :app:assembleDebug → BUILD SUCCESSFUL in 2s; the test-result XMLs aggregate to 130 tests, 0 failures, 0 errors, 0 skipped (the existing DetailTabsTest still covers the tab lists and clampTabIndex).
  • app/build/outputs/apk/debug/app-debug.apk is 17,990,397 bytes, sha256 ef467eaafd9cd7662167c17229a39281683aed6c890c48c9fabf0a1e3ed04172.
  • On emulator-5554 (2076x2152, density 390 ≈ 852dp wide; never the attached Pixel) against the live server ws://10.0.0.75:8080/connect (run 58, seven completed visits), driven with adb shell input:
    • A 13s screenrecord of tapping Summary → Graph → Input → Output → Evidence → Timeline (after-section-swap.mp4), with stills of each section (after-run-summary/graph/evidence/timeline.png): the rail's selected state moves and the body changes, and an extracted mid-transition frame (frame-3.65.png) shows the outgoing and incoming panels overlapping at the same x — a cross-fade, not a slide.
    • The same sequence on the pre-change build (built from HEAD in a throwaway git worktree, installed as a baseline) recorded as before-section-slide.mp4 and frame before-frame-2.05.png: the outgoing panel is visibly shifted left with the incoming panel entering from the right — the old lateral slide, by contrast.
    • Scroll preservation: Summary was scrolled down, Graph selected, then Summary re-selected; scroll-summary-returned.png matches scroll-summary-scrolled.png (Finished/Duration/Artifacts still on screen), not the top.
    • adb -s emulator-5554 logcat -d contained 0 FATAL EXCEPTION and 0 E AndroidRuntime lines; no run was started from the app.
  • APK publish. app-debug.apk was copied to ~/.local/share/pipelines/data/artifacts/62/1/pipelines-debug-wip-0b373d0.apk (0b373d0 = git rev-parse --short HEAD); shasum -a 256 matched. curl -I http://10.0.0.249:8080/artifacts/62/1/pipelines-debug-wip-0b373d0.apk (LAN address from ipconfig getifaddr en0, never localhost/10.0.2.2) returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 17990397; a streamed GET | shasum -a 256 returned ef467eaafd9cd7662167c17229a39281683aed6c890c48c9fabf0a1e3ed04172, equal to the local file. At 17.3 MiB it exceeds the server's 8 MiB per-file inventory cap, so it is served by direct URL only.

Not verified in this pass: the cross-fade's exact duration/frames beyond the single extracted frame and the 180 ms spec; a real hardware fold (the wide layout is the emulator's default 852dp); the narrow top-tab-row presentation (the emulator was driven wide only) — the narrow selector code is unchanged and shared, so this is a presentation difference the existing WindowSizeTest/DetailTabsTest still cover where they can. The after-section-swap.mp4 frame is the only mid-transition sample taken; before-frame-2.05.png is the only baseline mid-slide sample.

Run stage pane: surface Model/Provider in the headline (16 Oct 2026)

The report was "the adaptive-panes change lost the stage screen's content: only the title, the model chip and one collapsed Definition remain". That symptom is the definition-only branch of StageDetailBody (selectedStep == null, i.e. no recorded visits). It is what a pipeline stage pane (PipelineStagePane, level 2 of the Pipelines destination) legitimately shows, and it is exactly what the run-61 artifacts (~/.local/share/pipelines/data/artifacts/61/1/wide-3-levels-stage.png, narrow-3-levels-stage.png) capture — those screenshots are the Pipelines destination, not the Runs one, so they are the expected definition-only look and not the regression. Re-driving the current build from the Runs destination does not reproduce the loss: from a Timeline row (implementer · visit 2, run 60) and from a graph node the pane showed Status/Outcome/Duration/Visit/Target, the visit tab row (visit 2 selected), and Definition/Input/Output/Artifacts/This run collapsed with their content on expansion. No regression was present at 791d3dd.

The one real gap against the requested headline facts was that the stage's recorded Model/Provider configs lived only inside the collapsed Definition section (they were always visible in the pre-pane sheet). They are now promoted to the always-visible headline, without duplication:

  • ui/graph/StageDetailPane.kt gained the pure STAGE_CONFIG_HEADLINE_LABELS ({"Model", "Provider"}), stageConfigHeadlineFields(definition) and remainingDefinitionFields(definition). StageDetailBody renders headlineFields(runFields) + stageConfigHeadlineFields(definition) as the headline and remainingDefinitionFields(definition) inside the collapsed Definition section, so a promoted row is never rendered twice. Both derivations are remember(definition)-keyed; the run-evidence split stays runStepFields/headlineFields/evidenceFields.
  • Deliberate change to account for: the Definition section (collapsed by default) no longer repeats Model/Provider, because they are now headline facts. Everything else in Definition is unchanged (Type, Prompt, Output, Outcomes, the other configs, Tools, limits, memory, notify).
  • StageDetailSheetTest gained definitionModelAndProviderArePromotedToTheHeadlineWithoutDuplication and aDefinitionWithNoConfigsPromotesNothing.

Evidence obtained in this pass (macOS, ANDROID_HOME=/Users/alan/Library/Android/sdk; gradle :app:testDebugUnitTest :app:assembleDebug under the default Homebrew JDK 27, lint under JDK 17 as noted):

  • gradle :app:testDebugUnitTest :app:assembleDebug → BUILD SUCCESSFUL; the test-result XMLs aggregate to 132 tests, 0 failures, 0 errors, 0 skipped. app/build/outputs/apk/debug/app-debug.apk is 17,991,256 bytes, sha256 2252e6964cd73f1d666da24f3684bd8e0b79cf3e07e0fdc018842a4f1cab2ccf.
  • gradle :app:lintDebug under JDK 17 fails only on the two pre-existing NewApi errors for android:windowLightNavigationBar in res/values/themes.xml and res/values-night/themes.xml (unchanged by this pass); under the default Homebrew JDK 27 the lint worker crashes at dispose (NoClassDefFoundError: org.jetbrains.uast.UastFacade), so JDK 17 is required.
  • On emulator-5554 (narrow 1080x1920/density 480 ≈ 360dp; wide 2076x2152/density 390 ≈ 852dp; never the attached Pixel) against the live server ws://10.0.0.75:8080/connect, driven with adb shell input, screenshots in ~/.local/share/pipelines/data/artifacts/64/2/:
    • narrow_run61_facts_collapsed.png / wide_facts_collapsed.png: the headline (Status/Outcome/Duration/Visit/Target/Model/Provider) unexpanded and all five sections collapsed.
    • narrow_run61_artifacts_expanded.png / wide_facts_artifacts_expanded.png: Artifacts expanded to Artifacts · 8 recorded · partial capture, the capture note and the thumbnail grid.
    • wide_facts_definition_expanded.png: Definition expanded with no duplicated Model/Provider row.
    • narrow_run60_visit_tabs_facts.png / narrow_run60_graph_node_stage.png: a multi-visit stage (visit 1/visit 2 tabs, starting on the tapped/most-recent visit) opened from a Timeline row and from a graph node, with the promoted Model/Provider.
    • previous_behaviour_nav_timeline_pass_05.png is the pre-pane sheet (android/captures/nav_timeline_pass/05_sheet_from_timeline_visits.png) for comparison. The run-60/4 artifact files used by its gallery are corrupt (their .png bytes begin with the adb screencap "Multiple displays" warning), so its thumbnails correctly show the ! decode-error placeholder; run 61's valid artifacts render normally.
    • adb -s emulator-5554 logcat -d | grep -c 'FATAL EXCEPTION' and … | grep -c 'E AndroidRuntime' each returned 0; no run was started from the app.
  • APK publish. app-debug.apk was copied to ~/.local/share/pipelines/data/artifacts/64/1/pipelines-debug-wip-791d3dd.apk (791d3dd = git rev-parse --short HEAD); shasum -a 256 matched. curl -I http://10.0.0.249:8080/artifacts/64/1/pipelines-debug-wip-791d3dd.apk (LAN address from ipconfig getifaddr en0, never localhost/10.0.2.2) returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 17991256; a streamed GET | shasum -a 256 returned 2252e6964cd73f1d666da24f3684bd8e0b79cf3e07e0fdc018842a4f1cab2ccf, equal to the local file.

Not verified in this pass: the reported "content lost" symptom could not be reproduced at 791d3dd, so there is no before/after diff of a fixed regression; the "definition-only, never-visited stage" and blank status/outcome edge cases are covered by the existing unit tests (StageDetailSheetTest, FormatTest) rather than driven on the device; the narrow/wide gallery thumbnail failure for run 60's corrupt artifacts is a data issue in that run, not re-tested against a repaired copy.

Covered panes show a compact identity, with a minimum peek width (16 Oct 2026)

A wide-window stack no longer squeezes a full pane into each covered peek: a covered pane now renders only its compact identity (a title and at most one status/subtitle, centred in its strip) and its full body — tab rail, list, gallery, scroll body — is never drawn into a sliver. android/ only; nothing in the Pipelines server, its Go source, the Docker/compose files or the installer was touched, no dependency was added, no run was started from the app, and the attached Pixel 10 Pro Fold was never installed on or driven (the debug APK was installed with adb -s emulator-5554 install -r).

  • Compact covered panes. SlidingPaneStack's pane lambda now receives a covered: Boolean; on a wide window a covered level is composed inside a box constrained to its visible strip, and the caller renders only ui/components/PaneIdentity.kt — a centred title plus at most one status/subtitle line. The list (PipelineListScreen/RunHistoryScreen), both detail screens and the stage pane each gained a covered branch that early-returns after their data-loading effects, so nothing heavy is composed into a sliver. The strip itself stays a separate, higher tappable sibling and the compact identity rides with the pane's own slide.
  • A named minimum covered width, and a fold. MIN_COVERED_PANE_WIDTH_DP (112.dp) is the least width a covered pane's compact identity needs. peekStripsDp shows at most budget / MIN_COVERED_PANE_WIDTH_DP covered peeks; when a stack has more covered levels than that, the oldest levels fold into a single edge indicator ("<n> more") rather than being squeezed below the minimum, and the number of peeks shown shrinks instead of their width. The fixed budget (PEEK_BUDGET_DP, 224.dp) and the constant active-pane width are unchanged.
  • Unchanged behaviour. Tapping a covered pane's peek calls the same onPopTo(level), closing everything to its right; Back/gesture/back arrow and the narrow (no-peek) layout are untouched.

Evidence (macOS, JDK 17 from Homebrew openjdk@17, Gradle 8.11.1, ANDROID_HOME=/Users/alan/Library/Android/sdk, --offline):

  • gradle :app:testDebugUnitTest reported 134 tests, 0 failures, 0 errors; gradle :app:assembleDebug succeeded (17,992,288-byte debug APK, sha256 3923224136be7ef9bdd8eb87111fae1f6af0211a7ba070af0e5270e324a0fc93). The rewritten SlidingPaneStackTest has 10 cases (narrow spends no peek, the wide active pane is constant width at every depth, two covered levels each keep the minimum, a fourth level folds the oldest into one indicator carrying its count, the newest level still peeks, the first strip clears the gesture inset, the budget clamps, a tiny host never goes negative, strips are monotonic and deterministic, and widths are host-less-offset).
  • On emulator-5554 (2076x2152, density 390 ≈ 852dp wide; never the attached Pixel) against the live server ws://10.0.2.2:8080/connect, driven with adb shell input and uiautomator dump:
    • Wide, uiautomator dump of the peek strips: at two levels the single strip was [73,165]–[546,1859] ([30dp, 224dp] after the ~30dp left gesture inset); at three levels the two strips were [73,165]–[273,1859] and [273,165]–[546,1859] ([30dp,112dp] and [112dp,224dp]), so the active pane still starts at 224dp (constant width) and each covered pane now keeps at least 112dp for its identity.
    • Narrowest wide size (wm size 1463x2152, density 390 = 600dp): the same 224dp budget, strips [73,127]–[273,1859] and [273,127]–[546,1859]; both compact identities stayed readable and the active pane was full.
    • Tapping the detail peek (409 1000) at three levels popped to the detail (only Back to pipelines left); tapping the list peek (173 1000) popped to the list (no strips). input keyevent 4 at depth 2 returned to depth 1 (one Back to pipelines strip).
    • Narrow (wm size 1080x1920, wm density 480, ≈360dp): opening a pipeline showed 0 Back to … strips and the detail tabs as before.
    • adb -s emulator-5554 logcat -d contained 0 FATAL EXCEPTION; no run was started from the app.
    • Screenshots were written to the run's artifacts directory: wide-2-levels.png (the list covered as Pipelines · 11 on this server), wide-3-levels.png (list and detail covered, stage active) and wide-narrowest.png (600dp); wide-2-levels-after-peek.png is the state after the peek tap.
  • APK publish. app/build/outputs/apk/debug/app-debug.apk was copied to …/artifacts/65/1/pipelines-debug-wip-206953e.apk (206953e = git rev-parse --short HEAD); shasum -a 256 matched. curl -I http://10.0.0.249:8080/artifacts/65/1/pipelines-debug-wip-206953e.apk (LAN address from ipconfig getifaddr en0) returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 17992288; a streamed GET | shasum -a 256 equalled the local file. At 17.2 MiB it exceeds the server's 8 MiB per-file inventory cap, so it is served by direct URL only.

Not verified in this pass: the four-level / folded layout on a device — the app has exactly three pane levels (MasterPane.List/Detail/Stage, MAX_PANE_DEPTH = 2), so the fold is unreachable and its rule is covered by the pure SlidingPaneStackTest cases instead; a long covered detail title wraps to three centred lines and ellipsizes (e.g. Pipelines maintenance - plan implem…) rather than being rotated.

An app-owned run-status palette (16 Oct 2026)

Run status had the wrong hue for its two most important states because it was mapped onto Material roles: primary (mint) made a running run read green and tertiary (amber) made a succeeded run read yellow. android/ only; nothing in the Pipelines server, its Go source, the Docker/compose files or the installer was touched, no dependency was added, no run was started from the app, and the attached Pixel 10 Pro Fold was never installed on or driven (every adb/emulator command targeted emulator-5556; lane A's emulator-5554 was not used).

  • A new app-owned palette. ui/components/RunStatusPalette.kt defines one Entry(colour, rationale) per status, fixed (not scheme-derived) so a status reads the same on every device, with a one-line reason each: Running/Active blue, Succeeded green, Failed the app error red, Interrupted amber, Canceled muted grey, Queued neutral grey, Unknown the low-key surface grey. runStateColor is now a pure function over this palette (no MaterialTheme), so it is asserted in a plain JVM test. Each state keeps its distinct material glyph and text label, so status is never colour alone.
  • The graph outcome palette is unchanged. GraphPalette and the terminal success/error roles are untouched; run status and stage outcome stay different vocabularies. The runs-list Timeline step chips (and their leading glyphs) previously rendered through runStateOf/StatusChip, i.e. the run-status mapping, so they were pointed at the graph's outcome palette instead: they now call the shared graphColors(scheme) factory (extracted from WorkflowGraph, which uses it too) and outcomeColor, so a step chip agrees with the graph. The run header and runs-list cards keep the run-status palette.
  • Shared helper. ui/components/RunStatus.kt gained ColoredChip(label, colour, icon, …) — the single pill layout now used by both StatusChip (run status) and the Timeline's outcome chip, instead of a second copy.

Evidence (macOS, JDK 17 from Homebrew openjdk@17, Gradle 8.11.1, ANDROID_HOME=/Users/alan/Library/Android/sdk, ANDROID_SDK_ROOT set, --offline):

  • gradle :app:testDebugUnitTest reported 143 tests, 0 failures, 0 errors (new RunStatusPaletteTest: WCAG-AA contrast ≥ 4.5:1 for every status colour against DarkSurface 0xFF0E1513, Succeeded green and ≠ DarkTertiary, Running/ Active blue and ≠ DarkPrimary, Failed = DarkError, Interrupted amber and ≠ Failed, Queued near-grey and ≠ Running, and a non-blank rationale per status). gradle :app:assembleDebug succeeded (18,009,527-byte debug APK, sha256 17f52f23e40f4ba0c524ac2929adfd6a8f39353e68ccdeedb2e029019225e350).
  • On emulator-5556 (FoldB_API_36, 2208x1840, density 420) in dark mode (adb shell cmd uimode night yes) against the live server ws://10.0.2.2:8080/connect, driven with adb shell input and uiautomator dump. Every capture below was written with android/scripts/capture_png.sh -s emulator-5556 (which names the SurfaceFlinger display id and validates the PNG magic bytes), and a validated screenshot was pixel-sampled to read the rendered colour back:
    • Before (pre-change tree, git stash build): runs-list usage values were Succeeded #F2C879 (amber), Running card #6FD3B8 (mint); a run header read #F2C879 (succeeded) and #6FD3B8 (running) — the reported bug, captures in runs_list_before.png, run_header_before.png, run_header_running_before.png.
    • After: runs-list usage values were Succeeded #7FE0A8 (green), Failed #FFB4AB (error red), Canceled #889391 (muted), Interrupted #E8C06A (amber), Active #7FB2F0 (blue); the running card was #7FB2F0 and the succeeded card #7FE0A8 (runs_list_after.png). A run header read #7FE0A8 (succeeded) and #7FB2F0 (running) (run_header_after.png, run_header_running_after.png).
    • Timeline agrees with the graph: before, a graph-only outcome still went through the run-status mapping — an approved step chip sampled #BEC9C5 (the run-status Unknown grey). After, the success step chip sampled #F2C879 (the graph's tertiary terminal role) and the approved chip #C0A3F5 (GraphPalette index 5), both equal to the graph's outcomeColor (run_timeline_before.png, run_timeline_after.png).
    • adb -s emulator-5556 logcat -d contained 0 FATAL EXCEPTION / E AndroidRuntime lines (the only app-matched lines were expected InputDispatcher … Consumer closed input channel warnings from the force-stop/reinstall).
  • APK publish. app/build/outputs/apk/debug/app-debug.apk was copied to …/artifacts/69/1/pipelines-debug-wip-cd85f69.apk (cd85f69 = git rev-parse --short HEAD); shasum -a 256 matched. curl -I http://10.0.0.249:8080/artifacts/69/1/pipelines-debug-wip-cd85f69.apk (LAN address from ipconfig getifaddr en0) returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 18009527; a streamed GET | shasum -a 256 equalled the local file. At 17.2 MiB it exceeds the server's 8 MiB per-file inventory cap, so it is served by direct URL only.

Re-verified against the committed tree (run 72, 16 Oct 2026)

The change above is committed at 24584d8; re-checked independently on that exact tree (JDK 17 from Homebrew openjdk@17, Gradle 8.11.1, --offline):

  • gradle --offline :app:testDebugUnitTest --rerun → 143 tests, 0 failures, 0 errors (RunStatusPaletteTest 7/7, including the per-status WCAG-AA contrast check). gradle --offline :app:assembleDebug succeeded; the APK is 18,009,527 bytes, sha256 17f52f23e40f4ba0c524ac2929adfd6a8f39353e68ccdeedb2e029019225e350.
  • Before/after captured on emulator-5556 (sdk_gphone16k_arm64, 2208x1840, density 420, dark mode) with android/scripts/capture_png.sh -s emulator-5556. The pre-change build was produced from a clean git archive cd85f69 tree (never a working-tree stash), and each capture was pixel-sampled to read the rendered colour back:
    • Before: runs-list usage Succeeded #F2C879 (amber) and Active #6FD3B8 (mint); run 69 header #F2C879, run 72 header #6FD3B8; the approved Timeline chip #BEC9C5 (run-status Unknown grey).
    • After: Succeeded #7FE0A8 (green), Failed #FFB4AB, Canceled #889391, Interrupted #E8C06A, Active #7FB2F0; run 69 header #7FE0A8, run 72 header #7FB2F0; the approved Timeline chip #C0A3F5 (graph palette index 5) while the success chip stays #F2C879 (the graph's tertiary role), so a step chip agrees with the graph. logcat after a fresh launch had 0 FATAL EXCEPTION / E AndroidRuntime lines.
  • APK publish. app/build/outputs/apk/debug/app-debug.apk copied to …/artifacts/72/1/pipelines-debug-wip-24584d8.apk (24584d8 = git rev-parse --short HEAD); curl -I http://10.0.0.249:8080/artifacts/72/1/pipelines-debug-wip-24584d8.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 18009527, and a streamed GET | shasum -a 256 matched.

Last-run facts on every pipeline row (16 Oct 2026)

android/ only. No server field was added: the whole run history already arrives from list_runs (internal/pipeline/runs.go, id DESC), so the join is client-side.

  • Pure join. ui/screens/PipelineLastRun.kt adds pipelineRunBadges(runs, now), which folds the history onto a Map<Long, PipelineRunBadge> keyed by pipeline id with runId, state (runStateOf), ranAgo and duration. Recency comes from the run timestamps, not the input order — the higher run id breaks an exact tie (or a missing/blank created_at), so an unsorted or partial response is still correct. PipelineRunBadge.metaLine() formats ago · duration · run N and drops any fragment that is genuinely absent (a still-running run has no finished_at); it never prints a blank separator. formatRanAgo mirrors the formatDuration integer rhythm (just now, then Nm ago/Nh ago/Nd ago) and clamps clock skew to just now. A pipeline with no run is simply absent from the map and the row prints the explicit NO_RUNS_RECORDED ("no runs recorded") instead of a blank line. The last-run line is withheld until runsState.data != null (runsKnown), so a not-yet-loaded history never makes the false "no runs recorded" claim.
  • Row. PipelineListScreen.kt refreshes runs alongside pipelines, anchors "now" once per composition (remember), and renders the chip + meta line in a Row under the unchanged title/secondary lines; the selected-row highlight is untouched.
  • Tests. test/.../PipelineLastRunTest.kt (10 cases) covers most-recent-wins on unsorted input, no runs, unknown pipeline id, equal timestamps, an unparseable timestamp, an unknown status word (RunState.Unknown, id still rendered), each formatRanAgo scale plus blank/bad input, and the NO_RUNS_RECORDED wording.

Verified on this tree (macOS, JDK 17 from Homebrew openjdk@17, Gradle 9.7.1, ANDROID_HOME=/Users/alan/Library/Android/sdk):

  • gradle :app:testDebugUnitTest → 153 tests, 0 failures, 0 errors, 0 skipped (PipelineLastRunTest 10/10).
  • gradle :app:assembleDebug --rerun-tasks --no-build-cache succeeded → app-debug.apk 17,863,337 bytes, sha256 b22550660c1ce9f42719eb5a32a296055d9f3df97fa0fd94bb26fa3868730506. This is a full rebuild of the current tree; the review's blocker was that the earlier published artifacts/83/1/pipelines-debug-wip-5444390.apk (17,997,811 bytes, sha256 0fb07207…) was a different revision of PipelineListScreen.kt, so it has been rebuilt and republished (see below).
  • Screenshots on emulator-5556 (FoldB_API_36, 2208x1840, density 420, dark mode) with android/scripts/capture_png.sh -s emulator-5556: the narrow window via adb shell wm size 1080x2340, the wide window at the default 2208x1840 (wm size reset). Both show the running run omitting its duration, the failed and canceled rows carrying ago · duration · run N, and pipeline id 3 "Plan, implement, review" printing no runs recorded.
  • APK publish. Copied to …/artifacts/83/3/pipelines-debug-wip-5444390.apk (5444390 = git rev-parse --short HEAD). curl -I http://10.0.0.249:8080/artifacts/83/3/pipelines-debug-wip-5444390.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 17863337, and a streamed GET | shasum -a 256 returned the same b2255066… as the local file. The same APK was installed on the emulator and the pulled installed base.apk hashed to b2255066…, so the reviewed source is what was actually rendered.

Remembered sort options for the pipelines and runs lists (16 Oct 2026)

Both list top bars gained a sort control that opens the choices plus a Reset, and the choice is remembered per list across restarts. android/ only; nothing in the Pipelines server, its Go source, the Docker/compose files or the installer was touched, no dependency was added (the icons come from the already-declared material-icons-extended), no run was started from the app, and the attached Pixel 10 Pro Fold was never installed on or driven (every adb/emulator command targeted emulator-5556).

  • Pure comparators. ui/screens/ListSort.kt defines the PipelineSort (ServerOrder default, NameAsc, NameDesc, RecentRun, FewestStages, MostStages) and RunSort (NewestFirst default, OldestFirst, LongestDuration, ShortestDuration, PipelineName, Status) enums plus one pure pipelineComparator/runComparator per sort and the sortPipelines/ sortRuns helpers. Every comparator ends in an explicit tie-break, so equal primary keys always order the same way; a blank/unparseable timestamp and a run with no recorded duration (still executing) sort last regardless of direction instead of crashing. ServerOrder is a zero comparator, so the stable sort preserves the server's own order exactly. RecentRun uses the shared per-pipeline latest-run fold (latestRunByPipeline, extracted from the last-run badge join in PipelineLastRun.kt) rather than folding the history twice.
  • Shared time helpers. ui/Format.kt gained parseInstant (moved out of PipelineLastRun.kt) and durationSeconds; the existing formatDuration now delegates to durationSeconds, so the printed duration and the sort key can never disagree.
  • Shared control. ui/components/SortMenu.kt is the one top-bar control both screens use: an IconButton (its own glyph and content description, so it cannot collide with the adjacent Refresh action or a future search entry point) opening a DropdownMenu of the options — the active one carries a leading check glyph, not colour alone — then a divider and Reset. It has no geometry literals and anchors correctly at both window widths. The glyph is Icons.AutoMirrored.Filled.Sort (the RTL-aware form, so no Icons.Default.Sort deprecation warning at build time and the arrow mirrors correctly).
  • Persistence. data/SettingsRepository.kt stores each choice as its stable storage key (pipeline_sort, run_sort) with a StateFlow, exactly like the server URL/workspace; AppViewModel exposes them and their setters. The list screens resolve the stored string with PipelineSort.fromStorage/ RunSort.fromStorage, which fall back to the default for a stale, unknown or blank value (the repository stays unaware of the UI enums).
  • Grouping. groupRunsByDay now takes the ordering comparator and preserves the order it produces (the default is still newest first, so the default output is unchanged); the run list groups by day in that order and sorts within a day by the same comparator.

Verified on this tree (macOS, Homebrew JDK 25 (openjdk@25), Gradle 9.7.1, ANDROID_HOME=/Users/alan/Library/Android/sdk, --offline):

  • gradle --offline :app:testDebugUnitTest --rerun-tasks → the 21 test-result XMLs aggregate to 167 tests, 0 failures, 0 errors, 0 skipped (the new ListSortTest has 13 cases covering the storage fallback for both enums, server order, case-insensitive name/stage sorts with their id/name tie-breaks, recent-run no-run-last and run-id tie-breaks, newest/oldest with unparseable timestamps last, duration longest/shortest with a still-executing run last and equal-duration tie-break, pipeline-name/status sorts, and that equal keys order identically whatever the input order; RunGroupingTest gained an explicit-order case). compileDebugKotlin emits no warnings.
  • gradle --offline :app:assembleDebug --rerun-tasks --no-build-cache (a full rebuild, so the published binary is exactly this tree) succeeded → app-debug.apk 17,879,721 bytes, sha256 cb68fbb13e469e81c15837ba95314a2ab40f1f29f4769e4a615bbc0ce4636a30.
  • On emulator-5556 (FoldB_API_36, 2208x1840, density 420, dark mode) against the live server ws://10.0.2.2:8080/connect, driven with adb shell input and uiautomator dump; every capture below was written with android/scripts/capture_png.sh -s emulator-5556 (validated PNG, named display id) into …/artifacts/87/1/. The live server's pipeline set churns while the maintenance workflow runs, so the concrete names differ between captures, but each ordering was read back from the accessibility tree:
    • Wide (2208x1840 ≈ 841dp): tapping Sort pipelines opened the six options plus Reset (01_wide_pipelines_sort_open.png); choosing Name Z–A reordered the list to descending names and stored pipeline_sort=name_desc (02_wide_pipelines_name_za.png). Sort runs opened the six run options plus Reset (03_wide_runs_sort_open.png); Oldest first showed run 1 → 2 → 3 and stored run_sort=oldest_first (04_wide_runs_oldest_first.png). The sort icon and the adjacent Refresh stay separate actions at both widths (the icon's own Sort pipelines/Sort runs content description sits left of Refresh …).
    • Persistence proof. After setting pipelines Name Z–A and runs Oldest first, run-as net.awan.pipelines cat shared_prefs/pipelines_settings.xml showed pipeline_sort=name_desc, run_sort=oldest_first. am force-stop net.awan.pipelines (verified pidof empty) then am start and a fresh uiautomator dump showed the pipelines list still in descending-name order (05_wide_pipelines_name_za_after_relaunch.png) and the runs list still oldest first, run 1 → 2 → 3 (06_wide_runs_oldest_first_after_relaunch.png), with no interaction.
    • Reset on the pipelines menu restored the server order (id 1 → 5 → 11 → 6 → 4 → 9 → 3) and stored pipeline_sort=server_order; Reset on the runs menu restored run_sort=newest_first and run 87 → 86 → 85 → 84 → 83 → 82 (10_narrow_runs_reset_newest_first.png).
    • Narrow (adb shell wm size 1080x2340 ≈ 411dp; wm size reset afterwards): both Sort pipelines and Sort runs opened their menus (07_narrow_runs_sort_open.png); Status ordered Canceled → Failed → Failed … and stored run_sort=status (08_narrow_runs_status_sort.png); Most recent run ordered the rows by recency 10h → 3d → 3d → 4d → 4d → 5d and put the runless pipeline (no runs recorded) last, storing pipeline_sort=recent_run (09_narrow_pipelines_recent_run.png).
    • Stale-key tolerance on device. With pipeline_sort and run_sort set to garbage_key in shared_prefs/pipelines_settings.xml (verified via run-as … cat, then replaced by push + run-as … cp) and the app force-stopped and relaunched, the pipelines list came back in the server's order (id 1 → 5 → 11 → 6 → 4 → 9 → 3, 11_narrow_pipelines_stale_key_falls_back_to_server_order.png) and the runs list in newest-first (run 87 → 86 → 85), with no crash.
    • adb -s emulator-5556 logcat -d | grep -c 'FATAL EXCEPTION' and … | grep -c 'E AndroidRuntime' each returned 0; no run was started from the app.
  • APK publish. app-debug.apk was copied to ~/.local/share/pipelines/data/artifacts/87/1/pipelines-debug-wip-3480461.apk (3480461 = git rev-parse --short HEAD); shasum -a 256 matched. curl -I http://10.0.0.249:8080/artifacts/87/1/pipelines-debug-wip-3480461.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 17879721, and a streamed GET | shasum -a 256 returned the same cb68fbb1… as the local file. The deterministic full-rebuild APK was installed on emulator-5556 (adb -s emulator-5556 install -r) and the pulled installed base.apk hashed to cb68fbb1…, so the reviewed source is what was actually rendered. At 17.1 MiB it exceeds the server's 8 MiB per-file inventory cap, so it is served by direct URL only.

Not verified in this pass: :app:lintDebug was not run (its only reported issues are the two pre-existing NewApi errors for android:windowLightNavigationBar); a real hardware fold to the cover display was not exercised (narrow was produced with wm size); no before/after baseline build was captured, since the change is additive and the default orders are asserted unchanged by the ServerOrder/ NewestFirst unit tests.

Filters for the runs and pipelines lists (16 Oct 2026)

Both list top bars gained a filter control, remembered per list across restarts like the sort. android/ only; nothing in the Pipelines server, its Go source, the Docker/compose files or the installer was touched, no dependency was added (the one new glyph, Icons.Default.FilterList, is from the already-declared material-icons-extended), no run was started from the app, and the attached Pixel 10 Pro Fold was never installed on or driven (every adb/emulator command targeted emulator-5556).

  • Pure predicates. ui/screens/ListFilter.kt defines RunTimeRange (AnyTime default, Today, Last7Days, Last30Days), RunPresence (Any default, HasRuns, NoRuns) and the RunFilters/PipelineFilters data classes plus one pure predicate per facet (runMatchesStatuses, runMatchesPipeline, runMatchesTimeRange, pipelineMatchesPresence, pipelineMatchesLastRunStatus) and the AND-combining filterRuns/ filterPipelines. A default filter narrows nothing; an empty status set means "any status". The status options are the server's own run vocabulary (queued/running/succeeded/failed/canceled/interrupted), not the app-only active/unknown buckets. A time window is inclusive calendar days ending today (last 7 = today + the six days before), and a blank, unparseable or future-dated timestamp never matches a finite window. A pipeline with no run has no last-run status, so a selected status never matches it. fromStorage tolerates stale/unknown/blank values by returning the default, and encodeRunStates/decodeRunStates round-trip the status set as the server status words in ordinal order.
  • Runs list. Status (multi-select), pipeline (single-select from the distinct pipelines already present in the run history, named by their runs, so no extra fetch) and the time range, combined with AND.
  • Pipelines list. The existing name search stays a separate field; the new filter adds has-runs / no-runs and the most-recent run's status (multi-select). Both pipeline facets depend on the run history, so filterPipelines leaves the list unfiltered until that history is known rather than briefly hiding every row.
  • Shared control. ui/components/FilterMenu.kt is the one top-bar control both screens use: an IconButton carrying a numeric active-filter count badge (so "filters active" is never colour alone) opening the caller's sections plus a divider and one Clear filters action (disabled when nothing is active). Its optionContent slot receives a dismiss callback, so single-select entries close the menu while multi-select toggles keep it open; FilterCheckItem is the shared leading-check row. It has no geometry literals and anchors correctly at both window widths.
  • Empty states. ui/components/States.kt's EmptyState gained optional actionLabel/onAction. Both lists now distinguish "nothing exists" (no action) from "nothing matches the current filters" (a Clear filters action); the pipelines list also says when the name search and the filters together match nothing. The clear action resets that list's filters (and, on Pipelines, the search) without touching the other list.
  • Persistence. data/SettingsRepository.kt stores each facet under its own stable key (run_filter_statuses, run_filter_pipeline, run_filter_time_range, pipeline_filter_presence, pipeline_filter_run_statuses) with a StateFlow, exactly like the sorts; AppViewModel exposes them and their setters. The screens resolve the stored strings with RunFilters.fromStorage/PipelineFilters.fromStorage (the repository stays unaware of the UI enums).
  • Shared time helper. The run screen's file-private runDate was removed in favour of ListFilter.kt's runLocalDate, so the day-grouping label and the time-range predicate share one parse. groupRunsByDay is unchanged.

Verified on this tree (macOS, Homebrew JDK 25 (openjdk@25), Gradle 9.7.1, ANDROID_HOME=/Users/alan/Library/Android/sdk, --offline):

  • gradle --offline :app:testDebugUnitTest --rerun-tasks → the 22 test-result XMLs aggregate to 183 tests, 0 failures, 0 errors, 0 skipped (up from 167; the new ListFilterTest has 16 cases covering stored-value parsing/fallback, encode/decode round-trip and garbage tolerance, empty-status "any", the status union, pipeline id vs any, the inclusive time windows and blank/future timestamps, the AND combination of every facet, presence has/no-runs, last-run status excluding runless pipelines, the runsKnown guard, and the distinct/sorted pipeline options).
  • gradle --offline :app:assembleDebug --rerun-tasks --no-build-cache (a full rebuild, so the published binary is exactly this tree) succeeded → app-debug.apk 17,912,489 bytes, sha256 eaa34c0b030511c2e4de1964dc4e905e62e822e876b5c0128bfff4d918933fc5.
  • On emulator-5556 (sdk_gphone16k_arm64, 2208x1840, dark mode) against the live server ws://10.0.2.2:8080/connect, driven with adb shell input and uiautomator dump; every capture below was written with android/scripts/capture_png.sh -s emulator-5556 (validated PNG, named display id) into …/artifacts/89/1/:
    • Selecting status failed narrowed the runs list to the failed runs and showed the badge 1 (01_runs_filtered_failed.png), read back from the accessibility tree.
    • The runs Filter runs menu opened with its Status, Pipeline and Time range sections, the active-count badge and Clear filters (02_runs_filter_menu_open.png).
    • Filtered-empty state. Adding pipeline Complete a Task to the failed status matched run 43, but the contradictory running status (no Complete a Task run is running) yielded no match: the list showed No runs match the current filters. with a Clear filters button and badge 2 (03_runs_filtered_empty.png); the button restored the full list and removed the badge.
    • The pipelines Filter pipelines menu carries the Runs (Any/Has runs/No runs) and Last run status sections, the badge and Clear filters (05_pipelines_filter_menu_open.png). Has runs + last-run status succeeded narrowed the list to its succeeded-last-run pipelines (04_pipelines_filtered_has_runs_succeeded.png); No runs + last-run status succeeded is contradictory and showed No pipelines match the current filters. with Clear filters and badge 2 (06_pipelines_filtered_empty.png); the button restored the list and cleared only the pipelines filter (the runs filter was left intact).
    • Persistence proof. With runs status failed and pipelines has_runs + last-run status succeeded, run-as net.awan.pipelines cat shared_prefs/pipelines_settings.xml showed run_filter_statuses=failed, pipeline_filter_presence=has_runs, pipeline_filter_run_statuses=succeeded. am force-stop net.awan.pipelines (verified pidof empty) then am start and a fresh uiautomator dump showed the pipelines list still narrowed with badge 2 (07_pipelines_filtered_after_relaunch.png) and the runs list still filtered to failed with badge 1 (08_runs_filtered_after_relaunch.png), with no interaction.
    • adb -s emulator-5556 logcat -d | grep -c 'FATAL EXCEPTION' and … | grep -c 'E AndroidRuntime' each returned 0; no run was started from the app.
  • APK publish. app-debug.apk was copied to ~/.local/share/pipelines/data/artifacts/89/1/pipelines-debug-wip-1c925d7.apk (1c925d7 = git rev-parse --short HEAD); shasum -a 256 matched. curl -I http://10.0.0.249:8080/artifacts/89/1/pipelines-debug-wip-1c925d7.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 17912489, and a streamed GET | shasum -a 256 returned the same eaa34c0b… as the local file. The deterministic full-rebuild APK was installed on emulator-5556 (adb -s emulator-5556 install -r) and the pulled installed base.apk hashed to eaa34c0b…, so the reviewed source is what was actually rendered. At 17.1 MiB it exceeds the server's 8 MiB per-file inventory cap, so it is served by direct URL only.

Not verified in this pass: :app:lintDebug was not run; a real hardware fold to the cover display was not exercised (all captures were at the inner panel's 2208x1840 width, so no narrow-width capture of the filter menu was taken); the time-range facet was unit-tested but not exercised on device, and no before/after baseline build was captured, since the change is additive and the default filters are asserted to narrow nothing by the unit tests.

Filter menu overflow and accessibility (16 Oct 2026)

A UI review of the pass above found the runs DropdownMenu grew unbounded with the distinct-pipeline count (N=8 made it fill the whole window), clipping the Clear filters item under the bottom gesture inset, and that neither the active-filter count nor the checked facets were exposed to accessibility. Fixed in ui/components/FilterMenu.kt only (android/, no new dependency):

  • Bounded menu. filterMenuMaxHeight(screenHeightDp) caps the menu at 0.85 × the window height (window-derived, like the graph's height helpers, so no new geometry literal), so the menu scrolls internally instead of growing past the window as N rises.
  • Reset always visible. The single Clear filters action is now a leading header row (Filters + the reset TextButton, disabled when nothing is active), so it is fully in view on open and never below the fold or clipped.
  • Above the navigation inset. A trailing spacer of WindowInsets.navigationBars bottom padding keeps the last option clear of the gesture area at maximum scroll.
  • Accessible state. The icon's description now folds in the count (filterMenuDescription, e.g. "Filter runs, 2 filters active"), and FilterCheckItem exposes toggleableState plus Role.Checkbox, so TalkBack announces the count and which facet is checked.

Re-verified on this tree (Homebrew JDK 25, Gradle 9.7.1, ANDROID_HOME=/Users/alan/Library/Android/sdk, --offline):

  • gradle --offline :app:testDebugUnitTest --rerun-tasks → 185 tests, 0 failures (new FilterMenuTest: the height helper's proportional/positive growth and the description's 0/1/2/negative wording).
  • gradle --offline :app:assembleDebug succeeded → app-debug.apk 18,005,500 bytes, sha256 7351c13b….
  • On emulator-5556 (2208x1840, density 420, dark mode) against ws://10.0.2.2:8080/connect, captured with android/scripts/capture_png.sh -s emulator-5556 into …/artifacts/89/4/:
    • The runs menu now has window [1210,75]–[1945,1639] (1564px = the 596dp cap), ending ~138px above the gesture exclusion (y=1777); Filters/Clear filters sit at the top (y=133–186) and after four swipes the last item Last 30 days is at y=1466–1519, fully visible with the nav spacer below it (02_runs_filter_menu.png).
    • uiautomator dump reports the runs filter rows checkable=true with the selected row checked=true (Any time), and the icon content-desc is Filter runs, 2 filters active / Filter runs, 1 filter active matching the badge (03_runs_filtered_failed.png, 01_runs_filtered_empty.png).
    • The pipelines menu (Filters/Clear filters at the top, Runs and Last run status sections) is [1542,93]–[1945,1622], also above the inset (04_pipelines_filter_menu.png); Has runs + last-run succeeded filtered the list (05_…png), No runs + succeeded showed No pipelines match the current filters. with Clear filters (06_…png).
    • Persistence proof. am force-stop net.awan.pipelines (verified pidof empty) then am start and a fresh dump showed the pipelines screen still filtered (badge 2) and the runs list still Filter runs, 1 filter active (07_…png, 08_…png), with no interaction.
    • adb -s emulator-5556 logcat -d | grep -c 'FATAL EXCEPTION' and … | grep -c 'E AndroidRuntime' each returned 0.
  • APK publish. app-debug.apk copied to …/artifacts/89/4/pipelines-debug-wip-1c925d7.apk (1c925d7 = git rev-parse --short HEAD); shasum -a 256 matched. curl against http://10.0.0.75:8080/artifacts/89/4/pipelines-debug-wip-1c925d7.apk returned HTTP 200, Content-Type: application/vnd.android.package-archive, Content-Length: 18005500.

Not verified: the "nothing exists" variants (No pipelines are defined on this server. / No runs have been recorded yet.) were not captured — the live server has both pipelines and runs, list_runs is not workspace-scoped, and the task forbids touching the server's data, so there was no empty source to render them against; the branch is unit-covered only indirectly. A real hardware fold and :app:lintDebug were again not exercised.

Executed vs not-executed is structural, with a legend (16 Oct 2026)

android/ only. Nothing in the Pipelines server, its Go source, the Docker/ compose files or the installer was touched, no dependency was added, no run was started from the app, and every adb/emulator command targeted emulator-5556 (lane A's emulator-5554 was never used; the attached Pixel was never installed on or driven).

  • The two states differ by shape, fill and border style, not by a faded tint. ui/graph/WorkflowGraph.kt now draws an executed route as a solid full-colour stroke with its arrowhead, and a not-executed route as a dashed muted stroke without an arrowhead. A node the run visited is filled with its normal border; a node it did not is hollow (no fill) with a dashed muted border and a muted-but-legible onSurfaceVariant label. The old alpha = 0.25f / 0.3f dimming is gone, so the distinction survives a screenshot, a dim screen and a colour-blind reader.
  • Shared, testable predicates. stageIsExecuted(key, runState) and edgeIsExecuted(edge, runState) (both runState == null ⇒ executed) replace the private EdgeLayout.isExecuted and the inline visitedStages check, so drawing and the screen-reader graphDescription share one definition.
  • Dash token. INACTIVE_DASH_INTERVALS = floatArrayOf(14f, 10f) is the one line-style token; INACTIVE_DASH_EFFECT is the lazily-built PathEffect used by both the not-executed edges and the not-executed node borders, so it is never rebuilt per frame. Node/edge geometry keeps the existing layout tokens/insets — the only new literals are the dash rhythm and the compact legend swatch, not graph geometry.
  • Compact legend. GRAPH_LEGEND (a solid, arrowed swatch labelled Executed; a dashed, arrowless swatch labelled Not executed) is drawn as a one-line Row pinned to the graph's top-start, opposite the Fit/expand controls, so it stays visible with the top of the panel even on a short/narrow window. It renders only when a run is selected.
  • The definition-only view is untouched. With no runState every stage/route is executed, so the graph renders exactly as before (solid, filled, arrowed) and the legend is not composed — confirmed against the pipeline Graph tab. (Superseded later the same day: the pass/fail change below now widens an executed success/error route in this view too.)
  • The run-detail Graph tab's help line was updated from "highlighted … dimmed" to "solid … dashed and outlined".

Verification (macOS; Homebrew openjdk@17 at JAVA_HOME=/opt/homebrew/opt/openjdk@17/libexec/openjdk.jdk/Contents/Home, Gradle 8.11.1, ANDROID_HOME=/Users/alan/Library/Android/sdk, --offline):

  • gradle --offline clean :app:testDebugUnitTest :app:assembleDebug → 188 tests, 0 failures, 0 errors; WorkflowGraphTest 34 tests (3 new: the executed predicates over the definition view and a RunGraphState, the dash pattern being a positive even-length rhythm, and the legend naming both states with executed first). The clean :app:assembleDebug produced app-debug.apk 17,912,489 bytes, sha256 49631a3a2763bf1d9232eb9e7c8f9ff3edd719355ac0a99b7c91f7f40c3a1cc5 (two clean rebuilds were byte-identical; this is the published artifact).
  • A partly-executed run (run 77, pipeline id 11 "Focused tweak - implement review commit": implementer, reviewer, ui_reviewer ran, committer did not) was opened in the app against the live server ws://10.0.2.2:8080/connect in dark mode, driven with adb shell input, and every capture below was written with android/scripts/capture_png.sh -s emulator-5556 (validated PNG magic bytes; the fold emulator has two displays, so a screencap redirect must never be used). Captures are in …/artifacts/93/1/:
    • Narrow 1080x1920 @ density 480 (≈360dp): [implementer], [reviewer], [ui_reviewer] and [FAILURE] are filled with solid, arrowed routes between the visited stages and into #failure; [committer] and [SUCCESS] are hollow with dashed borders, and every other route is dashed with no arrowhead (graph_partly_exec_narrow_1x.png).
    • Narrow, 2x at 2160x3840 @ density 960 (same 360dp): the same graph at double the pixel density, dashes and arrowheads clearly resolved (graph_partly_exec_narrow_2x.png).
    • Wide 2208x1840 @ density 420 (≈841dp): graph_partly_exec_wide_1x.png; wide 2x at 4416x3680 @ density 840: graph_partly_exec_wide_2x.png; a colour 2x crop of the graph and legend graph_partly_exec_wide_1x_zoom.png.
    • Grayscale check. Greyscale conversions (PIL Image.convert('L')) of the narrow-2x and wide-1x captures, plus a 2x greyscale crop, keep the distinction: the executed routes are continuous solid lines with arrowheads and the nodes fill, while the not-executed routes are broken dashed lines and the nodes are hollow outlines (graph_partly_exec_narrow_2x_gray.png, graph_partly_exec_wide_1x_gray.png, graph_partly_exec_wide_1x_gray_zoom.png).
    • Definition-only view unchanged. Captured the pipeline Graph tab (no run) on a pre-change build (a 54af453 worktree) and on this build; the graph pane is pixel-identical (no legend on either side). A PIL ImageChops.difference over the graph pane (x 1150–2208, y 150–1500) reported bbox None / 0 differing pixels of 1,428,300 / max channel diff 0. Before/after pair: def_before_p8.png / def_after_p8.png (pipeline 8 Graph tab); the same source's pipeline-11 Graph tab after is graph_definition_only_wide_1x.png.
    • adb -s emulator-5556 logcat -d contained 0 FATAL EXCEPTION and 0 E AndroidRuntime lines.
  • APK publish. app-debug.apk copied to …/artifacts/93/1/pipelines-debug-wip-54af453.apk (54af453 = git rev-parse --short HEAD); shasum -a 256 matched. curl -I http://10.0.0.249:8080/artifacts/93/1/pipelines-debug-wip-54af453.apk (10.0.0.249 from ipconfig getifaddr en0) returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 17912489, and a streamed GET | shasum -a 256 equalled the local file. At ~17.1 MiB the APK exceeds the server's 8 MiB per-file inventory cap, so it is served by direct URL only.

Not verified in this pass: :app:lintDebug, the light theme, and a real hardware fold (the wide/narrow layouts were produced with wm size/wm density); the on-device captures used the debug build of this source, while the published APK is a clean rebuild of the same source.

Pass/fail edges are the loudest lines (16 Oct 2026)

android/ only. Nothing outside android/ was touched, no dependency was added, no run was started from the app, and every adb/emulator command targeted emulator-5556 (lane A's emulator-5554 was never used; the attached device was never installed on or driven).

  • Two decisive outcomes, drawn heavier. ui/graph/WorkflowGraph.kt now treats success (pass) and error (fail) as the emphasised outcomes (isPassFailOutcome). An executed pass/fail edge is drawn at PASSFAIL_EDGE_STROKE = 7f — noticeably heavier than the previous 3f — with a stronger, more saturated stroke and a matching PASSFAIL_ARROW_HEAD_SIZE = 20f arrowhead, so pass/fail is obvious at a glance and from a distance.
  • Other lines stay finer. Every other executed outcome keeps EDGE_STROKE = 3f, and a not-executed edge uses the finer INACTIVE_EDGE_STROKE = 2.5f, so the two emphasised outcomes dominate. No outcome hue changed.
  • Stronger, same-hue stroke. boostSaturation(color, factor) in ui/graph/GraphPalette.kt scales HSV saturation by PASSFAIL_SATURATION = 1.6f, clamping at 1 while preserving hue, value and alpha. On the dark theme the executed success stroke moves from #F2C879 (hue 39.2°) to a vivid #F2AF30-ish core (hue 39.3°, measured pixel (242,175,48)) and the executed error stroke from #FFB4AB (hue 6.4°) to a stronger (255,135,121) (hue 6.3°); the measured pixel hues match their unboosted originals, so meaning is not conveyed by a new colour. A non-pass/fail or not-executed edge keeps its exact outcome colour.
  • Widths come from named tokens, not call sites. edgeStrokeWidth, edgeArrowHeadSize and edgeStrokeColor pick the token for an edge; the old 12f arrowhead literal is gone (the draw scope takes the size as a parameter). The legend swatch keeps the base EDGE_STROKE/ARROW_HEAD_SIZE because it names the generic executed/not-executed states, not pass/fail.
  • Definition-only view. With no run selected every route counts as executed, so the definition graph now shows the same pass/fail emphasis (still no legend). The run Graph tab help line now adds "Executed success and failure routes are drawn thickest."

Verification (macOS; Homebrew openjdk@17, JAVA_HOME=/opt/homebrew/opt/openjdk@17/libexec/openjdk.jdk/Contents/Home, Gradle 8.11.1 at ~/.gradle/wrapper/dists/gradle-8.11.1-bin/…/gradle-8.11.1/bin/gradle, ANDROID_HOME=/Users/alan/Library/Android/sdk, --offline):

  • gradle --offline clean :app:testDebugUnitTest :app:assembleDebug → 193 tests, 0 failures, 0 errors; WorkflowGraphTest 36 (2 new: the executed pass/fail edge is the widest and its arrowhead scales, and only success/error are pass/fail outcomes) and GraphPaletteTest 10 (3 new: boostSaturation raises saturation while keeping hue/value/alpha, is safe and clamped at the edges, and only executed pass/fail strokes are saturated further). The clean :app:assembleDebug produced app-debug.apk 17,912,489 bytes, sha256 ce63722b851ce26322da69fa47bdc91958c3d7db3e339c1340efc3e04b6780f8.
  • Before/after on a run with both a success and an error edge. Run 77 (pipeline 11 "Focused tweak - implement review commit", failed at ui_reviewer with error) was opened in the app against the live server ws://10.0.2.2:8080/connect in dark mode; its taken routes include a success and an error edge. "Before" is HEAD 9c47527 (the six edited files stashed, rebuilt, installed; verified by the help line without "thickest"); "after" is this change. Captures were written with android/scripts/capture_png.sh -s emulator-5556:
    • Wide 2208x1840 @ density 420 (≈841dp): before_wide_1x.png / after_wide_1x.png. At the panel's fit scale the executed success/error stroke's saturated core measures 1px before, 3px after (sampled at the same x), while the dashed non-pass/fail routes stay ~1px.
    • Wide 2x 4416x3680 @ density 840: before_wide_2x.png / after_wide_2x.png.
    • Cropped graph panes before_wide_{1x,2x}_graphcrop.png / after_wide_{1x,2x}_graphcrop.png and stacked before/after sheets compare_wide_1x.png / compare_wide_2x.png show the two amber success edges and the red error edge as the boldest lines after the change, with the dashed blocked/rejected/approved/skipped routes and the not-executed committer/SUCCESS edges unchanged.
    • adb -s emulator-5556 logcat -d contained 0 FATAL EXCEPTION and 0 E AndroidRuntime lines.
  • APK publish. app-debug.apk copied to …/artifacts/98/1/pipelines-debug-wip-9c47527.apk (9c47527 = git rev-parse --short HEAD); shasum -a 256 matched. curl -I http://10.0.0.249:8080/artifacts/98/1/pipelines-debug-wip-9c47527.apk (10.0.0.249 from ipconfig getifaddr en0) returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 17912489, and a streamed GET | shasum -a 256 equalled the local file. The APK exceeds the server's per-file inventory cap, so it is served by direct URL only.

Not verified in this pass: :app:lintDebug, the light theme, and a real hardware fold (the wide layout was produced with wm size/wm density); the on-device captures used the debug build of this source, while the published APK is a clean rebuild of the same source.