Files
pipelines/android
alan c164d08cc5 Merge lane-c: keep the lane's reviewed work
Combines lane-c's Templates gallery and detail view with the chat and omni-search work already on main (lane-t2). The three files both lanes touched keep both intents: AppViewModel.kt keeps refreshTemplates/createFromTemplate alongside the search/chat flows, PipelinesApp.kt keeps both the Templates and Chat destinations, and graph/Artifacts.kt adopts the shared galleryGrid fitting while keeping the tile-gallery refactor.

Doc check before committing: nothing needs updating. This is an android/-only merge. The app's topic doc (android/README.md) already documents the Templates destination (lane-c) and the Chat/omni-search work (lane-t2). The root README and docs/ describe the server CLI/TUI (whose :templates catalog is a separate surface) and are unchanged. The packaged authoring skill references (internal/author/skill/references/) mention the Android client only for APK-delivery mechanics, which this change does not alter, and the packaged templates are server-side and untouched.
2026-10-17 01:42:51 +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.
  • A Templates destination (its own top-level pill between Pipelines and Runs, with its own gallery glyph rather than the Pipelines workflow tree): a measured gallery of cards, one per server template, each showing the template's name, its short description and its stage count — stage count unavailable when the source does not parse, never a claimed zero — with a single column on a narrow window and as many equal-width cards as fit on a wide one, from the shared galleryGrid fitting (the same rule the artifacts gallery uses) at the WIDE_RAIL_WIDTH_DP/SPACING_S tokens, so the gallery widens by adding columns instead of stretching cards. Tapping a card opens a detail pane that reuses the pipeline detail's Summary / Graph / Source tabs (the stage list, the WorkflowGraph and the shared PipelineSourceView), so the shape is readable before choosing it; a source the server could not parse is still fully viewable as raw markdown. A "create from this template" action submits the source as a create-only draft pipeline (the app's equivalent of pipelines new --template KEY) and never starts a run. Empty, loading and error states reuse the shared state components.
  • 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. The visual language is a modern surface, not a terminal diagram: a stage is a rounded rectangle (the theme's shapes.medium) and a terminal a pill, both filled with a tonal surface tinted with the node's semantic hue behind a soft border (not a flat fill plus hard outline); the node name and the outcome labels use the app's type scale (cardTitle/label, no ad-hoc sizes, no all-caps, terminal Success/Failure in their own colour); edges draw with round caps/joins and every right-angle bend is rounded by one ROUTE_CORNER_RADIUS control offset over the unchanged stored polyline, with a filled arrowhead proportional to its stroke and the outcome label on a rounded tonal chip rather than raw text over the canvas; node and per-edge-track spacing are named dp tokens.
  • 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.
  • The stage pane (opened from a Timeline row, a run graph node or a run's stage list) leads with the run's results, not the stage's definition: the stage's status, outcome, duration and the selected visit's target, then the visit's artifacts gallery (first), output and input, then the remaining run evidence. The stage's own definition — type, prompt, output contract, outcomes, model, provider, configs, tools, limits, memory and notify — moves into one collapsed Stage definition section at the bottom. A pipeline stage pane has no run context, so its definition section renders expanded as its only content. Nothing is removed, and the visit tabs still switch the selected visit.
  • 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).
  • A run still in progress shows the time it has taken so far instead of a finished duration, everywhere a run's time appears: the runs list meta row, the pipeline list's last-run line and the run detail summary's Duration row. A running value is live — recomputed once a second from the server's own created_at (never from when the app loaded, so it stays correct after a reconnect), using the shared runDurationText and a single ticking clock per screen (ui/components/LiveTime.kt) that pauses while the app is backgrounded and while no shown run is executing. Once the run finishes it keeps its stored total duration; a missing start omits the value and a future start (clock skew) reads as 0s (FormatTest, PipelineLastRunTest).
  • 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)

Superseded by "The covered edge is measured, not budgeted" below: the fixed PEEK_BUDGET_DP (224.dp) is gone. The covered region is now measured from the compact identity a covered edge has to show, so the active pane is no longer charged a fixed 224dp whatever the window width is.

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)

Superseded by "The covered edge is measured, not budgeted" below: the MIN_COVERED_PANE_WIDTH_DP/PEEK_WIDTH_DP split of a fixed budget no longer decides the layout. A covered edge is now as wide as the identity it has to show; the two tokens only bound which statistics that identity shows.

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.

Covered panes carry a compact statistics block (16 Oct 2026)

A covered pane's compact identity is no longer a bare title/subtitle: it now shows a small vertical block of labelled statistics, aggregated client-side from the run history the app already receives, degrading with the strip's width. android/ only; nothing in the Pipelines server, its Go source, the Docker/compose files or the installer was touched, no dependency was added (the declared material-icons-extended is unchanged), no run was started from the app and no server field was added.

  • Pipeline statistics. When the covered pane is a pipeline (PipelineDetailScreen, and RunDetailScreen through its run's pipeline) the block shows the run counts (runs/succeeded/failed/active), the last run's status and how long ago it started, and the average duration over the runs that finished. ui/screens/PaneStats.kt folds the history in one pass; the counts mirror the server's own vocabulary (active = queued/running, per internal/pipeline/stats.go) and a still-running run never drags the average. A run pane whose run (and so whose pipeline) has not loaded yet stays title-only: an absent pipeline id is "not known yet", never the whole history, so it can never show the server-wide summary as if it were the run's pipeline.
  • List statistics. When the covered pane is a list, PipelineListScreen and RunHistoryScreen show the whole history's counts by status and the single most recent run; a runs list scoped to one pipeline shows that pipeline's own numbers.
  • Width degradation. PaneIdentity measures its own strip and shows the title only below one peek width, the run counts up to MIN_COVERED_PANE_WIDTH_DP + PEEK_WIDTH_DP, and the full block above it, so a thin peek drops whole labelled statistics instead of clipping a number or printing an unlabelled figure. Each statistic is a label above its own value, so the number never shares a line with a label that could clip it. The boundaries reuse the named geometry tokens and the decision is the pure paneStatTier/visiblePaneStats pair.
  • One recency rule. The "most recent run" comparison is the shared isMoreRecent helper, used by the single-pass latestRunByPipeline join and by the covered summary's own fold, so the pipeline row's last-run badge, the "most recent run" sort and the covered summary all agree on which run is the latest without grouping the history into intermediate lists.
  • Two aggregation entry points. ui/screens/PaneStats.kt exposes pipelineStatLines(runs, pipelineId, now) for the pipeline-scoped panes and listStatLines(runs, now) for the list panes, so "which statistics, from which history, or none until it has loaded" lives in one place instead of at each call site and a null pipeline id can never be mistaken for the whole history. The fold is a single pass (RunTally.add tracks the counts, the finished-run duration total and the most recent run together), so a scoped pipeline summary never allocates a filtered list or walks the history twice.

Evidence (macOS, JDK 17 from Homebrew openjdk@17, the cached Gradle 8.11.1 distribution, ANDROID_HOME=~/Library/Android/sdk, --offline):

  • :app:testDebugUnitTest :app:assembleDebug --offline --console=plain → BUILD SUCCESSFUL in 2s (41 actionable tasks: 8 executed, 33 up-to-date). The result XMLs total 279 tests, 0 failures, 0 errors, 0 skipped across 32 files; app/build/outputs/apk/debug/app-debug.apk is 18,204,486 bytes, sha256 196c9d6f4acbcc75769fd52ecadac66378bad78994056895f26ff65da077718c. The PaneStatsTest (15 cases) covers the per-pipeline counts, queued as active, the last run's state/age, the average over finished runs, zero-duration runs, a pipeline with no runs, an unknown pipeline id, the whole-history list fold and the labelled lines, and that an absent/unknown pipeline id yields no lines rather than the list summary; the PaneIdentityTest (5 cases) pins the width tiers, that the counts tier drops only the detail lines, and that every shown statistic keeps its label and value.
  • APK publish. app-debug.apk was copied to ~/.local/share/pipelines/data/artifacts/142/3/pipelines-debug-wip-c700b28.apk (c700b28 = git rev-parse --short HEAD; the tree is uncommitted WIP on top of it); shasum -a 256 matched the built file (196c9d6f…). curl -I http://10.0.0.249:8080/artifacts/142/3/pipelines-debug-wip-c700b28.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 18204486.
  • Device evidence (emulator-5554). The debug APK was installed with adb -s emulator-5554 install -r (never the attached Pixel, never emulator-5556) against the live LAN server, and the wide and narrow layouts were captured with adb -s emulator-5554 shell screencap -p /sdcard/cap.png then adb -s emulator-5554 pull. Captures are in the same artifacts directory: wide-1-level-runs-list.png, wide-2-levels-covered-list-stats.png, wide-3-levels-covered-stats.png (plus …pane0…/…pane1… crops) and narrow-runs-list.png. OCR of the covered strips confirms the block: at two levels the covered runs list reads Runs / runs 145 / succeeded 90 / failed 39 / active 6 / last running - 4m ago (Full tier); at three levels its two covered strips (82 dp and 112 dp wide) drop the last line and keep only the labelled counts, and the covered run strip reads the run's own pipeline id 11 numbers (runs 60 / succeeded 37 / failed 14 / active 5) — clearly not the server-wide 145, so an unknown pipeline can no longer borrow the list summary. Four levels remain unreachable: MAX_PANE_DEPTH = 2 gives exactly three pane levels, so the three-covered degradation is captured instead.
  • Device-instruction conflict. The run's Constraints said use emulator-5554 exclusively and never the operator's physical device; an appended paragraph said to use the attached Pixel and never an emulator. There is no path that satisfies both, and installing this WIP build on the operator's own phone is forbidden by the task, so the emulator named in the Constraints was used (with the device.lock held) and the Pixel and emulator-5556 were never touched. While capturing, another lane repeatedly overwrote the installed APK on emulator-5554 (the installed hash reverted from this build to 2adaf03e…/5912d38f… at 16:18 and 16:20 until reinstalled), which is why the APK hash was re-checked immediately before the captures that are reported here.

Run stage pane leads with the run's results (16 Oct 2026)

A stage opened from a run no longer leads with its own definition. The pane now shows the run's result first — the stage's status, outcome, duration, visit and target, then the visit's results — and the stage's own definition is one collapsed Stage definition section at the bottom. 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 was never installed on or driven (the debug APK was installed with adb -s emulator-5554 install -r).

  • Results first. ui/graph/StageDetailPane.kt renders headlineFields (Status, Outcome, Duration, Visit, Target, Model target — the run-side facts) immediately, then the run-side result sections in STAGE_RESULT_SECTIONS order: Artifacts (the per-visit gallery, first, per the operator's earlier "artifacts at the top" preference), Output, Input, then the remaining evidence under This run. Each is collapsed by default via the unchanged SectionHeader/rememberSectionExpansion, and a new private StageSection renders them all through one header+content helper.
  • One collapsed definition. The previous Model/Provider headline promotion is reverted: STAGE_CONFIG_HEADLINE_LABELS, stageConfigHeadlineFields and remainingDefinitionFields are gone, and the full stageDefinitionFields (type, prompt, output contract, outcomes, model, provider, configs, tools, limits, memory, notify) renders in the single Stage definition section (STAGE_DEFINITION_KEY/STAGE_DEFINITION_TITLE). Nothing visible before is removed — Model/Provider are reachable by expanding the section.
  • Run vs. definition-only. StageDetailPane gained runContext (default false); RunStagePane passes true (Timeline, run graph and run stage list all go through it), PipelineStagePane leaves it false. The pure definitionStartsExpanded(runContext) seeds the section's default: collapsed in a run pane, expanded in a pipeline stage pane, where the definition is the only content. rememberSectionExpansion gained an initiallyExpanded set (part of the save key) for that seed.
  • Visit tabs unchanged. The visit tab row (showVisitTabs, clampVisitIndex) still switches the selected visit above the results.

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

  • gradle :app:testDebugUnitTest :app:assembleDebug → BUILD SUCCESSFUL; the test-result XMLs aggregate to 137 tests, 0 failures, 0 errors, 0 skipped. StageDetailSheetTest dropped the two promotion tests and gained theRunHeadlineIsRunSideOnlyAndTheDefinitionKeepsModelAndProvider, theDefinitionStartsExpandedOnlyWithoutARunContext and theRunResultSectionsLeadWithTheArtifactsGallery (12 cases, 0 failures). app/build/outputs/apk/debug/app-debug.apk is 18,011,770 bytes, sha256 1ba2119ad2e2c34b0928460036bdda7b02e2b4d819be2c68d225dd9b072611b8.
  • 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).
  • On emulator-5554 (narrow wm size 1080x1920 / wm density 480 ≈ 360dp; wide wm size reset / wm density reset = 2076x2152 / 390 ≈ 852dp; never the attached Pixel) against the live server ws://10.0.2.2:8080/connect, driven with adb shell input and uiautomator dump; run 60's implementer (two visits) and pipeline 11 v1's implementer:
    • narrow_timeline_top.png / narrow_timeline_sections.png and wide_timeline_stage.png: the implementer pane opened from the Timeline row implementer · visit 2 — title, model chip, visit 1/visit 2 tabs, Status/Outcome/Duration/Visit/Target, then Artifacts, Output, Input, This run, Stage definition (all collapsed) in that order.
    • narrow_graph_top.png / narrow_graph_sections.png and wide_graph_stage.png: the same pane opened by tapping the implementer graph node (starts on visit 2), identical ordering.
    • wide_pipeline_stage_definition.png: pipeline 11 v1's implementer opened from the pipeline graph — no visit tabs and no run sections, Stage definition expanded with Type/Prompt/Output, because a pipeline stage has no run.
    • narrow_run_definition_model_provider.png: the run pane's Stage definition expanded to Type model, Prompt, Outcomes, Model deepseek-v4.1-flash, Provider opencode-go, Retries, Timeout, Tools, Memory — nothing removed.
    • narrow_run_artifacts_gallery.png: the Artifacts section (the first result): Artifacts · 47 recorded · partial capture and the thumbnail grid. (Run 60's own artifact files are the corrupt adb screencap captures noted in the run-64 pass, so they render the honest ! failure mark, not a blank tile.)
    • Every capture was written and validated with android/scripts/capture_png.sh -s emulator-5554 … (--check re-validated all eight). adb -s emulator-5554 logcat -d contained 0 FATAL EXCEPTION, 0 E AndroidRuntime and no E-level net.awan.pipelines line; no run was started from the app. Screenshots and the raw uiautomator dumps are in ~/.local/share/pipelines/data/artifacts/68/2/.
  • APK publish. app/build/outputs/apk/debug/app-debug.apk was copied to ~/.local/share/pipelines/data/artifacts/68/1/pipelines-debug-wip-cd85f69.apk (cd85f69 = git rev-parse --short HEAD; the working tree is uncommitted WIP on top of it); shasum -a 256 matched. curl -I http://10.0.0.249:8080/artifacts/68/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: 18011770; a streamed GET | shasum -a 256 returned 1ba2119ad2e2c34b0928460036bdda7b02e2b4d819be2c68d225dd9b072611b8, equal to 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: a run stage that was never visited (no recorded step) still belongs to a run, so its definition is collapsed; the pane then leads with only the title/type and the collapsed section, which the pure definitionStartsExpanded rule covers but was not driven on the device. A terminal node opened from a run graph likewise collapses its single Incoming routes definition-and-only section. The wide layout was exercised headless on the fold AVD, not on physical hardware.

The stage pane is an opaque container (16 Oct 2026)

The stage detail pane already painted an opaque Scaffold, but that was the app background role, identical to the peek strips it slides over, so it read as "no background" and its rows ran together with the covered pane's compact identity. The pane is now a raised sheet.

  • StageDetailPane gives the pane the theme's surfaceContainer role through a single paneContainerColor() used by all of the pane's own surfaces: the Scaffold container, the TopAppBar, the visit PrimaryScrollableTabRow and every section header (StageSection passes it to the shared SectionHeader, which gained a containerColor parameter defaulting to the previous background). The pane therefore fully covers the area it occupies — including under a section header — as one tone, and sits a clear step above the background peeks and above the content it covers on a narrow window. The covered pane's peek is unchanged and still expected.
  • CodeBlock and the artifacts ArtifactRow moved from surfaceContainer to surfaceContainerHigh (the full-size artifact dialog to surfaceContainerHighest), so a card stays a visible card on both the app background and a pane's surfaceContainer sheet. No geometry, insets or dependencies changed; all colour roles come from the existing theme.

Evidence on emulator-5554 (fold AVD; narrow wm size 1080x1920, wide wm size reset = 2076x2152 / 390dpi ≈ 852dp; never the attached Pixel) against the live server, driven with adb shell input and uiautomator dump, using android/scripts/capture_png.sh -s emulator-5554 (every image validated):

  • gradle :app:assembleDebug → BUILD SUCCESSFUL; app/build/outputs/apk/debug/app-debug.apk is 18,012,281 bytes.
  • gradle :app:testDebugUnitTest → BUILD SUCCESSFUL; the 18 test-result XMLs aggregate to 137 tests, 0 failures, 0 errors, 0 skipped.
  • pane-opaque-wide-over-graph.png / pane-opaque-wide-over-timeline.png: on the wide window the implementer pane opened over run 69's Graph tab and over its Timeline tab is a solid surfaceContainer sheet starting at the fixed peek budget, clearly lighter than the Runs/run peeks to its left.
  • pane-opaque-narrow-over-graph.png / pane-opaque-narrow-over-timeline.png: on the narrow window the same pane opened over the run graph and the Timeline fills the window as one opaque sheet with no bleed-through.
  • pane-opaque-narrow-over-running-graph.png: the pane opened over run 70's running graph (visit tabs, Status running) is equally opaque and readable while the run polled.
  • pane-opaque-wide-definition-expanded.png / pane-opaque-narrow-definition-expanded.png: with a section expanded, the Prompt/Transcript code cards are clearly a step lighter than the pane, so the container change did not flatten the card hierarchy.
  • APK publish. The debug APK was copied to ~/.local/share/pipelines/data/artifacts/71/1/pipelines-debug-wip-cfd5887.apk (cfd5887 = git rev-parse --short HEAD; the working tree is uncommitted WIP on top of it), sha256 67f5223bd8f1c5ce8939ea786b62a222cdb5e59763d8bf3fd636ba5d52b6985e. curl -I http://10.0.0.249:8080/artifacts/71/1/pipelines-debug-wip-cfd5887.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 18012281; a streamed GET | shasum -a 256 returned the same hash. 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: the two app appearances are dark-only (PipelinesTheme defaults to dark), so the surfaceContainer step was checked in the dark scheme only; the pane's leading-edge shadow is not used (the tonal step is the separation) so no new elevation token was introduced.

Re-verification of the committed sheet (1fece88, 16 Oct 2026, run 73)

The change above is committed at 1fece88; this run rebuilt and re-installed it and re-captured the pane on emulator-5554 (fold AVD; narrow wm size 1080x1920, wide wm size reset = 2076x2152 / 390dpi ≈ 852dp; never the attached Pixel) against the live server, using android/scripts/capture_png.sh -s emulator-5554 (every image validated):

  • gradle :app:assembleDebug → BUILD SUCCESSFUL (JDK 17, Gradle 8.11.1, --offline); app/build/outputs/apk/debug/app-debug.apk is 17,846,953 bytes, sha256 d47c5bf993ca28293b188829c7fd5eec709fac49f04cca520377df96d393c887.
  • gradle :app:testDebugUnitTest --rerun-tasks → BUILD SUCCESSFUL; the 18 test-result XMLs aggregate to 137 tests, 0 failures, 0 errors, 0 skipped.
  • pane-opaque-wide-over-graph.png / pane-opaque-wide-over-timeline.png and pane-opaque-narrow-over-graph.png / pane-opaque-narrow-over-timeline.png: the implementer pane opened over run 72's Graph and Timeline is one opaque surfaceContainer sheet — on the wide window from the fixed peek budget to the right edge, on the narrow window full-window — with the headline rows, section headers and the tonal step clearly readable.
  • pane-opaque-narrow-over-running-graph.png: the pane over run 73's running graph (Status running) is equally opaque.
  • adb -s emulator-5554 logcat -d contained 0 FATAL EXCEPTION / E AndroidRuntime lines during the sweep.
  • APK publish. Copied to ~/.local/share/pipelines/data/artifacts/73/1/pipelines-debug-wip-1fece88.apk (1fece88 = git rev-parse --short HEAD). curl -I http://10.0.0.249:8080/artifacts/73/1/pipelines-debug-wip-1fece88.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 17846953; a streamed GET | shasum -a 256 returned the same d47c5bf… hash.

Re-verification on the current tree (1fece88, 16 Oct 2026, run 77)

Same committed sheet, rebuilt and re-driven this run on emulator-5554 only against the live server:

  • gradle :app:assembleDebug :app:testDebugUnitTest --offline → BUILD SUCCESSFUL (Gradle 9.7.1, JDK 17 from the Android Studio JBR, ANDROID_HOME=~/Library/Android/sdk); gradle :app:testDebugUnitTest --rerun-tasks --offline re-ran all 18 result XMLs to 137 tests, 0 failures, 0 errors, 0 skipped. The fresh app-debug.apk is 17,846,953 bytes, sha256 8ff68d24… — the same size but a different hash from d47c5bf… above, because APK signing is not byte-reproducible (called out in the run-73 review).
  • pane-opaque-wide-over-graph.png / pane-opaque-wide-over-timeline.png (2076x2152 @ 390dpi ≈ 852dp) and pane-opaque-narrow-over-graph.png / pane-opaque-narrow-over-timeline.png (wm size 1080x1920, wm density 480 ≈ 360dp): run 76's running implementer pane is one solid surfaceContainer sheet, from the fixed peek budget (546 px) to the right edge on the wide window and full-window on the narrow one, with the headline rows and section headers readable and the covered panes' peeks untouched. adb -s emulator-5554 logcat -d held 0 FATAL EXCEPTION / E AndroidRuntime lines; wm size/density were reset afterwards.
  • APK publish. Copied to ~/.local/share/pipelines/data/artifacts/77/1/pipelines-debug-wip-1fece88.apk (1fece88 = git rev-parse --short HEAD); local and streamed shasum -a 256 both return 8ff68d24…. curl -I http://10.0.0.249:8080/artifacts/77/1/pipelines-debug-wip-1fece88.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 17846953.

Mirror the open/close pane animation (16 Oct 2026, run 82)

A pane used to vanish on close: the destination cleared the selection that named it (a null itemId/stageKey) in the same recomposition that lowered the depth, so the sliding box carried no content, while the pane underneath swapped between its compact peek and its full body at the transition instant. The slide also used the default spring(), so it had no fixed duration or easing to run backwards.

  • SlidingPaneStack now slides every pane with one shared spec (paneSlideSpec): a fixed PANE_SLIDE_MILLIS (300) duration and a symmetric PANE_SLIDE_EASING (CubicBezierEasing(0.42, 0, 0.58, 1)), so the same curve run from the open offset back to the closed one is the open curve travelled backwards. A single close is therefore the exact time-reverse of the open.
  • The stack reports a level mounted while it is open or has not yet finished sliding out, and only then calls the caller's pane. The destinations name a level's content through the new rememberPaneContent(value), which keeps the last non-null value, so a closing pane keeps rendering the content that opened it until it is off-screen instead of vanishing. A fully closed level composes nothing, so a closed pane does no work and shows no stale content.
  • When one tap pops several levels, paneSlideDelayMillis waits PANE_POP_STEP_MILLIS (60) longer for each level below the topmost, so the cascade reverses in order. A level that is open or opening never waits, so a single-level open/close is unaffected.
  • Compose already maps the system animator duration scale onto its animations, so with animations disabled the slide is instant without a special case.
  • The covered pane's compact-vs-full presentation still swaps at the transition instant, exactly as opening already did (a styled change, not empty content); that presentation swap was not altered.

Verified on emulator-5554 only against the live server (wide fold layout, 2076x2152 / 390dpi ≈ 852dp; never the attached Pixel):

  • gradle :app:assembleDebug :app:testDebugUnitTest --offline → BUILD SUCCESSFUL; gradle :app:testDebugUnitTest --rerun-tasks --offline re-ran all 18 result XMLs to 140 tests, 0 failures, 0 errors, 0 skipped (3 new pure cases: the easing is its own reverse, a single close starts at once, several closing levels stagger from the top).
  • Open/close pair: input tap <timeline row> then input keyevent KEYCODE_BACK on run 80's Timeline, captured with screenrecord and split into open-1x-frames.png / close-1x-frames.png; the stage pane slides in from the right on open and slides back out to the right on close, revealing the run detail underneath, instead of vanishing.
  • Multi-level pop: at depth 2, tapping the list peek (onPopTo(0)) captured in multi-level-pop-1x-frames.png; the stage pane leaves first and the list is revealed level by level.
  • Slow motion (animator_duration_scale 10): open-close-slow10x.mp4 / open-close-slow10x-frames.png; the close frames are the open frames reversed.
  • Reduced motion: animator_duration_scale 0; 0.2 s after the open tap the stage pane is already at its final offset (title at x=585), and 0.2 s after Back the detail is already restored — unchanged 0.6 s later.
  • Narrow window (wm size 1080x1920, wm density 480 ≈ 360dp): narrow-open-1x-frames.png / narrow-close-1x-frames.png — the full-window run detail slides in from the right on open and back out to the right on close, revealing the runs list underneath; wm size/density reset afterwards.
  • Stability: tapping Back mid-open (0.8 s in at animator_duration_scale 10) settles fully at the detail, never half-slid.
  • adb -s emulator-5554 logcat -d held 0 FATAL EXCEPTION / E AndroidRuntime lines; animator_duration_scale was left at 1.
  • APK publish. app-debug.apk (18,012,493 bytes, sha256 d1c5506f…) copied to ~/.local/share/pipelines/data/artifacts/82/1/pipelines-debug-wip-1fece88.apk (1fece88 = git rev-parse --short HEAD); curl -I http://10.0.0.249:8080/artifacts/82/1/pipelines-debug-wip-1fece88.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 18012493.

Retain the parent identity of a closing pane (16 Oct 2026, run 82/3)

Review of the change above found a blocking defect: popTo(0) returns a bare PaneSelection (itemId=0, stageKey=null), and only the level-1 pane retained its itemId/version pair; the level-2 pane still read its parent id live from the selection, so closing a two-level stack to the list fed runId=0 / pipelineId=0 into the stage pane. The run was then null, the graph empty, the node not found, and the whole exit animation showed the terminal chip plus "No details recorded for this node." (captured in repro-pop-050.png / pl-pop-090.png); the same live read also reset the closing detail pane's section to Summary.

  • rememberPaneContent now retains the full parent identity at every level: pipeline detail (itemId, version, sectionIndex), pipeline stage (itemId, version, stageKey), run detail (itemId, sectionIndex) and run stage (itemId, stageKey, stageVisit). Each closing pane therefore keeps rendering the content, section and visit that opened it until it is off-screen; nothing a pane displays is read live from the selection while it exits.
  • No timing, easing or geometry changed — only what a closing pane reads.

Verified on emulator-5554 only (2076x2152 / 390dpi fold layout, live server), animator_duration_scale 10 for the frame work:

  • gradle :app:assembleDebug :app:testDebugUnitTest --offline → BUILD SUCCESSFUL; gradle :app:testDebugUnitTest --rerun-tasks --offline re-ran all 18 result XMLs to 140 tests, 0 failures, 0 errors, 0 skipped.
  • Pipeline multi-level pop (tapping the list peek, onPopTo(0), from depth 2): before-after-pipeline-pop.png puts the review's empty pl-pop-090.png (left) beside a frame of this build (right); every frame in multi-level-pop-pipelines-sheet.png shows the closing stage pane still rendering implementer / model / Stage definition with its Prompt, instead of the empty terminal state.
  • Runs multi-level pop: multi-level-pop-runs-sheet.png / multi-level-pop-runs-stage-mid-exit.png — the closing run stage pane keeps its run identity (Status completed, Outcome success, Duration 5m18s, Visit 2 / 5, Target reviewer, the Artifacts gallery), so runId is retained and the empty-node fallback never appears.
  • Single-level close (single-level-close-runs-sheet.png): the run detail slides back out to the right with its Summary section and rows intact, revealing the runs list underneath.
  • Reduced motion: animator_duration_scale 0; two captures 0.15 s and 0.6 s after Back are byte-identical (sha256 692437bc…), i.e. the close is instant.
  • adb -s emulator-5554 logcat -d held 0 FATAL EXCEPTION / E AndroidRuntime lines; animator_duration_scale was left at 1.
  • APK publish. app-debug.apk (18,012,767 bytes, sha256 b3b7d948…) copied to ~/.local/share/pipelines/data/artifacts/82/3/pipelines-debug-wip-1fece88.apk (1fece88 = git rev-parse --short HEAD); curl -I http://10.0.0.249:8080/artifacts/82/3/pipelines-debug-wip-1fece88.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 18012767; a streamed GET | shasum -a 256 returned the same b3b7d948….

Pane safe area (16 Oct 2026)

The pane stack now guarantees every pane clears the system UI from the live window insets instead of relying on each screen's implicit Material defaults. One shared paneSafeArea() (WindowInsets.safeDrawing: status bar, any display cutout, navigation bar and IME) is the single source of that geometry — never a fixed padding:

  • SlidingPaneStack reads it (unioned with systemGestures) for the covered peeks' strip geometry, so a peek also clears a cutout and the keyboard.
  • Each pane's Scaffold(contentWindowInsets = paneSafeArea()) reserves it once for the content, and its TopAppBar(windowInsets = paneSafeArea().only(Top + Horizontal)) reserves the top/horizontal part, so a pane can never sit under the status bar, a cutout, the navigation bar or the IME. Applied to the five stacked panes (PipelineListScreen, PipelineDetailScreen, RunHistoryScreen, RunDetailScreen, StageDetailPane) and to SettingsScreen.
  • No inset is applied twice: while the connection banner is shown it owns the top inset and the NavHost consumes paneSafeArea().only(Top) (was statusBars), so the pane's app bar directly below the banner is not padded a second time.
  • The search field lives inside the pane's Scaffold content, so it is already inside the safe area; a future floating overlay must read the same paneSafeArea().
  • The floating destinations pill clears the same safe area (windowInsetsPadding(paneSafeArea())), so the keyboard no longer hides it.

Evidence on emulator-5554 only (fold AVD; narrow wm size 1080x2340 @ 390dpi ≈ 443dp, wide wm size reset = 2076x2152 / 390dpi ≈ 852dp; never the attached Pixel), against the live server, driven with adb shell input / uiautomator dump and captured with android/scripts/capture_png.sh -s emulator-5554 (every image validated):

  • gradle :app:assembleDebug --console=plain → BUILD SUCCESSFUL (Gradle 8.11.1, JDK 17); app/build/outputs/apk/debug/app-debug.apk is 18,029,402 bytes, sha256 45c1bd09b9622dfe023ff62129a80c44b060bf7c15963757e3f1a5dfa5f851fb.
  • gradle :app:testDebugUnitTest --rerun-tasks --console=plain → BUILD SUCCESSFUL; the 18 result XMLs aggregate to 140 tests, 0 failures, 0 errors, 0 skipped.
  • safe-area-narrow-stage-pane.png / safe-area-wide-stage-pane.png: the run 84 implementer stage pane on the narrow and wide windows — the status bar and its icons are visible, and the pane's app bar and scrolling body sit fully below them, not clipped or covered.
  • safe-area-wide-ime-open.png / safe-area-wide-ime-scrolled.png: the pipeline search field focused (IME shown); the list scrolls inside the remaining space so the last pipeline row is fully visible above the keyboard, and the destination pill sits above the IME.
  • safe-area-wide-banner-owns-top.png: with the connection banner shown it owns the top inset and the pane's app bar follows directly below it — the inset is reserved once, never twice.
  • adb -s emulator-5554 logcat -d held 0 FATAL EXCEPTION / E AndroidRuntime lines; wm size was reset afterwards.
  • APK publish. Copied to ~/.local/share/pipelines/data/artifacts/86/1/pipelines-debug-wip-5ad4b58.apk (5ad4b58 = git rev-parse --short HEAD; the working tree is uncommitted WIP on top of it). curl -I http://10.0.0.249:8080/artifacts/86/1/pipelines-debug-wip-5ad4b58.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 18029402.

Full-screen artifact image viewer (16 Oct 2026)

Tapping an image artifact now opens a full-screen viewer (in the run summary grid, the per-visit artifacts list and the stage pane, which all render through ArtifactGallery), replacing the former small centred dialog rather than stacking on it. android/ only; no dependency was added, no run was started from the app, and every device command targeted emulator-5554 (never the attached Pixel, never emulator-5556).

  • Viewer. New ui/graph/ArtifactViewer.kt renders a scrim-backed full-screen Dialog (usePlatformDefaultWidth = false, decorFitsSystemWindows = false); a SideEffect stretches the dialog window to MATCH_PARENT, fits no system insets and draws into the display cutout (each API-guarded), so the dark backdrop reaches every edge while the content re-applies paneSafeArea() (status bar, cutout, navigation bar) itself. A top-right row keeps the open-in-new and copy-link actions and adds a close button, backed by a translucent scrim capsule so the light icons stay legible over a bright image. dumpsys window confirms the dialog window frame is [0,0][2076,2152] (previously inset to [0,136][2076,2074]).
  • Gestures. Pinch zooms about the centroid and a drag pans via the existing graph zoomAbout; a double-tap toggles between fit and 2.5x; a downward swipe at fit dismisses; a plain tap does nothing. Zoom is clamped to [1x, 5x] of fit and pan is clamped by the new pure clampImageOffset so the scaled image can never be dragged off screen (each axis centred when smaller than the viewport, pinned to [viewport - content, 0] when larger). Zoom state is remembered on the url, so closing the viewer or opening another image starts again at fit/centred. System Back and the close button dismiss the viewer without closing the pane behind it (verified: 0 Close viewer nodes and the run detail still shown after Back). The image loads through the existing cached, off-main-thread rememberArtifactBitmap (now internal, reusing the shared fetch/decode path), with a "Loading image…" spinner and a distinct "Couldn't load image." state. The loading/error/unavailable message is drawn in the light inverseSurface role, which contrasts with the always-black scrim (the previous inverseOnSurface was a dark colour on the scrim, measured ~1.6:1).
  • Pure helpers. fitImageSize, clampImageOffset and toggleZoomScale in ArtifactViewer.kt; ArtifactViewerTest covers them (fitting, centre/edge clamping, the toggle, and an anchored-zoom-then-clamp invariant). zoomAbout and the loading path are the existing shared ones, not copies.

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):

  • gradle :app:testDebugUnitTest :app:assembleDebug --console=plain → BUILD SUCCESSFUL; the result XMLs aggregate to 149 tests, 0 failures, 0 errors, 0 skipped (up from 140: the new ArtifactViewerTest). app/build/outputs/apk/debug/app-debug.apk is 18,043,579 bytes, sha256 1b3653dbdce9d62fc8dcfdcb986635829b70db38437d6769c77f91d16b7d6b3a.
  • gradle :app:lintDebug → only the two pre-existing windowLightNavigationBar NewApi errors (values/themes.xml, values-night/themes.xml); no new lint finding is attributed to ArtifactViewer.kt (39 warnings, down from 40 once the cutout constant was API-guarded).
  • On emulator-5554 against the live server, the run 90 summary artifacts grid was opened and captures/viewer/ (git-ignored, every PNG validated by scripts/capture_png.sh -s emulator-5554) holds: 01_viewer_open, 02_doubletap_zoom, 03_pinch_zoom, 04_pan, 05_clamp_1..3, 06_fit_reset, 07_swipedown_dismissed, 08_back_dismissed, 09_loading, 10_error, contact_sheet.png and viewer_gestures.mp4 (29 s). Pairwise pixel diffs (captures/imgdiff.py): open→double-tap 19.72, double-tap→pinch 6.72, pinch→pan 5.29, and 05_clamp_1→2 0.75 → 05_clamp_2→3 0.0 (the image is pinned at its bound and cannot be panned further off screen); fit-reset diff 0.01 (double-tap restores fit exactly). After a swipe-down and after Back the UI dump has 0 Close viewer nodes and the run detail is shown; a single tap leaves the viewer open (diff 0.02). Loading image… and Couldn't load image. were produced against a hanging and a 404 endpoint.
  • adb shell input cannot synthesise a two-finger pinch (it injects one pointer) and the shell cannot write /dev/input (sendevent is permission-denied on this production image), so pinch and the timed double-tap were driven with a test-only app_process injector (captures/viewer/tools/Injector.java → Injector.jar) that injects multi-pointer MotionEvents via the hidden InputManager.injectInputEvent, the same mechanism the platform input command uses. It is verification tooling only, not part of the app or its dependencies.
  • adb -s emulator-5554 logcat -d held 0 FATAL EXCEPTION / 0 E AndroidRuntime lines.
  • APK publish. Copied to ~/.local/share/pipelines/data/artifacts/91/1/pipelines-debug-wip-7b61906.apk (7b61906 = git rev-parse --short HEAD). curl -I http://10.0.0.249:8080/artifacts/91/1/pipelines-debug-wip-7b61906.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 18043579, and a streamed GET | shasum -a 256 equalled the local file's 1b3653db…. At 17.2 MiB it exceeds the 8 MiB per-file inventory cap, so it is served by direct URL only.

Not verified in this pass: a real hardware fold (the emulator is the 2076x2152 inner display at 390 dpi); an Android 8/9 device branch (the layoutInDisplayCutout Mode = SHORT_EDGES fallback is compiled and lint-guarded but only the API 36 path ran).

Share every artifact, from the grid cells and the per-visit rows (16 Oct 2026)

Every artifact item now carries a real share action: each image cell in a gallery grid (ArtifactTile) and each non-image row (ArtifactRow) has its own ArtifactShareButton. It is a child IconButton — its own 48dp hit area — so a tap on it consumes the gesture and never opens the image or the item, and its content description is Share <name>.

Sharing is not a stub. The new ui/graph/ArtifactSharing.kt fetches the resolved artifact through the app's existing client (AppViewModel.fetchArtifactBytes → PipelinesClient.fetchBytes, the shared OkHttp client) into cacheDir/shared-artifacts/ and hands the file to the platform chooser through the declared androidx.core.content.FileProvider (${applicationId}.fileprovider, scoped by res/xml/file_paths.xml to that one cache subdirectory, not exported). The intent is ACTION_SEND with EXTRA_STREAM, ClipData.newUri, MIME shareMimeType(contentType, fileName) and FLAG_GRANT_READ_URI_PERMISSION, so the receiving app gets the actual bytes. When the fetch fails the artifact's resolved link is shared as text/plain instead (shareDelivery). The cache is bounded: pruneSharedArtifacts drops entries older than a day and enforces a 64 MiB cap, oldest first. No new dependency: FileProvider comes from the already-declared androidx.core.ktx and the share glyph from the already-declared material-icons-extended.

  • gradle :app:testDebugUnitTest → 157 tests, 0 failures; the 7 new ones are ArtifactSharingTest (file/link fallback decision, artifact-to-file naming: content-type/url extension, suffix de-duplication, path sanitisation, per-url distinctness, and shareMimeType).
  • gradle :app:assembleDebug → succeeded, app-debug.apk 18,283,787 bytes, sha256 52ad15a6….
  • On emulator-5554 (density 390) against the live server, run 91's summary: the uiautomator dump shows a clickable share node of 117x117px = 48dp with a Share … content description beside every preview; the grid and the .mp4 row were captured (validated by scripts/capture_png.sh -s emulator-5554) to grid_cell_share.png and list_row_share.png.
  • Tapping a cell's share launched the chooser with the fetched file — logcat ActivityTaskManager: START u0 {act=android.intent.action.SEND … clip={image/png …}} (image/png), and the sharesheet showed a live preview of the actual PNG (share_intent_image_png.png). The .mp4 row's share resolved to clip={video/mp4 …}; the cached files are viewer_01_viewer_open_2f01f94a.png and viewer_viewer_gestures_8e1a3ba4.mp4 under cache/shared-artifacts/.
  • Fallback exercised live: with adb shell cmd connectivity airplane-mode enable (10.0.2.2 unreachable), tapping share opened the chooser titled Sharing link with the resolved http://10.0.2.2:8080/artifacts/91/1/viewer/viewer_gestures.mp4 as text (share_fallback_link.png); adb logcat -d held 0 FATAL EXCEPTION. Airplane mode was then disabled and the app reconnected.
  • Open and copy-link are unchanged and still enabled on both items.
  • APK publish. ~/.local/share/pipelines/data/artifacts/94/1/pipelines-debug-wip-d339827.apk (d339827 = git rev-parse --short HEAD), sha256 52ad15a6…; curl -I http://10.0.0.75:8080/artifacts/94/1/pipelines-debug-wip-d339827.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 18283787 (18 MB, over the 8 MiB inventory cap, so direct URL only). 10.0.0.75 is scripts/lan-address.py's output; 10.0.0.249 served it too.

Not verified in this pass: receiving the shared file inside a third-party app (the chooser was observed, not an app's import); the 24 h / 64 MiB prune bound was not reached on the emulator (only two small files were written).

Multi-select artifacts: bulk copy and share (16 Oct 2026)

A long-press on any artifact in a gallery now enters artifact selection: that item becomes selected with the app's tonal selected treatment, further taps toggle items instead of opening them, and a contextual action bar offers Copy links, Share and a close. It lives in both artifact surfaces — the run-summary grid (RunSummaryTab → ArtifactGallery) and the stage pane's per-visit artifacts list (ArtifactsSection) — and nowhere else (runs/pipelines lists are untouched).

  • Model. New ui/graph/ArtifactSelection.kt: an immutable ArtifactSelection keyed by the artifact url (enter, toggle, selectAll, clear, contains); selection mode is exactly "one or more urls selected", so it can never restore half-applied. ArtifactSelectionSaver (a listSaver) + rememberArtifactSelection save/restore it across configuration and reseed per run/visit.
  • Action bar. ArtifactSelectionBar is the pane's TopAppBar (it replaces the normal bar while selecting): title N selected, a close, a copy and a share, all Material 3 IconButtons (the measured 117x117 px = 48dp targets) with accurate descriptions ("Exit selection", "Copy selected links", "Share selected artifacts"). It applies the same paneSafeArea() top/horizontal insets as the bar it replaces, so it stays inside the status bar/cutout and above — never over — the items.
  • Copy links. artifactSelectionLinks resolves each selected url against the configured server through the existing resolvedArtifactUrl (no hardcoded host), joins one resolved absolute link per line, and copies it through the new one-line components/Clipboard.copyText (the single copy path, now also used by the code blocks, the pipeline source, the artifact row and the viewer). A Snackbar confirms Copied N links. Back leaves selection mode first (a pane-scoped BackHandler), only then runs the pane's own Back.
  • Bulk share. shareArtifacts fetches every selected artifact through the existing AppViewModel.fetchArtifactBytes and reuses the single-item writeSharedArtifact (same bounded cache, same FileProvider, same pruneSharedArtifacts) before one Intent.ACTION_SEND_MULTIPLE carrying every uri. Its type is the new pure bulkShareMimeType (the common type, else the wildcard) and its count is the chooser title. If any fetch fails the whole set degrades in the same action to the resolved links as text/plain (shareLinks). No parallel share path and no new dependency (icons come from the declared material-icons-extended).
  • Pure helpers / tests. ArtifactSelectionTest (enter, toggle, deselect-last, select-all + clear, restored state, the one-per-line link formatting, the labels) and two new ArtifactSharingTest cases (shareTargets resolution/drop, bulkShareMimeType common-type vs wildcard).

Evidence (macOS, JDK 17 Homebrew openjdk@17, Gradle 8.11.1 from the wrapper cache, ANDROID_HOME=~/Library/Android/sdk):

  • gradle :app:testDebugUnitTest :app:assembleDebug --console=plain → BUILD SUCCESSFUL; the result XMLs aggregate to 168 tests across 21 classes, 0 failures, 0 errors, 0 skipped (up from 157: the new ArtifactSelectionTest plus the two bulk-share cases). app-debug.apk is 17,913,089 bytes; the current tree's sha256 and the APK publish are recorded in the section below.
  • gradle :app:lintDebug → the same 2 pre-existing windowLightNavigationBar NewApi errors (values/themes.xml, values-night/themes.xml) and 39 warnings; the only warning attributed to a touched file is the pre-existing "Modifier parameter should be the first optional parameter" on StageDetailPane.
  • On emulator-5554 (never the physical Pixel, never emulator-5556; 2076x2152, density 390) against the live server, run 94's summary and per-visit list were driven. Every capture is in captures/selection/ (git-ignored) and was validated by scripts/capture_png.sh -s emulator-5554:
    • 01_longpress_selection.png — long-press on grid_cell_share.png entered the mode: the action bar reads 1 selected and the cell shows the tonal ring + check badge (its per-item share button hidden).
    • 02_several_toggled.png — three cells then a non-image row toggled on: 4 selected; the row wears the secondaryContainer/onSecondaryContainer treatment.
    • 03_bulk_copy_confirmation.png — Copy links showed the Copied 4 links Snackbar; pasting the clipboard into the Pipelines search field (06_clipboard_pasted_links.png) yielded exactly the four resolved absolute links, one per line, against the configured server (http://10.0.2.2:8080/artifacts/94/1/grid_cell_share.png … /94/2/lint-results-debug.txt), in the gallery's (candidate) order.
    • 04_bulk_share_intent.png — sharing the mixed 4 selected ran the file path: ActivityTaskManager: START … action.CHOOSER … clip={*/* hasLabel(11) 4 items: {U(content)} x4}, chooser titled "Sharing 4 files" (mixed types → wildcard).
    • 05_bulk_share_images_png.png — the 3 image cells alone resolved to a concrete type: clip={image/png hasLabel(11) 3 items: …}, chooser "Sharing 3 images".
    • 08_bulk_share_fallback_links.png — with cmd connectivity airplane-mode enable (10.0.2.2 unreachable) the same Share fell back in one action to text/plain: action.SEND, chooser "Sharing text" showing the three resolved links newline-joined. Airplane mode was then disabled.
    • 07_per_visit_selection.png — the stage pane's per-visit list enters the same mode (3 selected) with the action bar in the pane's safe area.
    • 09_rotation_restored.png — after user_rotation 1 (2152x2076) the 2 selected selection restored fully, not half-applied.
    • Back in selection mode exited the mode and left run 94 open (0 "Exit selection" nodes afterwards, the normal app bar returned); closing the stage pane by tapping the run peek and reopening the same visit showed no selection, confirming the pane-close clear.
    • adb -s emulator-5554 logcat -d held 0 FATAL EXCEPTION / 0 E AndroidRuntime.
  • APK publish. app-debug.apk copied to ~/.local/share/pipelines/data/artifacts/97/1/pipelines-debug-wip-1195535.apk (1195535 = git rev-parse --short HEAD); curl -I/-o against http://10.0.0.249:8080/artifacts/97/1/pipelines-debug-wip-1195535.apk (and 10.0.0.75) returned HTTP 200, Content-Type: application/vnd.android.package-archive, 17,913,089 bytes.

Not verified in this pass: a narrow-window layout of the selection bar (the emulator is the 851dp-wide inner display); receiving the bulk share in a third-party app (the chooser was observed, not an import).

Artifact selection: one shared host (16 Oct 2026)

The first pass left the run-summary and stage-pane selection wiring copy-pasted, and the refactor that removed the duplication had outrun this README. The final tree keeps one shared host: both RunDetailScreen (the run-summary grid) and StageDetailPane (the per-visit list) call ArtifactSelectionScaffold, which owns the remembered ArtifactSelection, the resolvedSelection lookup, the single artifactSelectionActions copy/share implementation, the SnackbarHostState and the pane-scoped BackHandler, and renders the contextual ArtifactSelectionBar in place of the surface's own top bar while selecting. Neither screen owns a SnackbarHostState or a BackHandler of its own.

artifactSelectionActions resolves every selected url through resolvedArtifactUrl (never a hardcoded host), copies the resolved links one per line through the one ClipboardManager.copyText, and shares every selected artifact through the single-item writeSharedArtifact/shareArtifacts path. artifactSelectionLinks resolves each selected url; artifactSelectionActions confirms the number of lines it actually produced (text.lines().size) rather than the raw selection size, so an absolute url plus an unresolvable relative one under no configured server reports the true count. writeSharedArtifact captures a non-null fileBytes from the shareDelivery check instead of asserting bytes!!. ArtifactSelection.selectAll is kept: it is the task's explicit select-all test surface even though no UI calls it.

Evidence, re-run on the same environment (JAVA_HOME=/opt/homebrew/opt/openjdk@17, Gradle 8.11.1 from ~/.gradle/wrapper/dists, ANDROID_HOME=~/Library/Android/sdk, emulator-5554 only):

  • gradle :app:testDebugUnitTest :app:assembleDebug --rerun-tasks --console=plain → BUILD SUCCESSFUL; the result XMLs aggregate to 168 tests across 21 classes, 0 failures, 0 errors, 0 skipped (ArtifactSelectionTest grew to 9 with resolvedSelectionKeepsOnlyTheCandidatesStillSelected). app-debug.apk is 17,913,089 bytes; its current sha256 and publish are in the doc-accuracy note below.

  • Rebuilt APK reinstalled on emulator-5554 (2076x2152, density 390); each frame validated by scripts/capture_png.sh -s emulator-5554 and kept in captures/selection-run100-final/ and ~/.local/share/pipelines/data/artifacts/100/1/:

    • 01_longpress_selection.png — long-press on grid_cell_share.png entered the mode: bar reads 1 selected, the cell wears the tonal ring + check, and every per-item Share/Open/Copy link node is gone from the uiautomator dump.
    • 02_several_toggled.png — three cells then the lint-results-debug.txt row toggled on → the action bar reads 4 selected; the two action-bar IconButtons measure 117x117 px = 48dp with the descriptions "Copy selected links" / "Share selected artifacts" ("Exit selection" for the close).
    • 03_bulk_copy_confirmation.png — Copy links showed the Copied 4 links Snackbar, and the system clipboard preview under the share bar showed the resolved absolute link (http://10.0.2.2:8080/artifacts/94/1/grid_cell_share.png…).
    • 04_bulk_share_intent.png — Share of the mixed 4 ran the file path (dumpsys activity activities: Intent { act=android.intent.action.CHOOSER … clip={*/* hasLabel(11) 4 items: {U(content)} x4} (has extras) }), i.e. one ACTION_SEND_MULTIPLE carrying 4 fetched files, typed by the mixed-set wildcard. The file path ran because the configured server (10.0.2.2:8080) was reachable, so every fetch returned bytes; the unchanged shareLinks fallback (unit-covered by shareDeliveryIsAFileOnlyWhenTheFetchReturnedBytes) is the branch a failed fetch would take in the same action.
    • 05_per_visit_selection.png — the stage pane's per-visit list enters the same mode (1 selected) with the bar inside the pane safe area.
    • Back exited selection mode first and left Run 94 open (0 "Exit selection" nodes afterwards, Run 94 still present); adb -s emulator-5554 logcat -d held 0 FATAL EXCEPTION / 0 E AndroidRuntime.
  • APK publish. app-debug.apk copied to ~/.local/share/pipelines/data/artifacts/100/1/pipelines-debug-wip-1195535.apk (1195535 = git rev-parse --short HEAD); curl against http://10.0.0.249:8080/artifacts/100/1/pipelines-debug-wip-1195535.apk (and 10.0.0.75) returned HTTP 200, Content-Type: application/vnd.android.package-archive, 17,913,089 bytes.

  • Doc-accuracy pass (16 Oct 2026). The ArtifactSelection.kt doc comment and this README's "in selection order" claim said the bulk copy preserves selection order; it actually writes one resolved link per line in gallery (candidate) order, because resolvedSelection filters the surface's own candidates. Both now state candidate order; no runtime behavior changed. Re-verified on the same environment: gradle :app:testDebugUnitTest :app:assembleDebug --rerun-tasks --console=plain → BUILD SUCCESSFUL, the result XMLs aggregate to 168 tests across 21 classes, 0 failures, 0 errors, 0 skipped; app-debug.apk is 17,913,089 bytes, sha256 a6d5caeb0c1e69da879aabfcc7df2eec09e4a44c85000adba3444558a1d3d82b. The sha is not a stable tree fingerprint — it moves with any source edit, because the debug APK embeds Kotlin source info (a comment-only edit to ArtifactSelection.kt left only classes6.dex different) — so run 100's build read 763806783f…. The APK was published to ~/.local/share/pipelines/data/artifacts/100/3/pipelines-debug-wip-1195535.apk; curl against http://10.0.0.75:8080/artifacts/100/3/pipelines-debug-wip-1195535.apk (and 10.0.0.249) returned HTTP 200, Content-Type: application/vnd.android.package-archive, 17,913,089 bytes.

Not verified in this pass: the link fallback on-device (the reachable server ran the file path); a narrow-window layout of the selection bar; receiving the bulk share in a third-party app (the chooser was observed, not an import).

Named motion tokens and animated list changes (16 Oct 2026, run 104/1)

Every animation duration and easing now lives in one file, and the pipelines and runs lists animate per item instead of cutting.

  • One motion token file. ui/components/Motion.kt (beside the pane's dimension tokens in SlidingPaneStack.kt) defines two named tokens, each a duration + easing pair: MotionQuick (120ms) for small in-place state changes (the section chevron, a list row appearing/leaving) and MotionStandard (220ms) for content moving or swapping (a pane sliding, a section cross-fading, an item taking a new place in a re-sorted list). Nothing exceeds the MAX_MOTION_MILLIS (300ms) cap and both easings are monotonic ease-in-out curves; MotionStandard is symmetric, which is what keeps a pane close the exact reverse of its open. A call site asks a token for its concrete spec via spec(); it never writes a duration. The pane slide, the section Crossfade and the chevron now use the tokens (PANE_SLIDE_* / SECTION_SWAP_MILLIS are gone), and the pane pop stagger moved in as MOTION_STAGGER_MILLIS.
  • Per-item list animation. A single shared LazyItemScope.animateListItem() (ListRow.kt) wraps Compose's supported Modifier.animateItem(fadeInSpec, placementSpec, fadeOutSpec) with the tokens: an item fades in as it appears and out as it leaves (MotionQuick), and the items still on screen slide to their new positions when the list is refreshed, filtered or re-sorted (MotionStandard) rather than jumping. Pipelines rows, run rows, pipeline version rows and run evidence rows all use it. Because it is the supported lazy-list item animation the list keeps its own scroll/measure state; the modifier only drives the transition, so a resting list is unchanged.
  • System animation setting. The tokens map onto Compose's standard animations, so the platform animator duration scale applies unchanged: with animations disabled each spec runs for zero time and an item is at its final state at once, no special case.
  • No per-frame allocation. Specs are built at composition time, not per frame, and the chevron reads its animating angle inside the layer (graphicsLayer { rotationZ = … }) so it turns without recomposing the header each frame.

Verified on emulator-5554 only (fold layout, 2076x2152 / 390dpi ≈ 852dp, against the live server; never the attached Pixel):

  • gradle :app:assembleDebug :app:testDebugUnitTest --offline --console=plain (Gradle 9.7.1, JDK 17, ANDROID_HOME set) → BUILD SUCCESSFUL. gradle :app:testDebugUnitTest --rerun-tasks --offline re-ran every result XML to 174 tests across 22 classes, 0 failures, 0 errors, 0 skipped; the new MotionTest (6 cases) checks the token ordering (quick shorter than standard), the per-token bands (quick 100-150ms, standard 200-250ms), the ≤300ms cap, that every easing is monotonic 0→1, that MotionStandard reverses itself, and that a spec carries its token's timing. SlidingPaneStackTest now reads the pane's timing from the token.
  • Filter change (filter.mp4, frames sheet1.png/sheet2.png): at animator_duration_scale 5, typing docker into the pipelines search fades the non-matching rows out and moves the survivors up; deleting it brings the rows back in.
  • A new run arriving (newrun.mp4, frames newrun_arrival.png / newrun_sheet1.png): run 105 was admitted out-of-band with pipelines run --json --pipeline 8 … --yes (not from the app); tapping Refresh in the Runs list shows run 105 fade in at the top while every existing row slides down to make room. Run 105 then failed (its stage returned blocked), so nothing had to be reclaimed.
  • Reduced motion (red_sheet.png): at animator_duration_scale 0, typing d/do/doc/dock leaves each captured frame fully settled — no ghosted or half-placed rows — i.e. the change is instant with no partial state.
  • adb -s emulator-5554 logcat -d held 0 FATAL EXCEPTION / 0 E AndroidRuntime lines; animator_duration_scale was left at 1.
  • APK publish. app-debug.apk (17,913,089 bytes, sha256 4bc1b781…) copied to ~/.local/share/pipelines/data/artifacts/104/1/pipelines-debug-wip-0b74903.apk (0b74903 = git rev-parse --short HEAD); curl -I http://10.0.0.249:8080/artifacts/104/1/pipelines-debug-wip-0b74903.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 17913089, and a streamed curl | shasum -a 256 returned the same 4bc1b781….

Not verified in this pass: a narrow-window frame of the item animation; an item leaving a list (a run being deleted is not a client action), only the appear/move halves driven above.

Loading, empty and error states cross-fade (16 Oct 2026)

A data-backed pane used to swap its loading spinner, empty message, error message and content with a plain when, so content flashed from empty to full and an empty or error state popped. Every pane now swaps through one shared StateCrossfade (ui/components/States.kt) — a Crossfade on the pane's classified state using the already-named MotionStandard token. No dependency, geometry token or literal was added.

  • LoadPhase is the mutually exclusive presentation state: Loading, Error(message), Empty(message), Content. The message-carrying phases keep the text they were classified with, so the branch that is fading out is never recomposed against a since-cleared error or a since-changed filter.
  • listLoadPhase(loading, error, hasData, emptyMessage) and detailLoadPhase(error, hasData) are the pure classifiers. A list pane reports a failed load with no data, then a load with no data, then empty, else content; a detail pane has no empty state, so data present is content, then a reported error, then loading. Stale data keeps a pane on Content (the screen shows the error inline), exactly as before — only the presentation changed.
  • StateCrossfade(phase) wraps the branch in a Crossfade with MotionStandard.spec(); both branches are laid out in one box, so the resting layout is exactly the branch's own layout and the outgoing phase fades under the incoming one. Applied to PipelineListScreen, RunHistoryScreen, PipelineDetailScreen and RunDetailScreen. LoadingState, ErrorState and EmptyState themselves are unchanged.
  • The detail panes render the fading-out branch from the last non-null item (rememberPaneContent, the same helper the closing pane uses), so selecting another pipeline/run fades the old content out instead of blanking it.
  • The Runs pane has no pane-level empty state — an empty list keeps its usage block and sticky headers and shows its No runs have been recorded yet. line inside the list, where it now fades in/out through the existing animateListItem(), as does its inline error line.

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

  • gradle :app:assembleDebug :app:testDebugUnitTest --console=plain → BUILD SUCCESSFUL; --rerun-tasks re-ran all 23 result XMLs to 184 tests, 0 failures, 0 errors, 0 skipped (up from 174; the new LoadPhaseTest adds 10 pure cases for the classifiers and the message-carrying phases). app/build/outputs/apk/debug/app-debug.apk is 17,913,089 bytes, sha256 e99bb970….
  • On emulator-5554 only (fold AVD, 2076x2152 / 390dpi; never the attached Pixel, never emulator-5556), against the live server, each frame captured and validated with scripts/capture_png.sh -s emulator-5554, animator_duration_scale used only to slow the capture:
    • Loading → content at animator_duration_scale 10 (load-to-content-10x.mp4, load-to-content-10x-sheet.png): selecting a pipeline shows Loading pipeline… and the summary then fades in; load-to-content-10x-overlap.png freezes the cross-fade with the loading text (…ding pip…) and the dimmed summary visible together, instead of a flash.
    • Empty appearing and going away at scale 10 (empty-appear-disappear-10x-sheet.png): typing zzz into the pipelines search makes No pipelines match "zzz". fade in, and clearing it fades the list back.
    • Error → content at scale 10 (error-to-content-recovery-10x-sheet.png): with the connection down the Runs pane showed the error state; after the connection returned, pressing Retry fades the error out and the loaded runs (usage block, day groups) in.
    • Animations disabled (animator_duration_scale 0): disabled-empty-sheet.png (same type/clear) and disabled-content-sheet.png (open a pipeline) are each fully settled on every frame — no ghosted or half-placed state, i.e. the swap is instant with no special case.
    • Resting layout: a settled Pipelines list captured at scale 1 and at scale 0 is pixel-identical (captures/imgdiff.py → ([0.0, 0.0, 0.0], 0.0)), so the cross-fade never alters the settled layout.
  • adb -s emulator-5554 logcat -d held 0 FATAL EXCEPTION / 0 E AndroidRuntime lines; animator_duration_scale was left at 1; no run was started from the app.
  • APK publish. app-debug.apk copied to ~/.local/share/pipelines/data/artifacts/106/1/pipelines-debug-wip-934994d.apk (934994d = git rev-parse --short HEAD; the working tree is uncommitted WIP on top of it), sha256 e99bb970…. curl http://10.0.0.75:8080/artifacts/106/1/pipelines-debug-wip-934994d.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 17913089, and a streamed GET | shasum -a 256 returned the same e99bb970… (10.0.0.249 served it too; at 17.1 MiB it exceeds the 8 MiB per-file inventory cap, so it is served by direct URL only).

Not verified in this pass: a narrow-window frame (the fold inner display is 851dp wide); the error state's fade-in from loading (the disconnected load failed before a loading frame could be drawn, only its fade-out was captured).

Animated selection and state changes (16 Oct 2026, run 109/1)

Selection and live state changes animate instead of cutting, and every resting state is unchanged. All of it reuses the one Motion.kt token file; no new dependency, geometry or literal.

  • The destination pill's indicator travels. DestinationPill (PipelinesApp.kt) now draws one selection indicator behind the three icons and animates its offset between them (animateDpAsState, MotionStandard), so picking another destination slides the highlight across rather than each icon swapping its own background; the glyph tint cross-fades in step (animateColorAsState). The geometry comes from two named tokens, DESTINATION_ITEM_SIZE/DESTINATION_ITEM_GAP (the existing 48dp target and 4dp gap, named once), through the pure destinationIndicatorOffsetDp, which is unit-tested. The icons own the taps, so a tap registers while the indicator is still travelling, and a rapid run of taps only retargets the one animator.
  • A selected row's highlight fades in. The shared ListRow animates its tonal container and content colour under MotionQuick instead of switching, so selecting a pipeline/run row fades the secondaryContainer highlight in and out; the settled row is exactly the old one.
  • Section bodies animate with their chevron. A new shared CollapsibleSectionBody (Sections.kt) wraps a section's body in AnimatedVisibility with expandVertically/shrinkVertically + fade under MotionQuick — the same token the SectionHeader chevron turns with — so the content and the chevron move together. Both collapsibleSection (the lazy variant) and the stage pane's StageSection use it; collapsed, the body is not composed, so a resting section is unchanged. (The section switch was already an in-place Crossfade with no lateral motion and is unchanged.)
  • A live run's status change animates. StatusChip eases its container and label colour under MotionQuick and RunStatusIcon eases its glyph tint, so a run whose status changes while the 1s poll is running visibly transitions the chip and the row's leading accent instead of silently swapping a colour.
  • Taps, pause and the animator scale. These are ordinary Compose animators, so the platform animator duration scale applies unchanged (disabled = instant), the recomposer pauses them while the screen is not resumed, and the selectable/clickable nodes are independent of the animators, so taps register mid-animation.

Verified on emulator-5554 only (fold layout, 2076x2152 / 390dpi; never the attached Pixel, never emulator-5556), against the live server; each frame captured and validated with scripts/capture_png.sh -s emulator-5554:

  • gradle :app:assembleDebug :app:testDebugUnitTest --offline --console=plain → BUILD SUCCESSFUL; gradle :app:testDebugUnitTest --rerun-tasks --offline re-ran every result XML to 186 tests across 23 classes, 0 failures, 0 errors, 0 skipped. The new PipelinesNavTest cases check the indicator offset lines up with each slot and pins to slot 0 when nothing is selected.
  • Pill selection moving at animator_duration_scale 6 (pill_0/1/5.png): with Pipelines selected, tapping Runs leaves pill_0 on Pipelines, pill_1 freezes the highlight between the two icons, and pill_5 settles under Runs.
  • Section collapsing at animator_duration_scale 15 (sec2_expand_3.png, sec2_collapse_2.png): the Input tab's prompt section expands with the code block revealing under a down chevron, and collapses with the block clipped and the following pwd header rising as the chevron returns.
  • Live status change (status3_post_01/02/03.png): run 112 was started out-of-band with pipelines run … --pipeline 1 --prompt "… sleep 45 …" (not from the app) and watched in its open detail; its summary chip goes from running (status3_post_01) through the mid-transition tint (status3_post_02) to succeeded (status3_post_03).
  • Taps mid-animation: at scale 15, tapping Runs and then Settings 0.2s later (while the indicator was still travelling) landed on the Settings screen, so the second tap registered.
  • adb -s emulator-5554 logcat -d held 0 FATAL EXCEPTION / 0 E AndroidRuntime lines; animator_duration_scale was left at 1.
  • APK publish. app-debug.apk (18,133,184 bytes, sha256 567c437d…) copied to ~/.local/share/pipelines/data/artifacts/109/1/pipelines-debug-wip-b89ad29.apk (b89ad29 = git rev-parse --short HEAD); curl -I http://10.0.0.249:8080/artifacts/109/1/pipelines-debug-wip-b89ad29.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 18133184, and a streamed curl | shasum -a 256 returned the same 567c437d….

Not verified in this pass: a clean settled frame of the selected-row highlight (it fades in while the wide layout then covers the list with the opened pane, so only a transient mid-fade frame was captured); resume-after-pause of an in-flight animation on device (the pause is Compose's own recomposer behaviour, not code here).

One source of truth for app geometry, with an enforcement test (16 Oct 2026)

android/ only. No layout changed: every moved value is identical, so the app renders exactly as before. No new dependency, no server/Go/installer/Docker file touched, no run started from the app.

  • ui/theme/Dimens.kt is the single source of truth for app geometry, alongside Typography.kt for type. It defines the 4dp spacing scale (SPACING_XXS/XS/S/M/L/XL/XXL, each comment tied to that base step) and moves the geometry constants that already existed: PEEK_WIDTH_DP (the collapsed/peek strip), PEEK_BUDGET_DP, MIN_ACTIVE_PANE_WIDTH_DP, MIN_COVERED_PANE_WIDTH_DP (from SlidingPaneStack.kt), DESTINATION_PILL_RESERVE (from PipelinesApp.kt), WIDE_RAIL_WIDTH_DP and DETAIL_MAX_WIDTH_DP (from DetailTabs.kt). The removed LIST_PANE_WIDTH, COLLAPSED_LIST_PANE_WIDTH and COLLAPSED_RAIL_WIDTH_DP no longer exist, so there was nothing to move for the "list pane width" or the rail's collapsed width; the collapsed strip that survives is PEEK_WIDTH_DP. Call sites import the tokens; their values (56/224/320/112/88/200/840) are unchanged.
  • ui/theme/DimensTest.kt scans the app's Kotlin sources (src/main/java, excluding Dimens.kt) for raw dp/sp literals, masking comment and string contents first so prose and URLs are not hits. It allow-lists the 34 literals that predate the file, each with a written reason (structural zeros/hairlines, the 4dp-scale members that are not yet migrated, component glyph sizes, the workflow-graph's own pixel geometry, container sizes and the sp typography values owned by Typography.kt). A literal that is neither a token nor allow-listed fails with file:line: literal. The list is expected to shrink as call sites move onto the tokens.

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

  • gradle :app:assembleDebug :app:testDebugUnitTest --rerun-tasks --console=plain → BUILD SUCCESSFUL; --rerun-tasks re-ran all 24 result XMLs to 188 tests, 0 failures, 0 errors, 0 skipped (up from 186/23; the new DimensTest adds rawDimensionLiteralsAreTokensOrReasonedAllowListEntries and everyAllowListEntryHasAWrittenReason). app/build/outputs/apk/debug/app-debug.apk is 17,929,473 bytes, sha256 e52ceb25….
  • Enforcement proof. Adding private val PROBE_RAW_LITERAL = 123.dp to ui/PipelinesApp.kt made gradle :app:testDebugUnitTest --tests net.awan.pipelines.ui.theme.DimensTest FAILED with raw dimension literals outside net/awan/pipelines/ui/theme/Dimens.kt: [net/awan/pipelines/ui/PipelinesApp.kt:455: 123.dp] (file, line and literal); removing the line made the same task BUILD SUCCESSFUL. The probe was reverted.
  • Before/after screenshots on emulator-5554 only (fold AVD, 2076x2152 / 390dpi; never the attached Pixel, never emulator-5556), against the live server, each frame captured and validated with scripts/capture_png.sh -s emulator-5554: the before APK was built from HEAD d019213 (android changes stashed, built, then restored) and the after APK from the working tree, each installed with adb -s emulator-5554 install -r, force-stopped and relaunched. Screen A is the Pipelines list; screen B is the "Complete a Task" pipeline detail (the wide rail plus the covered list peek, i.e. the moved rail/detail/pane tokens). captures/imgdiff.py reports ([0.0, 0.0, 0.0], 0.0) for both the A and B pairs — pixel-identical before and after.
  • adb -s emulator-5554 logcat -d held 0 FATAL EXCEPTION / 0 E AndroidRuntime lines; animator_duration_scale was left at 1; no run was started from the app.
  • APK publish. app-debug.apk copied to ~/.local/share/pipelines/data/artifacts/116/1/pipelines-debug-wip-d019213.apk (d019213 = git rev-parse --short HEAD; the working tree is uncommitted WIP on top of it), sha256 e52ceb25…. curl -I http://10.0.0.249:8080/artifacts/116/1/pipelines-debug-wip-d019213.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 17929473, and a streamed GET | shasum -a 256 returned the same e52ceb25….

Not verified in this pass: whether :app:lintDebug stays at its two pre-existing NewApi errors (it was not run).

The list and detail screens on the geometry tokens (16 Oct 2026)

android/ only. Every replacement is value-equal, so the screens render exactly as before. No new dependency, no server/Go/installer/Docker file touched, no run started from the app, and every adb/emulator command targeted emulator-5554 only (never emulator-5556 or the attached Pixel).

  • Scope. The four list/detail screens (ui/screens/PipelineListScreen.kt, RunHistoryScreen.kt, PipelineDetailScreen.kt, RunDetailScreen.kt) and the shared components they are built from (ListRow, States, Sections, PaneIdentity, ConnectionBanner, FilterMenu, CodeBlock, RunStatus, DetailTabs). The navigation chrome (SlidingPaneStack, PipelinesApp) and the workflow-graph package keep their literals.
  • Spacing. Every 4/8/12/16/24dp padding, gap and arrangement on those files now references the previous item's SPACING_XS/S/M/L/XL tokens (and SPACING_XXS for the 2dp chip gaps); no value changed. The 10dp dense row padding, the 2dp progress hairline and the 0.dp elevations stay as reasoned allow-list entries because they are not on the spacing scale.
  • Glyph sizes. Four new tokens in ui/theme/Dimens.kt name the icon sizes that cannot derive from layout: ICON_STATUS_DP (14dp), ICON_INLINE_DP (18dp), ICON_LIST_DP (20dp) and ICON_RAIL_DP (24dp), used by RunStatus, CodeBlock, RunHistoryScreen, RunDetailScreen, PipelineDetailScreen and DetailTabs.
  • The allow-list shrinks. ui/theme/DimensTest.kt's allow-list drops from 30 to 24 entries: 14.dp, 18.dp and 20.dp are gone because their last call site migrated, and the already-unused 32.dp, 11.sp and 13.sp entries were removed. The remaining entries are the structural hairlines/zeros (0/2/3/6dp), the not-yet-migrated graph/app-shell values, the container sizes and the sp type values owned by Typography.kt.

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

  • gradle :app:assembleDebug :app:testDebugUnitTest --rerun-tasks --console=plain → BUILD SUCCESSFUL; --rerun-tasks re-ran all 30 result XMLs to 259 tests, 0 failures, 0 errors, 0 skipped. app/build/outputs/apk/debug/app-debug.apk is 17,995,009 bytes, sha256 d40d7b78….
  • Allow-list shrinks. git show HEAD:…DimensTest.kt counts 30 entries; the working tree counts 24 (14.dp, 18.dp, 20.dp, 32.dp, 11.sp, 13.sp gone, the rest re-reasoned).
  • Enforcement proof. Appending private val PROBE_RAW_LITERAL = 123.dp to ui/components/ListRow.kt made gradle :app:testDebugUnitTest --tests net.awan.pipelines.ui.theme.DimensTest FAILED with raw dimension literals outside net/awan/pipelines/ui/theme/Dimens.kt: [net/awan/pipelines/ui/components/ListRow.kt:113: 123.dp]; removing the line made the same task pass. The probe was reverted.
  • Before/after screenshots on emulator-5554 only (fold AVD, 2076x2152 / 390dpi, dark mode; narrow 1080x2340 and wide 2000x3400 via wm size; never emulator-5556 or the attached Pixel), against the live server at ws://10.0.2.2:8080/connect, each frame captured and validated with scripts/capture_png.sh -s emulator-5554. The before APK was built from HEAD 8e49a0c (sha256 e50bb381…) with the working changes stashed; the after APK from the working tree (sha256 d40d7b78…). Every converted screen was captured at both widths (Pipelines list, Runs list, pipeline detail, run detail): geom-<screen>-<width>-before.png / -after.png in ~/.local/share/pipelines/data/artifacts/122/1/. captures/imgdiff.py reports a mean channel difference of 0.01–0.04 for both detail screens, 0.02–0.04 for the Pipelines list and 0.04–0.12 for the Runs list, all confined to the status-bar clock, the live relative-time/badge text and thumbnails that load asynchronously; the layout itself is unchanged.
  • adb -s emulator-5554 logcat -d held 0 FATAL EXCEPTION / 0 E AndroidRuntime lines; animator_duration_scale was left at 1; no run was started from the app.
  • APK publish. app-debug.apk copied to ~/.local/share/pipelines/data/artifacts/122/1/pipelines-debug-wip-8e49a0c.apk (8e49a0c = git rev-parse --short HEAD; the working tree is uncommitted WIP on top of it), sha256 d40d7b78…. curl -I http://10.0.0.249:8080/artifacts/122/1/pipelines-debug-wip-8e49a0c.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 17995009, and a streamed GET | shasum -a 256 returned the same d40d7b78….

Not verified in this pass: :app:lintDebug (not run); the Runs-list and run-detail before/after pairs are not byte-identical because their live relative-time text and artifact thumbnails load asynchronously.

The graph, panes, rail and sheet on the geometry tokens (16 Oct 2026)

android/ only. Every replacement is value-equal, so the workflow graph, the artifact gallery/viewer and the pane surfaces render exactly as before. No new dependency, no server/Go/installer/Docker file touched, no run started from the app, and every adb/emulator command targeted emulator-5554 only (never emulator-5556 or the attached Pixel).

  • Scope. The workflow-graph package (ui/graph/WorkflowGraph.kt, StageDetailPane.kt — the stage detail sheet — Artifacts.kt, ArtifactViewer.kt, ArtifactImage.kt) plus the two navigation components the previous item left with their literals: the sliding pane (ui/components/SlidingPaneStack.kt) and the detail rail (ui/components/DetailTabs.kt). The pane and the rail already derive every width and offset from tokens, so their only remaining literal is the structural 0.dp recorded in the allow-list; the graph/sheet/gallery files carried the rest.
  • Spacing. Every 2/4/8/12/16/24dp padding, gap, arrangement and offset on those files now references SPACING_XXS/XS/S/M/L/XL; no value changed.
  • New tokens. The off-scale component and graph-chrome sizes move into ui/theme/Dimens.kt: the run legend's GRAPH_LEGEND_PAD_X (6dp), GRAPH_LEGEND_PAD_Y (3dp) and GRAPH_LEGEND_GAP (10dp); the collapsed GRAPH_PANEL_MIN_HEIGHT (320dp, moved off WorkflowGraph.kt and now imported by its test); the gallery's ARTIFACT_TILE_DP (96dp), ARTIFACT_THUMB_DP (56dp), ARTIFACT_BADGE_DP (16dp), ARTIFACT_PROGRESS_DP (24dp) and ARTIFACT_PROGRESS_STROKE_DP (2dp); and the stage-type chip's STAGE_CHIP_PAD_H (10dp). The artifact tile/row and thumbnail corner radii derive from the Material shape scale (MaterialTheme.shapes.medium/.small), exactly as the graph's own node corners already do, so no radius literal remains.
  • The allow-list shrinks. ui/theme/DimensTest.kt's allow-list drops from 24 to 21 entries: 24.dp, 56.dp and 96.dp are gone because their last call site migrated onto a token. The remaining entries are the structural hairlines/zeros (0/2/3/6dp), the spacing values still used by the not-yet- migrated app shell and Settings screen, and the sp type values owned by Typography.kt.

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

  • gradle :app:assembleDebug :app:testDebugUnitTest --rerun-tasks --console=plain → BUILD SUCCESSFUL; --rerun-tasks re-ran all 30 result XMLs to 259 tests, 0 failures, 0 errors, 0 skipped. app/build/outputs/apk/debug/app-debug.apk is 17,995,009 bytes, sha256 c5da095aec8a01120d4d847da69f71fa2fe0f937290f3c9a5190a9de8b813b0f.
  • Allow-list shrinks. git show HEAD:…DimensTest.kt counts 24 entries; the working tree counts 21.
  • Enforcement proof. Appending private val PROBE_RAW_LITERAL = 123.dp to ui/graph/Artifacts.kt made gradle :app:testDebugUnitTest --tests net.awan.pipelines.ui.theme.DimensTest FAILED with raw dimension literals outside net/awan/pipelines/ui/theme/Dimens.kt: [net/awan/pipelines/ui/graph/Artifacts.kt:497: 123.dp]; removing the line made the same task BUILD SUCCESSFUL. The probe was reverted.
  • Before/after screenshots on emulator-5554 only (fold AVD, 2076x2152 / 390dpi; narrow 1080x2340 and wide 2000x3400 via wm size; never emulator-5556 or the attached Pixel), against the live server at ws://10.0.2.2:8080/connect, each frame captured and validated with scripts/capture_png.sh -s emulator-5554. The before APK was built from a git archive HEAD tree (3765fdf, sha256 d40d7b78…, byte-identical to the previous item's published APK); the after APK from the working tree (sha256 c5da095a…). Three surfaces were captured at both widths — the Pipelines list (the panes), the "Friend demo" pipeline Graph tab, and the opened stage detail sheet — as graph-*, sheet-* and list-{narrow,wide}-{before,after}.png in ~/.local/share/pipelines/data/artifacts/125/1/. captures/imgdiff.py reports a mean channel difference of 0.0 for the wide sheet, 0.01 for the wide/narrow graph and the wide list, and 0.03 for the narrow sheet — the only differing pixels are the status-bar clock; the list pairs also differ on their live relative-time text. The layout itself is unchanged.
  • adb -s emulator-5554 logcat -d held 0 FATAL EXCEPTION / 0 E AndroidRuntime lines; animator_duration_scale was left at 1; no run was started from the app.
  • APK publish. app-debug.apk copied to ~/.local/share/pipelines/data/artifacts/125/1/pipelines-debug-wip-3765fdf.apk (3765fdf = git rev-parse --short HEAD; the working tree is uncommitted WIP on top of it), sha256 c5da095a…. curl -I http://10.0.0.249:8080/artifacts/125/1/pipelines-debug-wip-3765fdf.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 17995009, and a streamed GET | shasum -a 256 returned the same c5da095a….

Not verified in this pass: :app:lintDebug (not run); the app shell (PipelinesApp.kt) and the Settings screen still keep their literals, so those allow-list entries remain.

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 filled arrowhead proportional to its own width (edgeArrowHeadSize, i.e. strokeWidth * ARROW_HEAD_SCALE with ARROW_HEAD_SCALE = 4: 28f for this 7f pass/fail stroke, 12f for a normal executed route), 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.

A modern visual language for the workflow graph (16 Oct 2026)

The graph read like an old terminal diagram (flat fills, hard outlines, sharp right angles, [bracketed] all-caps labels, small arrowheads, raw text over the canvas). This pass gives it a modern surface language without changing any information or any hue. android/ only; no dependency was added (the graph's corner comes from the theme's own shape scale), 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 only modified tracked files are the four under android/ shown in git status --short below; the capture runs also leave untracked scratch directories at the repo root (.ui_review*/), so a bare git status --short is not clean and the "nothing outside android/ touched" claim is only about the change itself, not those untracked captures.

  • Nodes are rounded and tonal, terminals are pills. WorkflowGraph.kt reads MaterialTheme.shapes.medium once per composition for a stage's corner and gives a terminal a full pill (height/2), so a terminal is visibly not a stage. The fill is a tonal surface: the new pure tonalFill(surface, accent, fraction) blends a raised surfaceContainerHigh with a subtle fraction of the node's semantic colour (NEUTRAL_TINT/KIND_TINT for a stage by kind, TERMINAL_TINT for a terminal's success/error hue), and the hard outline is replaced by a soft outlineVariant border (NODE_BORDER, strengthened for a selected stage with NODE_BORDER_SELECTED). Every kind's hue survives; the terminal fill now genuinely tints the outcome hue.
  • Type comes from the app's scale. The node name uses the app's cardTitle role and the outcome labels its label role (no ad-hoc 13.sp/11.sp), with the theme's own line height and letter spacing; the [brackets] and the all-caps SUCCESS/FAILURE are gone — the graph shows Success/Failure in the terminal's own colour (the new pure nodeDisplayLabel; the shared GraphSemantics.nodeLabel the TUI-mirroring panes use is untouched).
  • Edges are smoother, with one control offset and matched arrowheads. The stored route is still the axis-aligned polyline (routePoints, and its layout tests, are unchanged), but drawing now rounds every right-angle bend with the single ROUTE_CORNER_RADIUS control offset (the pure cornerCutRadius clamps a short adjacent segment to half its length so two cut-backs can never meet), uses StrokeCap.Round/StrokeJoin.Round, and scales the filled arrowhead to the line with one ARROW_HEAD_SCALE (edgeArrowHeadSize = edgeStrokeWidth * ARROW_HEAD_SCALE). Labels sit on a rounded tonal chip (tonalFill of the raised surface with the label's own colour) instead of raw text over the canvas.
  • More breathing room, from named tokens. Node width/height, the horizontal gap, the graph padding, the per-edge lane spacing and track step, and the terminal-row gap are now named dp tokens (no inline geometry literals); the values grew so nodes and the per-edge tracks have visibly more room, and the collapsed-panel floor grew to 320.dp to still fit a 4-stage graph with its terminal row.
  • Nothing semantic changed. The executed/not-executed structural split (solid full-colour + arrowhead vs dashed muted + no arrowhead; filled vs hollow/dashed node), the pass/fail emphasis (heavier, same-hue, more-saturated stroke with the largest head), the selected-stage invert, ntfy/custom/model kind tints, the error* fallback label, the legend, the active halo/elapsed badge, the flow dots and the screen-reader description are all kept. graphColors and outcomeColor keep their field names, so the Timeline step chips that share them still agree with the graph.

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

  • gradle --offline :app:testDebugUnitTest --rerun-tasks → BUILD SUCCESSFUL; the test-result XMLs aggregate to 207 tests, 0 failures, 0 errors, 0 skipped (4 new: WorkflowGraphTest for the readable node labels, the arrowhead proportional to its stroke and the corner-cut clamp, and GraphPaletteTest for tonalFill). compileDebugKotlin emitted no warnings (the deprecated quadraticBezierTo was replaced by quadraticTo).
  • gradle --offline :app:assembleDebug → BUILD SUCCESSFUL; app-debug.apk is 17,928,873 bytes, sha256 ba5bcc467989425b69aad2ae70799c0cf4d9eaf54be30243b4631fb7e94916b3.
  • On emulator-5556 (FoldB_API_36, dark mode) against the live server ws://10.0.2.2:8080/connect, driven with adb shell input and uiautomator dump. Every capture was written with android/scripts/capture_png.sh -s emulator-5556 (validated PNG magic bytes, named display id) into ~/.local/share/pipelines/data/artifacts/108/1/. The three cases are a definition-only graph (pipeline 3 "Plan, implement, review", 4 stages), a partly executed run (run 94, failed at committer: implementer/reviewer/ ui_reviewer and the failed committer executed, Success not) and its selected (current) stage. Widths: wide 2208x1840 @ density 420 (≈841dp) and narrow 1080x1920 @ density 480 (≈360dp); 2x doubles the pixel size and density (4416x3680 @840 and 2160x3840 @960), so the same dp layout is rendered at double the pixels. "Before" is a clean git archive 8b39c08 tree (never a working-tree stash) built and installed; "after" is this tree.
    • {before,after}_wide_1x_definition.png, {before,after}_wide_2x_definition.png, {before,after}_narrow_1x_definition.png, {before,after}_narrow_2x_definition.png — the definition graph; before shows [planner]/[FAILURE] rectangular nodes with hard 90° routes and raw labels, after shows rounded, tonal nodes, pill terminals and chipped labels.
    • {before,after}_wide_1x_run.png, {before,after}_wide_2x_run.png, {before,after}_narrow_1x_run.png, {before,after}_narrow_2x_run.png — run 94; implementer/reviewer/ui_reviewer were visited and the failed committer was visited too (it was entered and then failed), so all four stages are filled and the selected committer inverts (light inverseSurface fill, solid primary border); the executed success/error routes are the boldest lines, and the not-executed Success terminal is hollow with a dashed border (the Failure terminal, reached by the executed error edge, is filled). The invert applies only to an executed stage; a selected not-executed stage is instead drawn hollow with a dashed primary border (drawNodes' not-executed branch), so selection is legible in either state.
    • {before,after}_{wide,narrow}_{1x,2x}_selected.png — a 2x crop of the selected committer node (its primary border and rounded shape after vs the sharper [committer] before).
    • compare_wide_1x_definition.png, compare_wide_1x_run.png, compare_narrow_1x_definition.png, compare_narrow_1x_run.png — stacked before/after sheets for the 1x narrow and wide cases.
    • adb -s emulator-5556 logcat -d contained 0 FATAL EXCEPTION and 0 E AndroidRuntime lines after a fresh launch and a Runs/Graph sweep; no run was started from the app. The emulator's display was reset to its native 2208x1840 @420 afterwards.
  • APK publish. app-debug.apk was copied to ~/.local/share/pipelines/data/artifacts/108/1/pipelines-debug-wip-8b39c08.apk (8b39c08 = git rev-parse --short HEAD); shasum -a 256 matched. curl -I http://10.0.0.249:8080/artifacts/108/1/pipelines-debug-wip-8b39c08.apk (LAN address from ipconfig getifaddr en0) returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 17928873, and a streamed GET | shasum -a 256 returned the same ba5bcc46… as the local file. 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 (its only reported issues are the two pre-existing NewApi errors for android:windowLightNavigationBar); the light theme; the active/animating halo, elapsed badge and flow dots (the run 94 graph is a finished run, so it renders settled — those live-run visuals are unchanged by this pass and are covered by GraphMotionTest); a real hardware fold (narrow/wide were produced with wm size/wm density); and a greyscale pass (the executed/not-executed distinction is still structural, but only colour captures were taken). The crops are derived from the full captures with PIL; the full-size PNGs above are the primary evidence.

Review follow-up and re-verification (16 Oct 2026)

A follow-up pass addressed the review findings on the code above. The rendered surface is unchanged (the token conversion maps the former pixel literals onto the same device-scaled geometry), and android/ is still the only modified tree; the untracked .ui_review*/ scratch captures at the repo root are not part of it.

  • Duplication. The two near-identical rounded tonal chips (the edge outcome labels and the active-stage elapsed badge) are now one DrawScope.drawTonalChip(textTopLeft, textSize, color) helper; both call sites pass the accent tinted into labelBackground, so the chip geometry lives once.
  • Redundant geometry. cornerCutRadius now takes the adjacent segment lengths the caller has already measured (cornerCutRadius(inLength, outLength, radius)), so roundedRoutePath computes each corner's two hypots once instead of twice.
  • Redundant width. The new pure arrowHeadSizeFor(strokeWidth) is the one arrowhead-from-stroke mapping; drawEdgePaths passes the width it has just computed (arrowHeadSizeFor(width)) instead of re-deriving it, and edgeArrowHeadSize delegates to the same function.
  • Geometry tokens. ROUTE_CORNER_RADIUS (7.dp) and the chip EDGE_CHIP_PAD_X/EDGE_CHIP_PAD_Y/EDGE_CHIP_CORNER (2.dp/1.dp/2.dp) are dp tokens like the rest of the new graph geometry, not raw pixel literals.

Re-run checks (same environment as above):

  • gradle --offline :app:testDebugUnitTest → BUILD SUCCESSFUL; the test-result XMLs aggregate to 207 tests, 0 failures, 0 errors, 0 skipped (the cornerCutRadius test now exercises the length-based clamp).
  • gradle --offline :app:compileDebugKotlin --rerun-tasks → BUILD SUCCESSFUL with no w: warnings.
  • gradle --offline :app:assembleDebug --rerun-tasks → BUILD SUCCESSFUL; app-debug.apk is 17,928,873 bytes, sha256 ab99e734b0b190294ebfad8d342caf599286cefda23a0faf39f0244496e3af1a. (A full --rerun-tasks rebuild is byte-reproducible — two consecutive runs produced this same hash — whereas incremental packaging is not, so the published APK is the --rerun-tasks one.)
  • Smoke captures on emulator-5556 (native 2208x1840 @420) with the rebuilt APK (adb -s emulator-5556 install -r app/build/outputs/apk/debug/app-debug.apk), written via android/scripts/capture_png.sh -s emulator-5556: followup_wide_1x_definition.png (the pipeline 3 definition graph) and followup_wide_1x_run106.png (run 106, all four stages visited) in ~/.local/share/pipelines/data/artifacts/108/3/. Both render the rounded tonal nodes, pill terminals and chipped labels; run 106 shows the executed stages filled, the selected committer inverted (light fill, solid primary border) and the not-executed Failure terminal hollow with a dashed border — the same structural executed/not-executed split, unchanged. adb -s emulator-5556 logcat -d | grep -cE 'FATAL EXCEPTION|E AndroidRuntime' is 0; the display was not resized (still native 2208x1840 @420).
  • APK publish (this pass). The rebuilt APK was copied to ~/.local/share/pipelines/data/artifacts/108/3/pipelines-debug-wip-8b39c08.apk (8b39c08 = git rev-parse --short HEAD). curl -I http://10.0.0.249:8080/artifacts/108/3/pipelines-debug-wip-8b39c08.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 17928873, and a streamed GET | shasum -a 256 returned the same ab99e734… as the local file.

Second review follow-up (16 Oct 2026)

Two remaining findings on the modernised graph were fixed. The rendered surface is unchanged — the first is a same-value refactor, the second a doc-only correction — so the before/after captures above still describe the output.

  • One label colour, not two. drawEdgeLabels declared accent and textColor holding the identical value (both outcomeColor(...) when the edge executed, else colors.labelText); they are now the single labelColor, used for both the label text and its chip tint. No pixel changes.
  • README cites the live arrowhead token. The dated "Pass/fail edges" section cited the removed PASSFAIL_ARROW_HEAD_SIZE = 20f; it now describes the current mapping (edgeArrowHeadSize = strokeWidth * ARROW_HEAD_SCALE, i.e. 28f pass/fail and 12f normal), matching WorkflowGraph.kt.

Re-verified (Homebrew openjdk@25, Gradle 9.7.1, ANDROID_HOME=/Users/alan/Library/Android/sdk, --offline):

  • gradle --offline :app:compileDebugKotlin --rerun-tasks → BUILD SUCCESSFUL with no w: warnings.
  • gradle --offline :app:testDebugUnitTest --rerun-tasks → BUILD SUCCESSFUL; the test-result XMLs aggregate to 207 tests, 0 failures, 0 errors, 0 skipped.
  • gradle --offline :app:assembleDebug --rerun-tasks → BUILD SUCCESSFUL; app-debug.apk is 17,928,873 bytes, sha256 c95fab884d392a2b3df6170ec2e16ccc4fdf6f1fef4e946425f5dcda56c881a7, reproducibly (two consecutive --rerun-tasks rebuilds matched).
  • Smoke captures on emulator-5556 (native 2208x1840 @420) with this APK, written via android/scripts/capture_png.sh -s emulator-5556: followup2_wide_1x_launch.png, followup2_wide_1x_definition.png (pipeline 3) and followup2_wide_1x_run.png (run 109, partly executed) in ~/.local/share/pipelines/data/artifacts/108/5/. The definition graph renders rounded tonal stages, pill terminals (filled Failure/Success) and chipped labels; run 109 fills the visited stages, inverts the selected committer (light fill, solid primary border) and leaves the not-executed Failure terminal hollow with a dashed border. adb -s emulator-5556 logcat -d | grep -cE 'FATAL EXCEPTION|E AndroidRuntime' is 0.
  • APK publish (this pass). The rebuilt APK was copied to ~/.local/share/pipelines/data/artifacts/108/5/pipelines-debug-wip-8b39c08.apk (8b39c08 = git rev-parse --short HEAD); curl -I http://10.0.0.249:8080/artifacts/108/5/pipelines-debug-wip-8b39c08.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 17928873.

Re-verification with a fresh before/after capture set (run 117, 16 Oct 2026)

The source is unchanged from the sections above; this pass re-ran every check on it and produced a fresh, complete before/after capture set in ~/.local/share/pipelines/data/artifacts/117/1/. android/ remains the only modified tree (the untracked .caps117/ scratch captures at the repo root and the older .ui_review*/ directories are not part of the change). No run was started from the app, only emulator-5556 was ever addressed, and its display was reset to native 2208x1840 @420 at the end.

  • gradle --offline :app:assembleDebug --rerun-tasks → BUILD SUCCESSFUL; app-debug.apk is 17,928,873 bytes, sha256 c95fab884d392a2b3df6170ec2e16ccc4fdf6f1fef4e946425f5dcda56c881a7 (identical to the "Second review follow-up" build above).
  • gradle --offline :app:testDebugUnitTest --rerun-tasks → BUILD SUCCESSFUL; the test-result XMLs aggregate to 207 tests, 0 failures, 0 errors, 0 skipped (the new tonalFill, nodeDisplayLabel, arrowHeadScalesWithTheStrokeItTerminates and cornerCutNeverExceedsHalfTheShorterSegment tests included).
  • Captures. The same four display configurations as the first pass (wm size/wm density: wide 2208x1840 @420 and its 2x 4416x3680 @840; narrow 1080x1920 @420 and its 2x 2160x3840 @840), each for the pipeline 3 definition-only graph and the partly executed run 109 (the selected committer), written with android/scripts/capture_png.sh -s emulator-5556: {before,after}_{wide,narrow}_{1x,2x}_{definition,run}.png, the 2x-upscaled {before,after}_{wide,narrow}_{1x,2x}_selected.png node crops, and the stacked compare_{wide,narrow}_1x_{definition,run}.png sheets. The before images were rebuilt from HEAD (the four tracked files stashed, assembleDebug, captured, then the stash popped and the after build reproduced the same sha256); they show the sharp-cornered flat fills, [bracketed] all-caps labels and thin raw-text routes, while the after images show the rounded tonal stages, pill terminals (Failure hollow/dashed when not executed, Success filled) and chipped labels. adb -s emulator-5556 logcat -d | grep -cE 'FATAL EXCEPTION|E AndroidRuntime' is 0.
  • APK publish (this pass). Copied to ~/.local/share/pipelines/data/artifacts/117/1/pipelines-debug-wip-8b39c08.apk; curl -I http://10.0.0.249:8080/artifacts/117/1/pipelines-debug-wip-8b39c08.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 17928873.

Remembering the list scroll position (16 Oct 2026)

Returning from a pipeline or a run now restores the list to exactly where the operator left it — the same item at the same offset, on either window width — and the position also survives a configuration change, rotation and process death. android/ only; nothing in the Pipelines server, its Go source, the Docker/compose files or the installer was touched, no dependency was added (the declared material-icons-extended is unchanged), no run was started from the app and no server field was added.

  • Root cause. A covered pane is a different composition from an open one: when a detail opens on a wide window, pane 0 stops drawing its list and draws its compact identity in a strip instead, so the list screen (and any scroll state it owned) was discarded, and backing out rebuilt it at the top. The runs destination is additionally recreated by the NavHost when the app-level runs selection changes. The fix owns each list's scroll state at the app shell, above the NavHost (PipelinesApp), and passes it into the list screens, so it is never inside the pane that comes and goes.
  • One scroll state per list. PipelinesApp holds pipelineListState/runListState with rememberSaveable(saver = LazyListState.Saver) and passes them to PipelineDestination/RunsDestination and on to PipelineListScreen/RunHistoryScreen (and RunHistoryContent), whose LazyColumn now takes that state. The same two screens serve both window widths and both entry points, so the runs list reached from a pipeline gets the same treatment as one opened normally.
  • Restore and clamp rule. ui/components/ListScroll.kt holds the pure ListScrollAnchor(index, offset) and restoredScrollAnchor(anchor, itemCount) (the saved index clamped to the nearest valid item, the offset kept only for the item that survived) plus the RestoreListScroll(state, itemCount) composable, which is keyed on the item count so it runs once when the list's size settles and never on the operator's own scrolling. A list that changed underneath (a filter, a sort, a refresh, items removed) therefore clamps to the nearest sensible item instead of jumping to the top or throwing, a scroll after coming back is never overridden, and a list that has not loaded yet is left alone so a restored position is not reset to the top while the data is still arriving.
  • Runs list before it has loaded (fixed 16 Oct 2026). The runs list has no pane-level empty state, so its first frame — before LaunchedEffect { vm.refreshRuns() } has set loading — was data-less, not-loading and classified as content. RunHistoryContent then composed an empty list whose only slot was the "no runs" line, and RestoreListScroll clamped the restored index to 0 before the real list arrived: the runs list always came back at the top after process death (the pipelines list was spared only because its empty state was classified as a distinct LoadPhase.Empty). listLoadPhase now takes the pane's loaded signal (LoadState.loaded) and reads a data-less list that has never loaded as loading rather than empty, so the list — and its restored position — is not composed until the history is actually in hand. Both list screens pass it.
  • One source for the runs list body. RunHistoryScreen no longer maintains a second, hand-written copy of the LazyColumn's item count. The pure runListEntries(...) builds the slots (the usage block, the single empty-or-grouped body and the optional inline error row) once, in layout order; the column renders exactly that list and RestoreListScroll clamps to its size, so the count can never drift from what is drawn. RunListEntriesTest pins the slot order, the stable keys and the count.

Evidence (macOS, JDK 17 from Homebrew openjdk@17, cached Gradle 8.11.1 distribution, ANDROID_HOME=~/Library/Android/sdk, every Gradle command with --no-daemon --offline --console=plain):

  • :app:clean :app:testDebugUnitTest :app:assembleDebug → BUILD SUCCESSFUL; the tests were then re-executed with :app:testDebugUnitTest --rerun-tasks (not served from the build cache). The result XMLs total 292 tests, 0 failures, 0 errors, 0 skipped across 34 files. ListScrollTest (6 cases) pins the restore/clamp rule (in-range item keeps its index and offset, the last item keeps its offset, a shrunken list clamps to its last item and drops the offset, a negative index clamps to the top, an empty list stays at the top); the two new LoadPhaseTest cases pin that a data-less list that has never loaded reads as loading while the default keeps the old rule; and RunListEntriesTest (5 cases) pins the runs body's slot order, stable keys and count. app/build/outputs/apk/debug/app-debug.apk is 18,011,393 bytes, sha256 13b8d2871e9ad522e0d5a826642cdf467a95939408bed519d952e83d5c8dbb02.

  • :app:lintDebug aborts on only the two pre-existing NewApi errors for android:windowLightNavigationBar (minSdk 26) in res/values/themes.xml and res/values-night/themes.xml, which this change did not modify; no error or warning points at the scroll change.

  • APK publish. app-debug.apk was copied to ~/.local/share/pipelines/data/artifacts/157/1/pipelines-debug-wip-c700b28.apk (c700b28 = git rev-parse --short HEAD; the tree is uncommitted WIP on top of it); shasum -a 256 matched the built file (13b8d287…). curl -I http://10.0.0.249:8080/artifacts/157/1/pipelines-debug-wip-c700b28.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 18011393.

  • Device evidence (operator's Pixel 10 Pro Fold, adb -s 58281FDCG000JF, inner 2076x2152 at the 330 density override ≈1006dp; narrow override wm size 1080x1920). The build was installed with adb -s 58281FDCG000JF install -r, driven against the live LAN server (curl http://127.0.0.1:8080/healthz → {"healthy":true}), and captured with android/scripts/capture_png.sh -s 58281FDCG000JF (device-side screencap to a file, then pull — never exec-out), written to ~/.local/share/pipelines/data/artifacts/157/1/. The scroll position is read from uiautomator dump as the first run «id» · … line (the runs list) or the first id «n» · v… line (the pipelines list):

    case how driven result
    pipelines, wide, open→back scroll down (first row id 6), tap the pipeline, Back same first row; 01_list_scrolled.png vs 03_list_restored.png differ in no pixel (bbox None)
    runs, wide, open→back scroll down (first row run 32 · 13 Oct 17:21), tap the run, Back same first row; 05_runs_scrolled.png vs 06_runs_restored.png differ in no pixel (bbox None)
    runs, process death HOME, adb -s 58281FDCG000JF shell am kill net.awan.pipelines (pidof empty), restore the task from Recents back on the Runs destination with the same first row run 41 · 15 Oct 14:35; 30_runs_before_death.png vs 31_runs_after_death.png differ only in the status bar (bbox (138,67)-(289,95))
    runs, rotation user_rotation 1, then 0 same top row run 10 · 11 Oct 16:01 after both
    pipelines, rotation user_rotation 1, then 0 same top row in landscape; the first flip re-laid the anchor onto the adjacent row (id 6→id 11) and was stable on the second and later flips — the list never returned to the top
    density, config change wm density 330→340→330 same top row run 10 · 11 Oct 16:01
    pipelines, narrow wm size 1080x1920; scroll, open a pipeline, Back same first row id 4; 70_narrow_pipelines_before.png vs 72_narrow_pipelines_after.png differ in no pixel (bbox None)
    runs, narrow wm size 1080x1920; scroll, open a run, Back same first row run 8 · 11 Oct 14:44; only the status bar differs
    list shrank while open pipelines scrolled to the bottom, then search quick the two matches (id 9, id 10) are shown — clamped, not blank and not reset to the top — and the process stayed alive with no FATAL EXCEPTION in logcat

    For the open→back cases the top row and its pixel offset matched exactly (the screenshot diff isolates only the status-bar clock); rotation, the density change and process death restored the same destination and top row. device.lock was held for every adb command and released afterwards, and no run was started from the app.

  • Not exercised. onOpenRun from a pipeline detail is only reached through StartRunDialog.onStarted (after starting a run), which the task forbids, so the runs list reached that way is kept compiling and functional but not driven; it shares the one runListState, so it gets the same treatment as the normally opened runs list. A real hardware fold to the cover display was not exercised (narrow was produced with wm size).

The covered edge is measured, not budgeted (16 Oct 2026)

The covered panes used to spend the fixed PEEK_BUDGET_DP (224.dp) whatever the window width was, so on a folded window the covered area was over half the screen and the active pane was left with a fixed, small width. The stack now derives the covered region from what a covered edge actually has to show and takes the active pane's width from what remains. android/ only; no dependency was added, no run was started from the app, the Pipelines server/Go source/installer/Docker files were not touched, and the operator's Pixel 10 Pro Fold was not used at all (implementation verified with the build and the unit tests, per the brief).

  • The region is measured, not budgeted. rememberCompactIdentityWidth (ui/components/PaneIdentity.kt) measures the width one covered edge needs for its compact identity — an icon plus the shortest label that identifies the pane — at runtime, with the app's own type role and the platform's font metrics, and floors it at the platform minimum touch target (LocalMinimumInteractiveComponentSize). SlidingPaneStack adds the leading system-gesture inset (systemBars ∪ systemGestures) and uses that as the whole covered region. No percentage of the window, budget token or new dp constant stands in for it; the only fixed values left are platform ones (the minimum touch target and the leading gesture inset) plus the identity's own existing SPACING_S padding and the icon's own default size.
  • The active pane's width is the same at every depth — the invariant. coveredEdgesDp (ui/components/SlidingPaneStack.kt) always returns edges that sum to exactly the region, so activeStart is the region and the active pane measures hostWidth - region at depth 1, 2, 3 and 4 alike. Opening another level only adds an edge inside the region; it never widens the region or resizes or reflows a pane already there. SlidingPaneStackTest asserts the sum is constant across depths (theCoveredRegionIsTheSameAtEveryDepthSoTheActiveWidthNeverChanges).
  • The stack reads as a stack, and depth does not consume width. The nearest covered level shows its identity. One older level is shown as a thinner edge — the platform minimum touch target, the thinnest edge that stays tappable after the leading inset — and every level older than that folds into that edge's count ("<n> more") instead of spending width on each. When the region cannot fit the thin older edge as well as a full touch target for the nearest identity (one identity width is usually less than two touch targets), the older levels fold into the nearest edge's count rather than being squeezed: nothing is derived below the platform minimum. Tapping an edge still calls the same onPopTo(level), closing everything above it.
  • The old token and what replaced it. PEEK_BUDGET_DP was 224.dp and is removed, together with MIN_ACTIVE_PANE_WIDTH_DP (320.dp) and the peekBudgetDp/peekStripsDp split of a fixed budget. What replaced it is the measured compact-identity width above. PEEK_WIDTH_DP (56.dp) and MIN_COVERED_PANE_WIDTH_DP (112.dp) no longer place anything either: they now only bound which statistics a covered identity shows (see paneStatTier/visiblePaneStats) and are documented as such in Dimens.kt.
  • The identity carries an icon. PaneIdentity gained an icon parameter drawn above the title at the vector's own default size, so the drawn identity matches the width that was measured for it. The list, pipeline-detail, run-detail and stage panes each pass their own glyph.

Evidence (macOS, JDK 17 from Homebrew openjdk@17, the cached Gradle 8.11.1 distribution, ANDROID_HOME=~/Library/Android/sdk, --offline, every command with --no-daemon):

  • gradle :app:testDebugUnitTest :app:assembleDebug --no-daemon --offline --console=plain → BUILD SUCCESSFUL. The result XMLs total 293 tests, 0 failures, 0 errors, 0 skipped across 34 files. The rewritten SlidingPaneStackTest pins the invariant and the fold rules: a narrow window spends nothing, the edges sum to the region at every depth (so the active width is constant), one covered level keeps the whole identity edge, two covered levels show the nearest identity plus one thinner older edge, beyond two the older levels fold into one count edge, a region too small to fit both a thin edge and the nearest touch target collapses to a single counted edge, the nearest edge keeps its touch target after the gesture inset, and the edges stay monotonic and deterministic.
  • app/build/outputs/apk/debug/app-debug.apk is 18,247,412 bytes, sha256 77db131cdb2737da64286384e5f7387540b1c87588b89c36bf4c34821f091372; it was copied to ~/.local/share/pipelines/data/artifacts/166/1/pipelines-debug-wip-b003872.apk (b003872 = git rev-parse --short HEAD; the tree is WIP on top of it). curl -I http://10.0.0.249:8080/artifacts/166/1/pipelines-debug-wip-b003872.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 18247412.

Not verified in this pass: the derived widths on a real window, the stacked look and the identifiers on the left, the covered area's share of the window, and the two- and four-level screenshots — all of that is runtime/visual evidence for the review stages, and the device policy for this brief keeps the implementation to the build and the unit tests. Four levels are also unreachable in the app itself (MasterPane.List/Detail/Stage, MAX_PANE_DEPTH = 2), so the four-level fold is covered by the pure coveredEdgesDp cases rather than by a screenshot.

Stage sections open as their own pane, not inline (16 Oct 2026)

The reported stage-screen defect was real and, once reproduced, exactly as described: expanding a section stacked its rows at the top of the section. It is fixed by opening every stage section as its own pane and by laying a collapsible body out in one column. 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 every adb/emulator command targeted emulator-5554 only (never emulator-5556 or the attached Pixel).

  • The defect and its cause. Expanding Stage definition on the stage screen drew its fields stacked at the top: the last field's card (Memory) sat directly under the header and every other row (Type, Prompt, Outcomes, Model, …) was hidden underneath it. The section's content lambda emitted one composable per field (definition.forEach { StageFieldRow(it) }) straight into CollapsibleSectionBody's AnimatedVisibility, which lays out a single child: several children were placed on top of each other (all at the section's origin) instead of one below the next, so the body had the height of its tallest single row and showed only the last one. Reproduced on the pre-change tree (below).
  • Sections are panes. A stage section is no longer expanded in place. The stage screen keeps a compact list of section rows (Artifacts, Output, Input, This run, Stage definition) and tapping one opens that section as the next pane of the stack — a full-window screen on a narrow window, a panel to the right of the stage pane on a wide one — with its own Scaffold/ TopAppBar named for the section, its own scroll and its own top spacing. Back (the app bar, the gesture or a peek) returns exactly one level, to the stage screen. MasterPane gained the Section level (MAX_PANE_DEPTH = 3) and PaneSelection.sectionKey (a primitive saved with the pane selection), so the open section survives rotation and process death and the wide covered peeks fold ("2 more") as the fourth pane is added.
  • No trivial inline exceptions. None of the five sections is kept inline. Each can hold an arbitrarily long value — the definition's prompt/output contract, the input/output maps, the run evidence and the artifacts gallery — so an inline body would both risk the layout with many rows and push the operator's run context off screen; one uniform rule keeps the screen predictable.
  • The shared body fix. CollapsibleSectionBody now lays its content out in a single full-width Column, so any collapsible section with more than one row (it also backs the run/pipeline detail collapsibleSection lists) stacks its rows under the header instead of overlapping them.
  • Semantics kept. Sections start collapsed; the operator's choice (which section is open, and the visit) is saved with the pane selection; and each section's content is derived from the same stageSectionSpecs (runStepFields, stageDefinitionFields, ArtifactsSection) as before, so nothing shown changed — the stage screen just lists the sections and the section pane shows one.
  • Shared derivation. stageSectionSpecs(stageKey, graph, runSteps, visitIndex, runContext) is the one pure list of sections (key, title, fields, artifacts) the stage screen and the section pane both read, so the two can never disagree; StageVisitTabs is the one visit tab row both use; and StageSectionPane/StageSectionBody render a section (the artifacts section keeps the shared ArtifactSelectionScaffold, so its gallery retains long-press selection, the contextual bar and Back-leaves-selection-first).

Evidence (macOS, Homebrew JDK 17 openjdk@17, Gradle 9.7.1, ANDROID_HOME=~/Library/Android/sdk, --offline):

  • gradle :app:assembleDebug :app:testDebugUnitTest --offline --console=plain → BUILD SUCCESSFUL; the 30 result XMLs aggregate to 262 tests, 0 failures, 0 errors, 0 skipped (the updated PaneStateTest section-level/backStep/ popTo cases and the StageDetailSheetTest stageSectionSpecs cases included). app/build/outputs/apk/debug/app-debug.apk is 18,011,393 bytes, sha256 5912d38fef80aa8aad53132ac5bb1e05fd42fdb9d0ae778e7dc0a1af732e4019.
  • gradle :app:lintDebug --offline → the same 2 pre-existing NewApi errors for android:windowLightNavigationBar in res/values/themes.xml and res/values-night/themes.xml (unchanged by this pass); no error is attributed to a changed file.
  • On emulator-5554 only (fold AVD; wide wm size reset = 2076x2152 / 390dpi ≈ 852dp, narrow wm size 1080x1920 / wm density 480 ≈ 360dp; never the attached Pixel, never emulator-5556) against the live server, driving run 145's implementer from a Timeline row; every frame was captured and validated with scripts/capture_png.sh -s emulator-5554 into ~/.local/share/pipelines/data/artifacts/144/1/:
    • Before (the pre-change tree rebuilt from HEAD): before-wide-stage-sections.png then before-wide-definition-inline.png — tapping Stage definition shows the overlap defect (the Memory card under the header, the other rows hidden).
    • After: after-wide-stage-sections.png (the compact list, every row chevron-right/collapsed), after-wide-section-opened.png (the Stage definition panel to the right of the stage pane, peeks Back to run/ Back to stage), after-wide-artifacts-opened.png (the Artifacts pane from the same list), after-narrow-section-opened.png (full-window Stage definition, its own title/scroll/spacing) and after-narrow-stage-sections.png (Back returned to the compact stage screen). The narrow section pane was reached by opening it wide and folding the window, which exercises the saved section surviving the configuration change.
    • adb -s emulator-5554 shell input keyevent 4 from the section pane returned to the stage screen (the compact rows reappear, no Back to stage strip); no run was started from the app; wm size/density were reset afterwards.
  • APK publish. app-debug.apk copied to ~/.local/share/pipelines/data/artifacts/144/1/pipelines-debug-wip-c700b28.apk (c700b28 = git rev-parse --short HEAD; the working tree is uncommitted WIP on top of it). curl -I http://10.0.0.249:8080/artifacts/144/1/pipelines-debug-wip-c700b28.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 18011393; a streamed GET | shasum -a 256 returned the same 5912d38f…. At 17.2 MiB it exceeds the 8 MiB per-file inventory cap, so it is served by direct URL only.

Not verified in this pass: a clean logcat sweep was not conclusive because the emulator was shared — installs this pass did not issue appeared in the log during the sweep and the UI moved between commands. The one FATAL EXCEPTION present was the uiautomator dump tool itself (com.android.commands.uiautomator), never net.awan.pipelines. The artifacts section was captured for a visit that recorded none (Artifacts · not recorded for this visit) rather than the populated gallery (the same gallery branch is covered by the run-summary grid); the wide fold indicator ("2 more") was present but is not separately cropped.

The gallery was already a grid, but only for images: non-image artifacts fell through to a plain one-per-row list beneath it, so the same run rendered two different ways. This pass makes ArtifactGallery the single rendering path for every artifact (the run summary and the stage pane's per-visit section already both use it) and gives non-media files a tile too. android/ only; no dependency was added (the new glyphs are material-icons-extended), no run was started from the app, and every adb command targeted emulator-5554 (never emulator-5556 or the attached Pixel).

  • One tile, two shapes. ui/graph/Artifacts.kt's ArtifactTile replaces the old ArtifactTile + ArtifactRow split. An image fills the cell with its thumbnail; a video shows its still/poster frame with a centred play marker on top; anything else shows its file-type icon with the artifact's name and human-readable size beneath it, all in the same width-derived grid. The grid is still built from non-lazy chunked Rows, so it never nests a scrollable inside the Summary LazyColumn or the pane's scroll.
  • Type-to-icon mapping. The new pure ui/graph/ArtifactType.kt classifies an artifact from its content type (parameters tolerated) and, when the server's sniff is generic, its name's extension, into ArtifactKind (Image/Video/Audio/Pdf/Json/Archive/Spreadsheet/Log/Code/Document/Other), and artifactIcon(kind) gives each kind a distinct shape (PDF, JSON, archive, spreadsheet, log, code, document, audio, generic file). Format.kt gained the companion isVideoContentType predicate beside isImageContentType.
  • Video poster frame. ui/graph/ArtifactImage.kt gained ArtifactVideoFrame/rememberArtifactVideoFrame: the artifact's bytes are fetched through the same bounded cache as an image and the representative sync frame is extracted with the platform MediaMetadataRetriever over an in-memory MediaDataSource (no temp file, no new dependency, no inline playback). The full-screen viewer takes a video flag and shows that frame (its open action plays the clip externally); a fetch/extraction failure falls back to the video glyph rather than a fabricated image.
  • Actions kept. Tap opens the viewer for an image/video and the existing external-open action for anything else; every tile keeps its share control, a non-media tile adds the copy-link control, and long-press / multi-select, the contextual bar, bulk copy/share and the selection semantics are unchanged. The capture summary and partial-capture notes are byte-for-byte unchanged.
  • Geometry from tokens, not literals. ui/theme/Dimens.kt gains ARTIFACT_TYPE_ICON_DP (28dp), ARTIFACT_PLAY_BADGE_DP (32dp) and ARTIFACT_TILE_ACTION_DP (32dp); the tile still stretches ARTIFACT_TILE_DP cells across the measured width via the unchanged pure artifactGrid.

Review follow-up (same pass, no UI change): the two preview state-holders duplicated the whole memoize-through-caches scaffold, so it is now one private rememberArtifactPreview(url, maxDim, keyTag, fetchBytes, derive) that both rememberArtifactBitmap and rememberArtifactVideoFrame delegate to (the keyTag keeps the two cache entries apart); the video fallback draws artifactIcon(ArtifactKind.Video) instead of a hardcoded Icons.Filled.Movie; and the now-unused Format.kt artifactMetaLine helper (its last caller was the deleted non-image row) was removed with its FormatTest cases.

Verified on this tree (macOS, Homebrew openjdk@25, JAVA_HOME=/opt/homebrew/opt/openjdk@25/libexec/openjdk.jdk/Contents/Home, Gradle 9.7.1, ANDROID_HOME=/Users/alan/Library/Android/sdk, --offline):

  • gradle --offline :app:testDebugUnitTest --rerun-tasks → BUILD SUCCESSFUL; the 31 test-result XMLs aggregate to 265 tests, 0 failures, 0 errors, 0 skipped (the new ui/graph/ArtifactTypeTest has 6 cases: the media kinds from the content type, the named kinds, the extension fallback for a generic sniff, the never-crash Other fallback, the explicit type-to-icon mapping, and that no two kinds share a glyph). ArtifactGalleryTest still covers the grid sizing (narrow → fewer, larger cells; wider → more preferred-shaped columns; degenerate inputs). compileDebugKotlin emits no warnings.
  • gradle --offline :app:assembleDebug --rerun-tasks --no-build-cache succeeded → app-debug.apk 18,011,393 bytes, sha256 faa9df077c960b23eef4afbac1b7effa1a50180eabcee2d638cabb232974cfa8.
  • On emulator-5554 (native 2076x2152 @390; wm size/wm density used for the narrow pass and reset afterwards) against the live server ws://10.0.2.2:8080/connect, driven with adb shell input and uiautomator dump; every capture was written with android/scripts/capture_png.sh -s emulator-5554 (validated PNG, named display id) into …/artifacts/140/1/. Run 136's implementer visit 1 is a real mixed set: five image/png screenshots plus chat_stub_approval.py (text/plain, code glyph) and stub.log (text/plain, log glyph).
    • Wide (2076x2152 ≈ 532dp): evidence_wide_run136_summary_gallery.png shows the five thumbnails with their share controls and, in the same grid, the .py tile with the <> code glyph and the .log tile with the log glyph, each with its name and 9.3 KiB / 220 B beneath it and the copy + share actions; evidence_wide_run136_stage_pane.png shows the same gallery in the stage pane under the unchanged Artifacts · 7 recorded · partial capture wording and the 1 files excluded from artifact capture. note.
    • Narrow (1080x2340 @480 ≈ 360dp): evidence_narrow_run136_summary_gallery.png and evidence_narrow_run136_stage_pane.png show three cells per row with the thumbnails and the code/log type tiles still legible.
    • Tapping a thumbnail opened the full-screen viewer (evidence_wide_run136_image_viewer.png; uiautomator dump reported the 01_approval_pending.png image plus Open … externally, Copy link … and Close viewer), and the non-media tiles' Copy link to … / Share … controls are present in the accessibility tree.
    • adb -s emulator-5554 logcat -d | grep -cE 'FATAL EXCEPTION|E AndroidRuntime' returned 0; the emulator display was reset to native 2076x2152 @390 afterwards.
  • APK publish. app-debug.apk copied to …/artifacts/140/1/pipelines-debug-wip-c700b28.apk (c700b28 = short HEAD); shasum -a 256 matched. curl -I http://10.0.0.249:8080/artifacts/140/1/pipelines-debug-wip-c700b28.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 18011393, and a streamed GET | shasum -a 256 returned the same faa9df07… as 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: a video artifact does not exist on the live server and starting a run is forbidden, so the play-marker/poster-frame render is covered only by the artifactKind unit test (video/mp4 → Video) and the code path, not by a device capture; the non-media external-open tap was not driven (no handler is guaranteed on the emulator); multi-select/bulk share were not re-exercised on device (their code is unchanged from the previous pass); the light theme and :app:lintDebug were not run (the only known lint issues are the two pre-existing NewApi errors for android:windowLightNavigationBar).

Review fixes (same pass)

The review's three findings were addressed with no intended UI change, and the two build checks were re-run on the resulting tree:

  • gradle --offline :app:testDebugUnitTest --rerun-tasks → BUILD SUCCESSFUL; the 31 result XMLs again aggregate to 265 tests, 0 failures, 0 errors, 0 skipped (the removed artifactMetaLine assertions were replaced by isVideoContentType coverage in the same FormatTest method).
  • gradle --offline :app:assembleDebug --rerun-tasks --no-build-cache succeeded → app-debug.apk 18,011,393 bytes, sha256 2adaf03e5ac0bdb29b012d1487a0e10917f8ebabda973ddc63c7315b6df25dda; it was published to …/artifacts/140/3/pipelines-debug-wip-c700b28.apk and curl -I http://10.0.0.249:8080/artifacts/140/3/pipelines-debug-wip-c700b28.apk returned HTTP/1.1 200 OK, Content-Length: 18011393, with a streamed GET | shasum -a 256 matching the local 2adaf03e….

The device render was not re-captured: emulator-5554 is shared and, while this pass ran, another lane replaced the installed app with a build whose dex has no ArtifactType class (dumpsys package … lastUpdateTime moved from this pass's 16:24:02 install to 16:24:20, and the installed base.apk sha no longer matched 2adaf03e…), so any capture could not be attributed to this build. The wide/narrow captures above predate the refactor; the refactor changes no UI pixels, so they remain representative of the gallery this code renders.

The artifacts gallery led the run summary but was always open, so a long run's grid pushed the run's own facts below the fold. It is now one collapsed-by-default section in the same place. android/ only; no dependency was added (the chevron is the existing material-icons-extended KeyboardArrowDown the shared SectionHeader already uses), no run was started from the app, and every device command targeted the operator's Pixel 10 Pro Fold (58281FDCG000JF), never an emulator.

  • One collapsed section, same place. RunDetailScreen.kt's RunSummaryTab renders the gallery through the shared LazyListScope.collapsibleSection, keyed "artifacts" and seeded with rememberSectionExpansion(run.id), so a run opened fresh starts collapsed and the operator's expand/collapse choice survives Summary↔tab switches, configuration changes and rotation exactly like every other section. The order is unchanged: the artifacts section still leads the summary and the facts item follows it.
  • A self-describing header. The new pure runArtifactsHeader(steps, executing) (ui/ArtifactGroups.kt) builds the header text — the title (its singular form for exactly one artifact), how many the run recorded, and · partial capture when any visit excluded or omitted files; with no artifacts it reuses the shared artifactsEmptyMessage. Its count is exactly runArtifactGroups's tile total, so the header and the expanded gallery can never disagree.
  • The gallery itself is unchanged. Expanding composes the same ArtifactGallery (the width-derived thumbnail grid, tap for full size, the non-media tiles with name, size and content type plus their open/copy/share actions); collapsing composes nothing. The stage pane's per-visit artifacts section and every other summary section are untouched.

Evidence (macOS, JDK 17 from Homebrew openjdk@17, Gradle 8.11.1 from the wrapper cache, ANDROID_HOME=/Users/alan/Library/Android/sdk, --offline, every Gradle command with --no-daemon):

  • gradle --no-daemon --offline :app:testDebugUnitTest → BUILD SUCCESSFUL; the test-result XMLs aggregate to 269 tests, 0 failures, 0 errors, 0 skipped. ArtifactGroupsTest gained headerReportsTheCountWithASingularTitleForOne, headerAddsPartialCaptureOnlyWhenFilesWereExcludedOrOmitted, headerEmptyCaseUsesTheSharedEmptyWording and headerCountMatchesTheGalleryRecordedTotal.
  • gradle --no-daemon --offline :app:assembleDebug → app-debug.apk 18,011,393 bytes, sha256 c5655269e490db34cbacccf68eaec468a3a41c46c661b41e6ad2d92295235247; installed with adb -s 58281FDCG000JF install -r, and the pulled base.apk sha matched the local build, so the captures below are attributed to this exact build.
  • Run 136 (pipeline id 11 v1, succeeded, 17 artifacts) on the Pixel:
    • Wide (inner display, 2152×2076 @330 ≈ 1043dp): summary_wide_collapsed.png shows the summary led by a lone collapsed Artifacts · 17 recorded · partial capture header (right chevron) with the run's facts immediately below and no gallery; summary_wide_expanded.png shows the same header expanded to the unchanged gallery — the implementer · visit 1 and ui_reviewer · visit 1 groups of image thumbnails plus the chat_stub_approval.py (<> code glyph) and stub.log (log glyph) tiles with their names, 9.3 KiB/220 B sizes and share/copy actions.
    • Narrow (wm size 1080x2152 on the inner display ≈ 524dp, reset to the native size afterwards): summary_narrow_collapsed.png and summary_narrow_expanded.png show the same collapsed header and, expanded, the same gallery re-flowed to four cells per row (wide uses five).
    • Persistence. uiautomator dump reported Artifacts · 17 recorded · partial capture, collapsed on a freshly opened run; toggling it and round-tripping Summary → Graph → Summary, and a wm size configuration change, both kept the operator's expanded/collapsed choice.
    • adb -s 58281FDCG000JF logcat -d | grep -cE 'FATAL EXCEPTION|E AndroidRuntime' returned 0; the screen stayed awake (svc power stayon usb
      • KEYCODE_WAKEUP) and every capture used screencap -p -d <display-id> + adb pull. Screenshots, uiautomator dumps and the APK are in …/artifacts/155/1/.
  • APK publish. app-debug.apk copied to …/artifacts/155/1/pipelines-debug-wip-95150c7.apk (95150c7 = short HEAD; the working tree is uncommitted WIP on top of it); shasum -a 256 matched. curl -I http://10.0.0.249:8080/artifacts/155/1/pipelines-debug-wip-95150c7.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 18011393.

Not verified in this pass: no device capture exercises the empty or the single-artifact header wording (both are covered by the runArtifactsHeader unit tests); the narrow window was produced with a wm size override on the inner display rather than a physical fold, then reset; :app:lintDebug was not re-run (its only known findings remain the two pre-existing NewApi errors for android:windowLightNavigationBar).

Run title beside the pipeline name (16 Oct 2026)

A run now shows the operator's title for the goal, with the pipeline it ran on as the secondary line, so two runs of the same pipeline are distinguishable. android/ only; no dependency was added, no run was started from the app, and no device command was run (build + unit tests only).

  • Protocol. data/protocol/Message.kt gains an optional title on both RunSummary and RunDetail (the server's RunSummary.title). It is nullable and defaults to absent, so a server that does not send it degrades cleanly.
  • One shared fallback. New ui/RunIdentity.kt holds runLabel(title, name) (mirroring the server's RunSummary.Label) and runIdentity(title, name): the label is the title, or the pipeline name when the title is absent/blank, and the pipeline is a second line only when a title exists — never an empty line.
  • Runs list. RunHistoryScreen.RunRow shows the label as the primary line and, only for a titled run, the pipeline name plus its version chip on a second line; an untitled run keeps the pipeline name and version chip as its single identity line. The status chip, progress, id/start/duration line and diagnostic are unchanged.
  • Run detail + stage panes. The run detail app bar and the Summary lead with the label and, when titled, name the pipeline (name · vN) on a second line; the covered peek uses the label too. StageDetailPane takes an optional runLabel and shows it under the stage name, so a stage/visit pane keeps the run context.
  • Renaming is not offered. The authoritative server does not expose it: it has no set_run_title command and list_runs/get_run return no title field, so the app does not fake a rename. The protocol field is parsed for the server that does send it; until then the title falls back to the pipeline name.

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

  • :app:testDebugUnitTest → BUILD SUCCESSFUL; the 32 result XMLs aggregate to 276 tests, 0 failures, 0 errors, 0 skipped. The new RunIdentityTest (5 cases) covers the title/fallback/trim logic, and ProtocolModelTest gained a case for a present and one for an absent title on both the run summary and the run detail.
  • :app:assembleDebug → app-debug.apk 18,257,214 bytes, sha256 bce661069b2bd013f0802545402766a3ae8fed97e1bbe0109f81a4bfb6233601.
  • Server capability probe (read-only, through the installed CLI): pipelines runs and pipelines rpc '{"type":"get_run","run_id":155}' return no title field, and the running pipelines-server binary contains no set_run_title string. So renaming is deliberately not offered and the title falls back to the pipeline name until a server carrying the field is deployed.
  • APK publish. app-debug.apk copied to …/artifacts/162/1/pipelines-debug-wip-e1c531a.apk (e1c531a = short HEAD; the working tree is uncommitted WIP on top of it); shasum -a 256 matched. curl -I http://10.0.0.249:8080/artifacts/162/1/pipelines-debug-wip-e1c531a.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 18257214.

Not verified in this pass: device captures of the runs list and run detail (the visual review owns the device); no server that actually sends title was available, so the titled layout is exercised by the unit tests and the fallback path only.

Stage verdict atop the stage pane, with clickable artifacts (16 Oct 2026)

A completed run visit now leads its stage pane with the server's derived verdict: the chosen option as a badge, the concise reason in ordinary body text, and the recorded artifacts the reason names as inline, tappable references plus the same references as compact chips. android/ only; nothing in the Pipelines server, its Go source, the installer or the Docker files was touched, no run was started from the app, and no device command was run (build + unit tests only).

  • Protocol. data/protocol/Message.kt gains StageVerdict and an optional verdict on RunStep, mirroring internal/protocol/verdict.go ({option, reason, reason_source, artifacts} under the verdict wire name). It is nullable and defaults to absent, so a running step or a pre-verdict server parses cleanly to null.
  • One block. New ui/graph/StageVerdict.kt holds the pure helpers and the composable. StageVerdictBlock is rendered at the top of the run pane, below the visit tabs and above the facts, only when the server reported a verdict; a null verdict (or one with neither option nor reason) draws nothing — never an empty heading or placeholder.
  • Badge. The option is a ColoredChip in the stage outcome's existing colour (outcomeColor(step.outcome), the graph's palette the Timeline chips already use), so the badge agrees with the graph rather than a new colour vocabulary.
  • Reason. Rendered with pipelinesText().body, so it is readable plain language, never a monospace JSON dump, and it wraps with no maxLines clip.
  • References. referencedVerdictArtifacts resolves the verdict's referenced names to the visit's recorded artifacts (recorded order, deduplicated, an unrecorded/invented name dropped). verdictReasonSegments splits the reason around those names — by full recorded name or basename, longest match first — and the segments become inline LinkAnnotation.Clickable references coloured primary with an underline. An image/video reference opens the shared ArtifactViewer; anything else goes through the existing openArtifact action. The same references are FlowRow chips (VerdictArtifactChip) with their type glyph, so they can be tapped without hunting in the sentence.
  • Geometry. Only existing tokens (SPACING_M/SPACING_S/SPACING_XS, ICON_STATUS_DP); no new dp/sp literal and no new dependency.

Evidence (macOS, JDK 17 from Homebrew openjdk@17, Gradle 8.11.1 from the wrapper cache, ANDROID_HOME=/Users/alan/Library/Android/sdk, --no-daemon):

  • :app:testDebugUnitTest → BUILD SUCCESSFUL; the result XMLs aggregate to 282 tests, 0 failures, 0 errors, 0 skipped. New StageVerdictTest (5 cases: split around every referenced name, basename for a slashed path, longest match wins, a reason with no references, and name→recorded-artifact resolution) and ProtocolModelTest#runStepVerdictParsesWithItsReasonSourceAndReferencedArtifacts.
  • :app:assembleDebug → app-debug.apk 18,270,824 bytes, sha256 85847c6fe32498f38464741ca1b8f592dbbd7a9e1f34dd649121e723836b0903.
  • APK publish. app-debug.apk copied to ~/.local/share/pipelines/data/artifacts/167/1/pipelines-debug-wip-8b0d7b1.apk (8b0d7b1 = short HEAD); shasum -a 256 matched. The LAN URL http://10.0.0.249:8080/artifacts/167/1/pipelines-debug-wip-8b0d7b1.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 18270824.

Not verified in this pass: device captures of the stage pane at a narrow and a wide window (the visual review owns the device, per the brief's device policy), so the verdict layout is exercised by the unit tests and the compile only. No server that actually sends verdict was available to the implementer, so the block's live rendering against real data is deferred to visual review.

One search: the pipelines list drops its inline field (16 Oct 2026)

The pipelines list carried its own "Search pipelines" text field while the app also has the omni search (the destination pill's Search entry point), so the list offered a second, narrower way to do the same job. The inline field is gone and name narrowing moved into the list's filter control, keeping "filters narrow one list" separate from "search finds things across the system".

  • One field removed. PipelineListScreen no longer owns a query state or draws the OutlinedTextField; the list is now the first thing under the app bar, so no spacer stands in for the field that used to sit there.
  • Name is a filter. PipelineFilters gained a free-text name facet beside presence/lastRunStatuses, applied by filterPipelines through the new pipelineMatchesName (case-insensitive contains, blank means any). Unlike the run facets it needs no run history, so it narrows as soon as the pipelines load while the run facets still wait for runsKnown.
  • In the menu. PipelineFilterControl opens with a Name section holding a single-line PipelineNameFilter (label "Pipeline name contains") that keeps the menu open while typing; the shared Clear filters resets it with the run facets and the active-count badge counts it.
  • Persisted. SettingsRepository/AppViewModel store the name under pipeline_filter_name like the other facets, so a restart remembers it.
  • Runs list unchanged. The runs list never had an inline search field, so nothing was removed there.
  • Geometry. No new dp/sp literal and no percentage: the field reuses SPACING_M/SPACING_S and fills the filter menu's own width, and the reclaimed vertical space comes from the removed field's layout, not a replacement constant.

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

  • :app:testDebugUnitTest → BUILD SUCCESSFUL; the 35 result XMLs aggregate to 312 tests, 0 failures, 0 errors, 0 skipped. ListFilterTest now has 20 cases (+4: name substring/blank, name before the run history, name AND the run facets, active count/hasRunFacets; pipelineFiltersFromStorageParsesAndFallsBack now covers the name).
  • :app:assembleDebug → app-debug.apk 18,164,618 bytes, sha256 375be755d03d17c7721fe5b4ea23f637c928fd48acc300b4aec9f3d3cf2d4e50.
  • APK publish. app-debug.apk copied to ~/.local/share/pipelines/data/artifacts/171/1/pipelines-debug-wip-e7c4b8f.apk (e7c4b8f = short HEAD); shasum -a 256 matched. The LAN URL http://10.0.0.249:8080/artifacts/171/1/pipelines-debug-wip-e7c4b8f.apk returned HTTP 200, Content-Type: application/vnd.android.package-archive, Content-Length: 18164618.

Not verified in this pass: device captures (the visual review owns the device, per the brief's device policy), so the filter-menu name field's on-screen layout is exercised by the compile and the pure filter tests only.

Omni-search results panel (16 Oct 2026)

The results panel above the omni-search field was already on the tree (it landed with the entry point and pill morph, commits 80f7b0a and e2147b0); this pass verified it against the brief and documents it, because the entry point/pill section left the panel itself undocumented.

  • Above the input, above the keyboard. PipelinesApp puts the panel and the destination bar in one bottom-anchored Column that clears paneSafeArea() (WindowInsets.safeDrawing, which carries the IME and the navigation bar); the panel takes the remaining height with weight(1f, fill = false) and scrolls its LazyColumn inside it, so it is never under the field or the keyboard. The activity declares adjustResize and the app is edge-to-edge, so the Compose window inset is the only source of the IME geometry and it is applied once, here (the chat composer likewise reads it once, through imePadding).
  • Badge, title, secondary line. OmniSearchResults.searchRow gives every hit a pipeline/run/step/artifact/match badge (searchBadge, a version hit reads as pipeline), a title and a secondary line; a text ("field") hit's secondary line is its snippet, split by snippetSpans and rendered bold+underlined for the matched span, so the match is legible without colour.
  • Debounced, no flicker, no stale overwrite. AppViewModel debounces keystrokes through the pure SearchSequencer: a burst collapses to one request for the last edit, SearchUiState.editing keeps the previous results (a thin progress bar marks the refresh), and accepts gates every reply on the newest sent token, so an older query can never land on top of a newer one.
  • Loading, empty, error. The first load shows a "Searching…" row; the empty state names the query (No matches for "<query>".); a failure is shown in place of the results without discarding what was already loaded.
  • Navigation. Selecting a result resolves through searchTarget and closes the search: a pipeline/version opens the pipeline detail, a run opens the run detail, a step or artifact opens the recorded visit's stage pane (whose leading section is the visit's Artifacts gallery), and a text match opens the run-detail section holding it (searchFieldSection). A kind with no known payload resolves to no target and is shown read-only rather than dropped.
  • Tests. OmniSearchResultsTest covers the badge/row mapping, the snippet split, the result-to-target mapping for every kind, the run-target resolution (visit index and section) and the debounce/stale/panel-state transitions; OmniSearchTest covers the field state and its Saver.

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

  • gradle :app:testDebugUnitTest :app:assembleDebug --no-daemon --offline --console=plain --rerun-tasks → BUILD SUCCESSFUL in 14s (41 actionable tasks: 41 executed). The 39 result XMLs aggregate to 349 tests, 0 failures, 0 errors, 0 skipped.
  • app/build/outputs/apk/debug/app-debug.apk is 18,126,113 bytes, sha256 69e61b9564b5958e21e9b56465a7f1c9c60e29d5767b53fe7549ecfd67db6f8b.
  • APK publish. app-debug.apk copied to ~/.local/share/pipelines/data/artifacts/186/1/pipelines-debug-wip-9b9f12f.apk (9b9f12f = git rev-parse --short HEAD); shasum -a 256 matched. The LAN URL http://10.0.0.249:8080/artifacts/186/1/pipelines-debug-wip-9b9f12f.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 18126113.

Not verified in this pass: device frames of the populated panel, the empty result and a selection navigating (the visual review owns the device, per the brief's device policy); the panel's pure logic is exercised by the unit tests and the compile only.

Chat destination and multiple conversations (16 Oct 2026)

The first Chat slice: the destination, the server session list and several conversations held open at once. android/ only; no new dependency (the material-icons-extended icon is the declared one), no Pipelines server/Go/ installer/Docker file touched, no run started from the app, and the operator's physical device was never used (emulator-5556 only).

  • Pill. The floating destination pill gains a Chat icon between Runs and Settings (icons only, 48dp targets via the named DESTINATION_ITEM_SIZE/ DESTINATION_ITEM_GAP tokens, one non-wrapping Row), so it stays narrow and clear of the reserved 88dp bottom inset however many destinations it holds. The Search destination is owned by another lane and is not present on this base; the pill is built to take it.
  • Brokered protocol. data/protocol/Chat.kt mirrors internal/protocol/chat.go field-for-field (sessions, create, query, prompt, messages/parts, event frames, permission, reply); Message gains the optional chat_* payloads and PipelinesClient now forwards unsolicited frames (chat_event/chat_permission) to events instead of dropping them. PipelinesRepository exposes the typed chat calls.
  • Multi-chat model. ui/chat/ChatStore.kt is an Android-free state holder: every open chat keeps its own conversation, running flag, composer draft and scroll position; open/activate report when history must be (re-)fetched so a running session re-syncs on return instead of showing a stale copy; a server frame is applied to its chat whether or not it is on screen. busy sessions render read-only and the composer refuses to write to them.
  • Surface. ui/chat/ChatScreen.kt reuses the shared adaptive SlidingPaneStack (session list → conversation): the list shows each session's running/busy/read-only status, an open-chat strip switches between several conversations in one tap (with an optional X to close one), and the conversation is a bottom-anchored transcript of user bubbles, secondary reasoning, assistant text and tool-call chips that expand to INPUT (pretty-printed JSON) / OUTPUT (monospace, via the shared CodeBlock). "New chat" creates a server session and opens it. Closing a chat is provided (the chip X); it removes only that chat.
  • Messages sent to a chat are optimistic (the bubble shows immediately); the live delta/streaming pass is the next slice.

Evidence (macOS, JDK 17, Gradle 9.7.1 --offline, ANDROID_HOME=/Users/alan/Library/Android/sdk):

  • gradle :app:assembleDebug :app:testDebugUnitTest --rerun-tasks → BUILD SUCCESSFUL, 229 tests, 0 failures (new MultiChatStateTest: switching preserves each conversation, a running session re-syncs on return, drafts and scroll are per chat, a busy session is read-only, background events land on their own chat; new ChatProtocolTest for the wire shapes; new ChatFormatTest).
  • The debug APK was installed on emulator-5556 (FoldB_API_36, narrow wm size 1080x2340 @420) and driven with uiautomator dump/input tap; captures were validated with android/scripts/capture_png.sh -s emulator-5556: the pill with the Chat destination (01_pill_chat), the session list (02_chat_list, 05_chat_list_one_open, 07_chat_list_two_open), two chats with different conversations (03_chat_alpha and 06_chat_beta), a tool chip expanded to INPUT/OUTPUT (04_chat_alpha_tool_expanded), a read-only busy session with a disabled composer (08_chat_readonly) and a per-chat draft preserved across a switch (10_draft_preserved). adb -s emulator-5556 logcat -d held 0 FATAL EXCEPTION and 0 E AndroidRuntime during the sweep.
  • The deployed Pipelines server predates chat (verified: a chat_sessions request answers unknown command: chat_sessions), and the server-side chat broker is a separate lane. The on-emulator sweep therefore drove the client against chat_stub.py, a minimal /connect WebSocket double that speaks the exact internal/protocol/chat.go JSON, so the screenshots show real client rendering of the documented wire contract, not the production service.
  • APK publish. app-debug.apk (18,261,008 bytes, sha256 aa167617c830fd7249eedf457959ef7e99b553769ed4ab82a3af6b4e8cb98ed3) copied to ~/.local/share/pipelines/data/artifacts/119/1/pipelines-debug-wip-e5bde98.apk; curl -I http://10.0.0.249:8080/artifacts/119/1/pipelines-debug-wip-e5bde98.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 18261008; a streamed GET | shasum -a 256 matched.

Not verified in this pass: the live brokered server (not deployed and out of this lane's scope), a genuinely running session's re-sync against OpenCode (covered by the model test, not live), and streaming/stop/approval/attachments, which are later slices.

Review follow-ups (16 Oct 2026, implementer pass)

Addressing the reviewer's findings on the slice above, still android/ only.

  • Shared part upsert (duplication blocker). ChatStore.applyDelta and applyTool were the same message/part upsert twice. Both now call one private upsertPart(frame, partId) { existing -> … }; the delta appends to the existing text, the tool replaces the part, and neither can drift. event() and the new permission() share one ensureThread() placeholder creator.
  • Diff cards (task gap). The research report's edit view (_CodeRun / _DiffView, §1.3) is now reproduced: an edit-family tool call renders a diff card. ChatFormat.toolEditDiff derives an LCS line diff from the arguments' oldString/newString — the brokered protocol has no diff field (research §2.5), so it is synthesised, never silently dropped. The collapsed chip shows the file and the +N -M stat; expanding shows the green/red monospace lines (the app's own success/failure hues, not new literals).
  • One read-only rule (divergent code). sessionReadOnly was dead (only its own test called it) and disagreed with the UI's ChatThread.readOnly = busy for a locally-running busy session. The helper is deleted and ChatThread.readOnly is now busy && !running, the same precedence sessionStatusLabel uses: a turn we started is Running and writable, not read-only.
  • chatReply / approval now reachable (unused API). observeChatEvents forwards chat_permission into ChatStore.permission instead of dropping it, the conversation shows an approval bar (action, resources, Allow once / Always / Deny) and AppViewModel.replyChatPermission answers through chatReply.
  • Stop control fixed (found while tracing read-only). While a turn ran the composer's red stop button was wired to onSend, so it sent the draft instead of interrupting; it now calls stopChat.
  • Evidence gap closed. The previous checklist cited 09 (new chat) but no 09_* file existed; this pass captures 09_new_chat.png (the New-chat conversation), plus 11_diff_card.png and 12_permission_bar.png for the two new surfaces.

Evidence (macOS, JDK 17, Gradle 9.7.1 --offline, ANDROID_HOME=/Users/alan/Library/Android/sdk):

  • gradle :app:assembleDebug :app:testDebugUnitTest --offline → BUILD SUCCESSFUL; the JUnit XML totals 233 tests, 0 failures, 0 errors, 0 skipped (new toolEditDiffMarksOnlyChangedLinesAndCountsThem, toolEditDiffIsNullForNonEdits, locallyRunningBusyChatStaysWritable, permissionIsStoredUntilAnswered).
  • The debug APK was installed on emulator-5556 only and driven with uiautomator dump/input tap; captures validated with android/scripts/capture_png.sh -s emulator-5556: the new-chat conversation (09_new_chat), the derived diff (11_diff_card, showing context / - val gap = 4.dp / + val gap = 6.dp / + val inset = 2.dp under a src/layout.kt +2 -1 chip) and the approval bar (12_permission_bar). Tapping Allow once cleared the bar through chat_reply. adb -s emulator-5556 logcat -d held 0 FATAL EXCEPTION and 0 E AndroidRuntime. Driven against the test-double stub (the deployed server still predates chat).
  • APK publish. app-debug.apk (18,228,844 bytes, sha256 db240fc2fc295c5ab50530f9d8cefae908f307a3115b54ce9f6d713e05643b87) copied to ~/.local/share/pipelines/data/artifacts/119/3/pipelines-debug-wip-e5bde98.apk.

Still not verified: the live brokered server (separate lane), streaming against real OpenCode, and attachments — unchanged from the pass above.

Conversation markdown rendering (16 Oct 2026)

The assistant's text part was rendered as one plain Text; it is now rendered as markdown, matching the reference experience (research report Part 1 §1.2). android/ only; no new dependency (still just the declared material-icons-extended), no Pipelines server/Go/installer/Docker file touched, no run started from the app, and emulator-5556 only (lane A's emulator-5554 was never addressed).

  • Parser. ui/chat/Markdown.kt adds a small, dependency-free CommonMark subset. It is pure Kotlin (no Compose, no transport) so it is unit-testable: paragraphs (soft-wrapped lines join with a space), #..###### headings, fenced code ( / ~~~, with the info string as the language), block quotes, bullet and ordered lists, | tables (with a --- delimiter row), thematic rules, and inline code / bold / italic / [label](url) / bare-http(s):// autolinks. Underscore emphasis needs word boundaries so snake_case is never italicised. Anything outside the subset renders as plain text, never dropped.
  • Renderer. The same file turns the blocks into themed, selectable Compose content: fenced code reuses the shared CodeBlock, so the whole-block copy action is the existing one (label = the fence language, code when absent); tables are a bordered grid with a bold header and equal-weight wrapping cells; links use LinkAnnotation.Url, so they are tap-openable and styled from the scheme; inline code and headings use the shared type roles (pipelinesText()), not ad-hoc sizes. ChatScreen.MessagePart now calls MarkdownText(part.text) for PART_TEXT; the assistant message stays one SelectionContainer, so all of it remains selectable and the bounded code block/table keep long content inside the bubble. Geometry reuses the chat tokens (CHAT_ITEM_GAP, promoted from private to internal); only the quote-bar width and table border, which had no token, are new named constants.

Evidence (macOS, JDK 17, Gradle 9.7.1 --offline, ANDROID_HOME=/Users/alan/Library/Android/sdk):

  • gradle :app:assembleDebug :app:testDebugUnitTest --offline → BUILD SUCCESSFUL; the JUnit XML totals 243 tests, 0 failures, 0 errors, 0 skipped (new MarkdownTest: fences keep their language, an unterminated fence still yields code, soft-wrapped paragraphs join, headings/rules parse by level, bullet/ordered lists, table header/rows, inline code/bold/italic/link, bare-URL autolink trims trailing punctuation, snake_case is not emphasis, empty source → no blocks).
  • The debug APK was installed on emulator-5556 only and driven against a stdlib /connect WebSocket double serving a fixed history; capture was validated with android/scripts/capture_png.sh -s emulator-5556: chat_markdown_conversation.png shows the bottom-anchored transcript with the user bubble, the secondary reasoning line, body markdown with inline code and an underlined link, a kotlin fenced code block with its copy action, and the bordered Surface | Role table. adb -s emulator-5556 logcat -d held 0 FATAL EXCEPTION and 0 E AndroidRuntime during the sweep.
  • APK publish. app-debug.apk (18,076,412 bytes, sha256 bb290a7f42a3b28e613098dfffea438c34a5332081cffc6a2fbc0d275c207f68) copied to ~/.local/share/pipelines/data/artifacts/124/1/pipelines-debug-wip-0718f5b.apk; HEAD is 0718f5b and a streamed curl | shasum -a 256 of http://10.0.0.249:8080/artifacts/124/1/pipelines-debug-wip-0718f5b.apk matched.

Not verified: the live brokered server (separate lane), streaming against real OpenCode, and attachments — unchanged from the passes above. The markdown subset is intentionally smaller than full CommonMark (no HTML, no reference links, no nested lists, no strikethrough).

Streaming replies (16 Oct 2026)

The live delta/streaming pass promised by the first slice. android/ only; no new dependency (still just the declared material-icons-extended), no Pipelines server/Go/installer/Docker file touched, no run started from the app, and emulator-5556 only (lane A's emulator-5554 was never addressed).

  • Turn lifecycle in the model. ChatStore now owns ChatThread.runningSince and one private setRunning transition, so a turn that begins is stamped with the wall clock and settling clears it; ChatThread.elapsedMillis(now) is the one pure derivation the indicator and its test share. event already appended text/reasoning deltas to the target part and upserted tool parts, wherever the frame's chat sits in the open order.
  • Running indicator. The transcript's indicator shows the spinner, Working… and the live elapsed time (ticked once a second, never per frame, through the shared formatDuration). Its tick loop is keyed on the turn's start and stops the moment the turn settles, and the elapsed value keeps counting across a chat switch because it lives on the thread, not the composable.
  • Follow the stream. The transcript hard-jumps to the newest item while a turn runs — a fast-growing reply outruns an animation — unless the operator has scrolled up to read; returning to the end resumes following. Consuming the list state's interactionSource.interactions (DragInteraction.Start/Stop/Cancel) distinguishes a user drag from the programmatic jump, so the jump never un-sticks the view.
  • Reconnect resync. AppViewModel.observeConnection re-fetches every open chat's history whenever the socket transitions to Connected, after ChatStore.streamResumed() settles each running thread (a still-live stream re-asserts running on its next frame, so no stale Working… sticks). The resync replaces the conversation wholesale, so a gap can neither duplicate nor drop text.
  • Failure settle. A server-pushed error frame carries no session id (the brokered protocol cannot attribute it), so ChatStore.streamError settles the sole running chat — or the active one when several are in flight — and keeps the server's text; with nothing running it is ignored. The prompt-call failure path already settled the turn and is unchanged.
  • Non-blocking. Unsolicited frames reach the UI through the client's bounded SharedFlow (tryEmit from the socket thread, DROP_OLDEST capacity 256), so a slow collector never blocks the read loop; each mutation touches only its chat and the LazyColumn keys limit recomposition to the changed item.

Evidence (macOS, JDK 17 target, Gradle 9.7.1, ANDROID_HOME=/Users/alan/Library/Android/sdk):

  • gradle :app:assembleDebug :app:testDebugUnitTest → BUILD SUCCESSFUL; the JUnit XML totals 248 tests, 0 failures, 0 errors, 0 skipped (new ChatStreamTest: a delta sequence grows the rendered text and toggles the running indicator, the elapsed time comes from the turn's own start and a repeated start keeps it, streamResumed settles every open chat and returns them for re-fetch, streamError settles the running turn with the server's text and is ignored with nothing running).
  • The debug APK was installed on emulator-5556 only and driven with uiautomator dump/input tap against .stream_check/stream_stub.py (a stdlib /connect WebSocket double that streams chat_event frames; test scaffolding, not the app — the deployed server still predates chat). Captures were validated with android/scripts/capture_png.sh -s emulator-5556: a mid-stream reply with the growing transcript and the indicator at Working… · 1s (chat_stream_01_early) and Working… · 4s with the list followed to the newest line (chat_stream_02_mid); the settled turn with the completed bash 340ms tool chip, no indicator and the send control restored (chat_stream_03_settled); and, after a mid-stream drag up, the transcript staying where the operator left it while the turn still ran (chat_stream_04_scrolled_up). adb -s emulator-5556 logcat -d held 0 FATAL EXCEPTION and 0 E AndroidRuntime during the sweep.
  • APK publish. app-debug.apk (18,262,465 bytes, sha256 ef435b662e6f7e7467b5ae25b69fb24f8904334af204224aad00bfd76879a84e) copied to ~/.local/share/pipelines/data/artifacts/126/1/pipelines-debug-wip-d7f6500.apk; curl -I http://10.0.0.249:8080/artifacts/126/1/pipelines-debug-wip-d7f6500.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 18262465, and a streamed GET | shasum -a 256 matched.

Not verified in this pass: the live brokered server (separate lane), streaming against real OpenCode, and attachments — unchanged. :app:lintDebug could not run in this environment: the Gradle JVM reports 25.0.4.1, a version string the AGP 8.7.2 lint (IntelliJ JavaVersion) rejects, so lint fails before analysing the tree; this is environmental and unrelated to the change.

Tool-call chips and the expandable panel (16 Oct 2026)

The tool-call surface now matches the reference chat's _ToolCalls/_ToolChip and _buildPanel (research §1.3) more closely. android/ only; no new dependency (still just the declared material-icons-extended), no Pipelines server/Go/installer/Docker file touched, no run started from the app, and emulator-5556 only (lane A's emulator-5554 was never addressed).

  • Grouped chips. A run of consecutive tool parts in one assistant turn is now one FlowRow of compact chips (ToolCalls/ToolChip), so the turn's calls sit together and wrap instead of each taking a full-width row. Each chip keeps its kind icon, label (the edited file for an edit), +N -M diff stat, duration and running spinner.
  • Overlay panel, scroll preserved. Tapping a chip opens its INPUT/OUTPUT panel as a Popup anchored to that chip, not as inline content. The former inline panel re-flowed the transcript (a short chat visibly jumped); the popup is outside the list layout, so opening, failing or dismissing it never moves the conversation's scroll anchor. ToolPanelPositionProvider places it below the chip, flips it above when there is no room, and keeps it inside the window margins. The panel is dismissible by its own X or by tapping outside, and its INPUT and OUTPUT blocks carry the shared CodeBlock copy action.
  • Visible failure. An error tool call is now unmistakable: an error-tinted chip with an ErrorOutline icon (toolFailed), and its panel shows an ERROR block with the tool's error text (ChatFormat.toolFailed).
  • Diff cards preserved. An edit-family chip still expands to the synthesised green/red diff (toolEditDiff/DiffView), unchanged.

Evidence (macOS, Gradle 9.7.1 --offline, ANDROID_HOME=/Users/alan/Library/Android/sdk):

  • gradle :app:assembleDebug :app:testDebugUnitTest --offline → BUILD SUCCESSFUL; the JUnit XML totals 252 tests, 0 failures, 0 errors, 0 skipped (new toolFailedOnlyForTheErrorStatus, and ToolPanelPositionProviderTest: below-the-chip, flip-above and margin-clamp placement).
  • The debug APK was installed on emulator-5556 only and driven against .tool_calls_check/chat_stub_tools.py (a stdlib /connect WebSocket double serving the documented internal/protocol/chat.go JSON; test scaffolding, not the app). Captures were validated with android/scripts/capture_png.sh -s emulator-5556: 01_tools_collapsed.png (the completed bash 340ms and src/layout.kt +2 -2 300ms chips grouped), 02_tools_expanded.png (the bash chip expanded to INPUT pretty JSON + OUTPUT monospace with the transcript behind it unmoved — the chips keep the same on-screen position), and 03_error_chip_collapsed.png/04_error_chip_expanded.png (the failed shell chip in the error container and its panel INPUT + ERROR text). Tapping outside the panel dismissed it with the chips still in place. adb -s emulator-5556 logcat -d held 0 FATAL EXCEPTION and 0 E AndroidRuntime during the sweep.
  • APK publish. app-debug.apk (18,262,465 bytes, sha256 160f10ea8a2dc80364bb7f38596d50d08557ccce01f99705b93a8b9bc9216c27) copied to ~/.local/share/pipelines/data/artifacts/129/1/pipelines-debug-wip-d7f6500.apk; curl -I http://10.0.0.249:8080/artifacts/129/1/pipelines-debug-wip-d7f6500.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 18262465, and a streamed GET | shasum -a 256 matched.

Not verified in this pass: the live brokered server (separate lane), streaming against real OpenCode, and attachments — unchanged from the passes above.

Tool-call review fixes (16 Oct 2026)

Two findings from the tool-call slice review, both in android/, under the same constraints as above (no new dependency beyond the declared material-icons-extended, no Pipelines server/Go/installer/Docker file touched, no run started from the app, emulator-5556 only).

  • One elapsed derivation. ChatScreen.rememberElapsedMillis re-derived the running turn's elapsed time by subtracting the start itself, duplicating the tested ChatThread.elapsedMillis and contradicting the two KDocs that claimed the indicator shared the model's derivation. The composable now ticks a rememberElapsedNow(runningSince) wall clock (once a second, and only while the turn lives) and reads thread.elapsedMillis(now), so the model and the UI cannot drift.
  • No per-frame allocation. ToolCalls keyed its open-panel remember on parts.map { it.id }, allocating a list on every streaming recomposition. The key is unnecessary — an id no longer among the calls simply matches nothing — so openId is plain remembered state and a streaming rebuild no longer allocates a key list.

Evidence (macOS, Gradle 9.7.1 --offline, ANDROID_HOME=/Users/alan/Library/Android/sdk):

  • gradle :app:assembleDebug :app:testDebugUnitTest --offline → BUILD SUCCESSFUL; the JUnit XML totals 252 tests, 0 failures, 0 errors, 0 skipped.
  • The rebuilt debug APK was installed on emulator-5556 only and driven against .tool_calls_check/chat_stub_tools.py and chat_stub_error.py (stdlib /connect WebSocket doubles serving the documented internal/protocol/chat.go JSON; test scaffolding, not the app). Captures were validated with android/scripts/capture_png.sh -s emulator-5556 into .tool_calls_fix/: 01_tools_collapsed.png (the completed bash 340ms and src/layout.kt +2 -2 300ms chips grouped), 02_tools_expanded.png (the bash chip's INPUT pretty JSON + OUTPUT monospace), 04_diff_card.png (the edit chip's synthesised green/red diff card), 03_dismissed_outside.png (tapping outside dismissed the panel with both chips at the same on-screen bounds), and 05_error_chip_collapsed.png/06_error_chip_expanded.png (the failed shell chip in the error container, with a Failed tool call description, and its panel INPUT + ERROR text). adb -s emulator-5556 logcat -d held 0 FATAL EXCEPTION and 0 E AndroidRuntime during the sweep.
  • APK publish. app-debug.apk (18,219,766 bytes, sha256 b607a879ce2f2ac324fe6fa254918a456337c678abc1781bb79a05d88d539984) copied to ~/.local/share/pipelines/data/artifacts/129/3/pipelines-debug-wip-d7f6500.apk; curl -I http://10.0.0.75:8080/artifacts/129/3/pipelines-debug-wip-d7f6500.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 18219766, and a streamed GET | shasum -a 256 matched. This supersedes the 129/1 publish above: it is built from the current source, so the change is in the served artifact (a fresh rebuild can still differ in classes5.dex — the reproducibility caveat recorded in review stands).

Not verified in this pass: the live brokered server (separate lane), streaming against real OpenCode, and attachments — unchanged from the passes above. :app:lintDebug still cannot run here (the Gradle JVM's 25.0.4.1 version string is rejected by AGP 8.7.2 lint), unchanged from the slice above.

Tool-call review fixes, second pass (16 Oct 2026)

Three findings from the tool-call slice's second review, all in android/ under the same constraints (no new dependency beyond the declared material-icons-extended, no Pipelines server/Go/installer/Docker file touched, no run started from the app, emulator-5556 only).

  • A failed edit call shows its error. The panel only rendered the diff for an edit-family call, because the diff != null branch sat above the failed check, so a failed edit showed no error text. The ERROR block is now emitted whenever toolFailed, alongside the diff when one exists; a failed non-edit call keeps INPUT + ERROR, and a successful edit still shows the diff alone.
  • The error message, not the partial output. ChatFormat.toolOutputText returned non-blank state.content before it considered state.error, and that text fed the ERROR block, so a failed call carrying both showed its partial output under the ERROR heading. The failed call's text now comes from the new toolErrorText, which prefers the server's message and falls back to the output text only when the failure carries none; toolOutputText is the OUTPUT derivation again.
  • README mechanism corrected. The follow-the-stream bullet claimed a snapshotFlow on the list's scroll state; the code consumes listState.interactionSource.interactions (DragInteraction.Start/Stop/Cancel), as the bullet now says.

Evidence (macOS, Gradle 9.7.1, ANDROID_HOME=/Users/alan/Library/Android/sdk):

  • gradle :app:testDebugUnitTest :app:assembleDebug → BUILD SUCCESSFUL; the JUnit XML totals 253 tests, 0 failures, 0 errors, 0 skipped (the failed-text helper split into toolOutputFallsBackToNoOutput and toolErrorPrefersTheMessageOverPartialOutput, which asserts the message wins over a failed call's partial output).
  • The rebuilt debug APK was installed on emulator-5556 only and driven against .tool_calls_fix2/chat_stub_failed_edit.py (the review tool stub plus a failed edit call with oldString/newString and a failed bash call carrying both partial output and an error; stdlib /connect WebSocket double, test scaffolding, not the app). Captures were validated with android/scripts/capture_png.sh -s emulator-5556 into .tool_calls_fix2/: 04_failed_edit_expanded.png shows the failed edit chip's diff and its ERROR block (oldString not found in src/layout.kt), and 06_failed_bash_expanded.png shows the failed bash call's INPUT + ERROR (exit status 2: src/nope.kt: No such file), the error text — not the partial output — under the ERROR heading. uiautomator dump confirms the same nodes; adb -s emulator-5556 logcat -d held 0 FATAL EXCEPTION and 0 E AndroidRuntime during the sweep.
  • APK publish. app-debug.apk (18,219,360 bytes, sha256 4522aa62c8a3a59033aa2cca8b7fba65267dbdde473284585eaae47f03aeda2f) copied to ~/.local/share/pipelines/data/artifacts/129/5/pipelines-debug-wip-d7f6500.apk; curl -I http://10.0.0.249:8080/artifacts/129/5/pipelines-debug-wip-d7f6500.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 18219360, and a streamed GET | shasum -a 256 matched. This supersedes the 129/3 publish above: it is rebuilt from the current source, so the fix is in the served artifact (the classes5.dex reproducibility caveat recorded in review stands).

Not verified in this pass: the live brokered server (separate lane), streaming against real OpenCode, and attachments — unchanged from the passes above.

Edit diffs: file name, stat and large-edit summarisation (16 Oct 2026)

The edit diff card already derived its lines, but three things the task calls for were missing or wrong. android/ only; no new dependency (still just the declared material-icons-extended), no Pipelines server/Go/installer/Docker file touched, no run started from the app, and emulator-5556 only (lane A's emulator-5554 was never addressed).

  • The file name and +N -M are on the card, not just the chip. The expanded panel header showed the tool name (edit); it now shows the edited file (as the chip already did) and the shared green/red DiffStat, so the diff names its file and its counts wherever it is read.
  • Very large edits are summarised, not flooded. A diff longer than MAX_RENDERED_DIFF_LINES (200) kept every line — the >400-line fallback rendered old + new in full, thousands of Text nodes in a scrolling Column on a phone. ChatFormat.toolEditDiff now keeps the first 200 lines and carries the rest in the new ToolDiff.omitted; DiffView prints … N more changed lines not shown first, so the truncation is visible without scrolling. The +N -M counts still describe the whole edit, never the rendered prefix.

Evidence (macOS, JDK 17, Gradle 9.7.1 --offline, ANDROID_HOME=/Users/alan/Library/Android/sdk):

  • gradle :app:testDebugUnitTest :app:assembleDebug → BUILD SUCCESSFUL; the JUnit XML totals 254 tests, 0 failures, 0 errors, 0 skipped (new toolEditDiffSummarisesAnOversizedEditInsteadOfRenderingEveryLine, which asserts the true +250 -250 counts, the 200-line render cap and omitted = 300; the small-edit test now also pins omitted = 0).
  • The rebuilt debug APK was installed on emulator-5556 only and driven against .diff_check/chat_stub_diff.py (the .tool_calls_check/chat_stub_tools.py /connect WebSocket double plus a 300-line edit whose intersection with the cap must summarise; stdlib double, test scaffolding, not the app). Captures were validated with android/scripts/capture_png.sh -s emulator-5556: 03_diff_small.png shows the small edit card — src/layout.kt +2 -2 300ms, then red - val gap = 4.dp / - val inset = 1.dp and green + val gap = 6.dp / + val inset = 2.dp in monospace — and 05_diff_summarised.png shows src/big.kt +100 -100 150ms over … 200 more changed lines not shown and the interleaved context/-/+ lines. uiautomator dump confirms the same nodes; adb -s emulator-5556 logcat -d held 0 FATAL EXCEPTION and 0 E AndroidRuntime during the sweep.
  • APK publish. app-debug.apk (18,220,501 bytes, sha256 7cfca9c40361d4f1871bc61da20aec8c918637f8e085b8eb534d134b3cb8fe00) copied to ~/.local/share/pipelines/data/artifacts/133/1/pipelines-debug-wip-291cec2.apk; curl -I http://10.0.0.75:8080/artifacts/133/1/pipelines-debug-wip-291cec2.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 18220501, and a streamed GET | shasum -a 256 matched.

Not verified in this pass: the live brokered server (separate lane), streaming against real OpenCode, and attachments — unchanged from the passes above. :app:lintDebug still cannot run here (the Gradle JVM's 25.0.4.1 version string is rejected by AGP 8.7.2 lint), unchanged from the slices above.

Stopping a running turn (16 Oct 2026)

The composer already swapped its send control for a red Icons.stop while a turn ran and AppViewModel.stopChat already sent chat_interrupt; the slice was missing the proof the task asks for — a unit test pinning the interrupt frame — so this pass adds that seam and the on-device capture. android/ only; no new dependency (still just the declared material-icons-extended), no Pipelines server/Go/installer/Docker file touched, no run started from the app, and emulator-5556 only (lane A's emulator-5554 was never addressed).

  • One interrupt frame. ChatProtocol.interruptRequest(sessionId) builds the single chat_interrupt frame (a ChatQuery carrying the session id); PipelinesRepository.chatInterrupt sends it, so the wire shape is no longer constructed inline where only production can see it.
  • The stopped state is honest. On a successful interrupt the thread settles (running = false, no error) and the composer's send control returns; only a failing call (or a server-pushed error frame) sets the conversation's error, so a stop the server accepted is never shown as a failure.

Evidence (macOS, JDK 17, Gradle 9.7.1 --offline, ANDROID_HOME=/Users/alan/Library/Android/sdk):

  • gradle :app:assembleDebug :app:testDebugUnitTest --offline → BUILD SUCCESSFUL; the JUnit XML totals 255 tests, 0 failures, 0 errors, 0 skipped (new chatInterruptRequestCarriesTheRunningSession, which asserts the frame the stop control sends is chat_interrupt for the running session and survives the client's JSON round-trip).
  • The debug APK was installed on emulator-5556 only and driven against .stop_check/chat_stub_hold.py (a stdlib /connect WebSocket double that holds the turn open until chat_interrupt; test scaffolding, not the app) with uiautomator dump/input tap; captures validated with android/scripts/capture_png.sh -s emulator-5556: stop_control_running.png shows the running turn (Working… · 11s) with the composer's send control replaced by the red stop control (bottom-right, in thumb reach) and the top-bar stop action; stop_control_stopped.png shows the same chat after the stop was pressed — the indicator gone, the send control back, and no error text (the server acknowledged the interrupt). The stub log recorded exactly one chat_interrupt. adb -s emulator-5556 logcat -d held 0 FATAL EXCEPTION and 0 E AndroidRuntime during the sweep.
  • APK publish. app-debug.apk (18,240,566 bytes, sha256 56abfb2c59a9c09fabbe32d7de4f0164cdc852cece4b7df3655dd0c233256248) copied to ~/.local/share/pipelines/data/artifacts/135/1/pipelines-debug-wip-e2f306b.apk; curl -I http://10.0.0.249:8080/artifacts/135/1/pipelines-debug-wip-e2f306b.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 18240566, and a streamed GET | shasum -a 256 matched.

Follow-up: one tested composer action (16 Oct 2026, run 143)

The stop control was still chosen by an inline if (thread.running) in the composer, and the text field's keyboard send action only checked canSend, so a prompt could still be sent from the IME while a turn was in flight even though the visible control had become stop. ChatFormat.composerAction(thread) (ComposerAction.Send/Stop) is now the single pure derivation the trailing button and the keyboard action both read, so the two controls can no longer disagree; ChatFormatTest.composerControlIsStopWhileARunIsInFlightAndSendOtherwise covers it. android/ only; no new dependency.

  • Re-verified: gradle :app:assembleDebug :app:testDebugUnitTest --offline → BUILD SUCCESSFUL, 266 tests, 0 failures (the new composer-action case).
  • APK publish. app/build/outputs/apk/debug/app-debug.apk (18,249,033 bytes, sha256 a9ce0cc8829513ee37fa5abaafa765307d5574f7cbd2b9cf0bc32392d0c1461e) copied to ~/.local/share/pipelines/data/artifacts/143/1/pipelines-debug-wip-609721d.apk. curl -I http://10.0.0.249:8080/artifacts/143/1/pipelines-debug-wip-609721d.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 18249033; a streamed GET | shasum -a 256 matched.
  • Not driven on a device in this pass: the constraint that the stop control be exercised on an emulator only conflicts with this run's device note that only the operator's Pixel (adb serial 58281FDCG000JF) is available and no emulator may be run, so the evidence here is the unit tests and the build rather than a fresh screenshot. The earlier emulator-5556 captures (.stop_check/stop_control_running.png, .stop_check/stop_control_stopped.png) still show the running/stopped control states.

Not verified in this pass: the live brokered server (separate lane), streaming against real OpenCode, and attachments — unchanged from the passes above.

Approvals in the conversation, answered in place (16 Oct 2026)

The brokered protocol already carried chat_permission, but the phone only showed it as a bar above the composer and removed it the moment it was answered. This pass makes a pushed approval a card in the conversation: the reference app's amber risk framing, once/always/reject actions wired to chat_reply, an in-place settle on answer, and a resolved state for a request the server reports as already settled. android/ only; no new dependency (still just the declared material-icons-extended), no Pipelines server/Go/installer/Docker file touched, no run started from the app, and emulator-5556 only (lane A's emulator-5554 was never addressed).

  • The card is in the transcript. ApprovalCardItem is the transcript's last item, so the request sits with the conversation rather than floating above the composer. It shows the action (Approve edit), the affected resources in monospace, the amber RISK REVIEW panel carrying the server's risk summary (falling back to a neutral sentence naming the action when the server sends none), and Allow once / Always allow / Reject. The amber tertiary role at 12% fills the review panel and its shield glyph, and at 50% outlines a pending card — the same amber shield_outlined framing the reference app uses. Geometry reuses the existing chat tokens; the only new constants are the two alpha strengths.
  • Findable without scrolling the whole chat. The conversation's top bar shows a gold PanTool "Waiting for your approval" action while a request is open; tapping it jumps the transcript to the card, and the same glyph marks the chat's chip in the open-chat strip. A newly arrived request is also scrolled into view by the existing bottom-follow, and the running indicator stands down while the turn waits (the clock would otherwise tick on work that is not happening).
  • Answered in place. ChatStore.answerPermission records the decision optimistically, so the card settles to Allowed once / Always allowed / Rejected and drops its actions instead of disappearing; a failed chat_reply reopens the same request (permissionReplyFailed) with the error, so a decision the server never received is never shown as accepted. ChatProtocol.replyRequest is the one builder PipelinesRepository.chatReply sends, so the card's actions and the wire frame cannot drift.
  • Already resolved is honest. ChatPermissionFrame gained optional resolved and decision fields. A frame for a request the server reports as settled renders as Rejected/Always allowed/Already resolved with no controls, so a stale once/always/reject is never offered for a closed request; a frame for a new request replaces a settled card. Those fields are the additive contract the server sends when it reports an already-settled request (both are omitted by an older peer, which simply leaves every request pending).

Evidence (macOS, JDK 17, Gradle 9.7.1 --offline, ANDROID_HOME=/Users/alan/Library/Android/sdk):

  • gradle :app:testDebugUnitTest :app:assembleDebug → BUILD SUCCESSFUL; the JUnit XML totals 267 tests, 0 failures, 0 errors, 0 skipped (new ChatApprovalTest: a pushed frame yields a pending card with the request's action/resources/risk and its three actions, answering once/always/reject settles the card in place, a server-resolved frame offers no actions, a failed reply reopens the request, and the missing-summary fallback; new ChatProtocolTest.chatPermissionFrameCarriesTheServerResolution; the reply builder is asserted for once, always and reject through one shared encode/decode round trip, so no decision is asserted more weakly than another).
  • The rebuilt debug APK was driven on emulator-5556 against .approval_check/chat_stub_approval.py (a stdlib /connect WebSocket double that pushes a pending chat_permission after a prompt and a server-resolved one for a second session; test scaffolding, not the app). Fresh captures this pass, validated with android/scripts/capture_png.sh -s emulator-5556 into ~/.local/share/pipelines/data/artifacts/147/3/: 01_approval_pending.png (the Approve edit card with src/layout.kt, the amber RISK REVIEW panel and the three actions, the top-bar pan-tool and the chat-chip marker) and 02_approval_answered.png (the same card settled to Always allowed, no actions, the amber risk panel retired). The stub log recorded the chat_reply with decision=always request=req_pending_1. The already-resolved path was reached too — the Already resolved session rendered Rejected with the server's note and no controls — but emulator-5556 shut down before that frame could be captured, and it is not restarted here, so its evidence is the uiautomator dump (uiautomator_server_resolved.xml) rather than a second screenshot.
  • APK publish. app-debug.apk (18,109,180 bytes, sha256 5f58ac6e92a7fbeb2fd023b5604fd7876e9d2546cc7cadf3d871aa7a4b7cce43) copied to ~/.local/share/pipelines/data/artifacts/147/3/pipelines-debug-wip-305714c.apk (305714c = git rev-parse --short HEAD); the running artifacts server serves curl -I http://10.0.0.75:8080/artifacts/147/3/pipelines-debug-wip-305714c.apk as HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 18109180, and a streamed GET | shasum -a 256 matched.

Not verified in this pass: the live brokered server (separate lane), streaming against real OpenCode, and attachments — unchanged from the passes above. The resolved/decision frame fields are the additive contract the server must send when it reports an already-settled request; the live server does not emit them yet, so only the unit test and the stub exercise that path. :app:lintDebug still cannot run here (the Gradle JVM's version string is rejected by AGP 8.7.2 lint), unchanged from the slices above. emulator-5556 — this lane's standing device, already running when the pass began and never started or restarted here — shut down after the second capture, so the resolved frame was confirmed from the accessibility tree rather than a screenshot. The run's device note (all device work through the attached Pixel, no emulator) conflicts with the task constraint (emulator only, never install on the person's device); this pass resolved it by using the already-running emulator and never installing on the Pixel.

The covered region is sized for the statistics it shows (16 Oct 2026)

Review of the statistics block found three blocking problems, all rooted in the same cause: the covered region was measured too small for the statistics it was supposed to carry. First, the region was measured from the destination's bare compactLabel ("Runs" measured ~48.9dp, "Pipelines" ~76dp) plus the touch target floor, so PaneIdentity's width-derived tier never reached the statistics it was supposed to carry: "Runs" fell below PEEK_WIDTH_DP and rendered the title alone (the runs list showed no counts and no most-recent run), and even "Pipelines" only reached the Counts tier because the Full tier needs MIN_COVERED_PANE_WIDTH_DP + PEEK_WIDTH_DP (168dp). Second, even after the region was floored at the block, a pipeline-scoped identity is only ever the nearest covered pane at depth 2, where the thin older edge (startInset + minTouch) narrows it below 168dp, so its last-run/age and average lines stayed unreachable — avg was dead in the UI. Third, the title broke mid-word in a narrow strip ("Complete a Task" → "Complet"/"e a Task"). android/ only; no dependency was added, no run was started from the app, no server field was added, and the server/Go source/installer/Docker files were not touched.

  • The measured region carries the statistics, and the nearest edge keeps them. coveredIdentityWidthDp (ui/components/PaneIdentity.kt) is the pure width rule: the measured content (title or icon) plus the identity's own padding, floored at the platform touch target and — when the identity carries statistics — one touch target above the full block's width (MIN_COVERED_PANE_WIDTH_DP + PEEK_WIDTH_DP + minTouch). That extra touch target is the thin older edge the nearest identity gives up when a second level is covered (coveredEdgesDp; the leading gesture inset cancels against the region's own), so the nearest edge — the only pipeline-scoped pane that is ever covered — now clears the Full boundary and renders its last-run/age and average lines instead of only the counts. rememberCompactIdentityWidth gained a withStats flag, and SlidingPaneStack a compactStats parameter; the Pipelines and Runs stacks both pass true, since every covered pane in either is a list or a detail and both carry a statistics block (the stage pane is never a covered level: covered = level < depth and it is the third level). The active pane's width stays the same at every depth, because the region does not depend on depth. At depth 1 a single covered pane measures the full block width and shows every line; at depth 2 the nearest covered identity still reaches Full, while the older level shows its title alone in the thin edge.
  • The title breaks at whole words rather than mid-word. wholeWordTitle packs the title greedily onto whole-word lines and, once its lines are full, drops the remaining words and ellipsizes the last line at a word boundary; the only exception is a word wider than the whole strip, which is ellipsized to the width rather than wrapped (there is no internal boundary to break at). The helper takes an injected measure, so the packing rule is unit-testable, and PaneIdentity measures with the same cardTitle role and TextMeasurer it draws with.
  • The fixes are pure and unit-tested. coveredIdentityWidthDp's round trip through paneStatTier (a stats-bearing identity shows the full block), theNearestEdgeOfAStatisticsBearingStackStillShowsTheFullBlock (the region fed to coveredEdgesDp yields a nearest edge that clears the block at depth 2 — the geometry that was wrong) and wholeWordTitle's packing/ellipsis/oversized-word/no-room cases are asserted in PaneIdentityTest without a device. The nearest-edge case fails when the + minTouch reserve is removed, so it pins the defect rather than restating it.

Evidence (macOS, JDK 17 from Homebrew openjdk@17, the cached Gradle 8.11.1 distribution, ANDROID_HOME=~/Library/Android/sdk, --offline, every command with --no-daemon):

  • gradle clean :app:testDebugUnitTest :app:assembleDebug --no-daemon --offline --console=plain → BUILD SUCCESSFUL in 6s (41 actionable tasks; the clean evicted nothing cached, so compileDebugKotlin and testDebugUnitTest were FROM-CACHE for the fixed source and packageDebug/assembleDebug ran). The result XMLs total 300 tests, 0 failures, 0 errors, 0 skipped across 34 files; PaneIdentityTest has 12 cases, including aStatisticsBearingIdentityIsNeverSizedForItsBareTitle, theNearestEdgeOfAStatisticsBearingStackStillShowsTheFullBlock (run alone against the pre-fix floor it failed at PaneIdentityTest.kt:96, so it pins the defect), theTitleWrapsAtWholeWordsAndNeverSplitsOne and theTitleEllipsizesWholeWordsWhenTheLinesAreFull.
  • app/build/outputs/apk/debug/app-debug.apk is 18,046,987 bytes, sha256 9c2735c8e07db6a04a85616a85a88f2828ef8a551d5b6281a3993b9ea6be9ea7; it was copied to ~/.local/share/pipelines/data/artifacts/198/4/pipelines-debug-wip-af68a62.apk (af68a62 = git rev-parse --short HEAD; the tree is WIP on top of it). curl -sI http://10.0.0.75:8080/artifacts/198/4/pipelines-debug-wip-af68a62.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 18046987, matching the local file's size.

Not verified in this pass: the on-device wide/narrow renders and the one/two/four-level screenshots — the brief keeps implementation verification to the build and the unit tests, and visual review owns the device. The title wrapping is asserted against an injected measurer, not rendered pixels; the whole-word guarantee therefore rests on TextMeasurer and the drawn Text using the same role and width, which is why both read text.cardTitle and the identity's own SPACING_S padding.

Stage sections open as their own pane, not inline (17 Oct 2026)

The reported stage-screen defect is reproducible and this pass fixes it by opening every stage section as its own pane and by laying a collapsible body out in one column. android/ only; nothing in the Pipelines server, its Go source, the Docker/compose files or the installer was touched, no dependency was added and no run was started from the app.

  • The defect and its cause. Expanding a stage section drew its rows stacked at the top of the section: the section's content lambda emits one composable per field (fields.forEach { StageFieldRow(it) }) straight into CollapsibleSectionBody's AnimatedVisibility. AnimatedVisibility lays out a single child, so several siblings were placed on top of each other at the section's origin instead of one below the next; the body took the height of its tallest single row and showed only the last one, so the content did not sit cleanly under — or under all of — its header.
  • Sections are panes. The stage screen now keeps a compact list of its section rows (Artifacts, Output, Input, This run, Stage definition) and tapping one opens that section as the next pane of the stack — a full-window screen over the stage on a narrow window, a panel to the stage pane's right on a wide one — with its own Scaffold/TopAppBar named for the section, its own scroll and its own top spacing. Back (the app bar, the gesture or a peek) returns exactly one level, to the stage screen. MasterPane gained the Section level (MAX_PANE_DEPTH = 3) and PaneSelection.sectionKey (a primitive saved with the pane selection), so the open section survives rotation and process death.
  • No trivial inline exceptions. None of the five sections is kept inline: each can hold an arbitrarily long value (the definition's prompt/output contract, the input/output maps, the run evidence, the artifacts gallery), so an inline body would both risk the layout with many rows and push the run context off screen; one uniform rule keeps the screen predictable.
  • Rows read as navigation, not as disclosures. The stage screen's section rows go through the shared SectionHeader with navigation = true: the chevron becomes the static forward arrow (Icons.AutoMirrored.Filled .KeyboardArrowRight, mirrored for RTL) instead of a rotating disclosure chevron, and the row announces as Artifacts with an Open Artifacts action instead of Artifacts, collapsed / Expand Artifacts. Assistive tech is therefore never told the row expands in place after it started opening a pane. The disclosure rows (the run/pipeline detail lists) are unchanged. The rememberSectionExpansion seed that existed only to start the stage pane's definition expanded (initiallyExpanded) is gone with its last caller, so the shared component no longer carries docs or a parameter for the removed inline stage behaviour.
  • The shared body fix. CollapsibleSectionBody now lays its content out in a single full-width Column, so any collapsible section with more than one row (it also backs the run/pipeline detail collapsibleSection lists) stacks its rows under the header instead of overlapping them.
  • Semantics kept. Sections start collapsed; the operator's choice — which section is open, and the visit — is saved with the pane selection; and each section's content is derived from the same pure stageSectionSpecs (stageDefinitionFields/runStepFields/evidenceFields), so nothing shown before is lost. The artifacts section keeps the shared ArtifactSelectionScaffold.

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

  • gradle :app:testDebugUnitTest :app:assembleDebug --no-daemon --offline → BUILD SUCCESSFUL (compileDebugKotlin and compileDebugUnitTestKotlin executed on the edited sources); the test-result XMLs aggregate to 303 tests, 0 failures, 0 errors, 0 skipped across 34 classes (PaneStateTest gained the Section-level backStep, popTo, encode/decode and depth cases; StageDetailSheetTest replaced the definition-expansion seed with the stageSectionSpecs order/blank-section cases). The navigation affordance is Compose UI semantics, which this module has no unit harness for, so it is covered by compilation only, not by a test.
  • app/build/outputs/apk/debug/app-debug.apk is 18,272,941 bytes, sha256 dccce3ca1a3c5acc724dec376709f694e11a29b68ffd85eae4d5114c4f8989a1; it was copied to ~/.local/share/pipelines/data/artifacts/216/1/pipelines-debug-wip-dcd58b8.apk (dcd58b8 = git rev-parse --short HEAD; the tree is uncommitted WIP on top of it). curl -sSI http://10.0.0.249:8080/artifacts/216/1/pipelines-debug-wip-dcd58b8.apk returned HTTP/1.1 200 OK, Content-Type: application/vnd.android.package-archive, Content-Length: 18272941, matching the local file's size.

Not verified in this pass: the on-device narrow/wide renders (a section opening over the stage and returning, and the wide panel beside the stage pane) and any screenshot of the former inline case — the brief keeps implementation verification to the build and the unit tests, and visual review owns the device.

The server's template catalog (list_templates, which pipelines templates and pipelines template <key> --source already print) is now a first-class surface in the app; before this change the app showed nothing for it. android/ only: nothing in the Pipelines server, its Go source, the Docker/compose files or the installer was touched, no dependency was added (the destination glyph is the already-declared material-icons-extended Widgets) and no run is started from the app.

  • The destination. PipelinesApp's destination list gains a Templates entry between Pipelines and Runs (TemplatesIcon, Icons.Filled.Widgets, deliberately not the Pipelines workflow tree), and TemplatesDestination uses the same shared SlidingPaneStack the other destinations use: pane 0 the gallery, pane 1 the selected template's detail, with the selected key in rememberSaveable so the open template survives rotation and process death.
  • The gallery. TemplateGalleryScreen shows one card per template from vm.templates (loaded by a new AppViewModel.refreshTemplates, backed by PipelinesRepository.listTemplates): the name, the short description and the stage count, with the card's own leading glyph. templateGridColumns decides the layout — a single column on a narrow window, and on a wide one as many WIDE_RAIL_WIDTH_DP-shaped cards as fit SPACING_S apart via the shared galleryGrid fitting — so no new geometry constant is introduced.
  • Stage counts come from a parsed source, not a guess. list_templates carries only the source, so refreshTemplates parses each template's source on the server (validateSource, the validate command) once and caches the graph per key+source. A template whose source does not parse keeps a null graph: its card reads stage count unavailable (never 0 stages), its Graph tab says the source could not be parsed, and its Source tab shows the raw markdown — the template stays fully viewable.
  • The detail view reuses the pipeline-detail idiom. TemplateDetailScreen uses the same DetailTabs (pipelineDetailTabs: Summary / Graph / Source) and the same tab body/width handling as PipelineDetailScreen: Summary lists the stages, Graph renders the WorkflowGraph (with an explicit note when the source did not parse), and Source renders the definition through the shared PipelineSourceView.
  • One rendered-definition view, not two. PipelineSourceTab moved out of PipelineDetailScreen into ui/graph/SourceView.kt as PipelineSourceView, so the pipeline detail and the template detail render a definition through exactly one composable (per-stage collapsible sections, the Raw toggle, the copy action).
  • One gallery fitting, not two. The artifact gallery's private ArtifactGrid/artifactGrid fitting moved to the shared ui/components/GalleryGrid.kt (GalleryGrid/galleryGrid), so the templates gallery and the artifacts gallery share one measured-column rule and the artefact gallery tests now exercise the shared function.
  • Create from a template. A top-bar action on the detail opens a dialog that submits the template's source as a create-only draft pipeline (AppViewModel.createFromTemplate → PipelinesRepository.createPipeline, the submit command with create_only): the app's equivalent of the CLI's pipelines new --template KEY (that path writes a local draft file; the app has no filesystem, so it stores the draft on the server, where it appears in the Pipelines list). An existing name is never overwritten and no run is started.
  • States. Empty, loading and error states reuse the shared StateCrossfade state components; a covered pane shows only its compact identity.

Verification (this run's review stage, macOS, cached Gradle, --no-daemon): the offline build and unit tests pass at 35 suites / 309 tests / 0 failures / 0 errors, including the new TemplatesTest (the card/stage-count mapping, the stage count unavailable label for an unparsed source, and the narrow-column / wide-grid decision) and the relocated artifact-gallery cases now running against the shared galleryGrid. The app's create path was checked against the repo's own Go test for the server submit-with-create_only behaviour.

Visual review (this run, operator's Pixel 9 Pro XL, adb 47241FDAS00DLK, built from this tree and installed over the existing package) confirmed the gallery renders 5 cards — a single column at the phone's ~448dp width and a 4-column measured grid at wm size 2000x2244 — and that each card opens a Summary / Graph / Source detail with the create dialog, consistent with the app's Material 3 language. The empty, loading, error and unparseable-source states were built from the app's shared state components but could not be produced live without mutating the operator's server.