Mirror the server's derived verdict onto RunStep as a nullable
StageVerdict ({option, reason, reason_source, artifacts}, absent -> null),
matching internal/protocol/verdict.go.
Render a StageVerdictBlock at the top of the run pane, below the visit
tabs and above the facts, only when a verdict is present - a null or
empty verdict draws nothing, never an empty heading. The chosen option is
a ColoredChip in the stage outcome's existing colour; the reason is plain
pipelinesText().body that wraps without a maxLines clip.
The artifacts the reason names become inline, tappable references
(image/video open the shared ArtifactViewer, anything else uses the
existing openArtifact action) plus the same references as compact
FlowRow chips. Referenced names resolve to the visit's recorded
artifacts, deduplicated and in recorded order; reason text is split
around those names longest-match-first. No new dependency and no new dp
or sp literal.
android/ only.
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), andANDROID_HOME/ANDROID_SDK_ROOTset. - 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) orwss://…/connect(proxy/VPN). A path is optional and defaults to/connect, matching the Go server'sGET /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.mdandcompose.yaml). The field flags a non-absolute path and will not save it, mirroring the repository's start-run guard.
Tap Connect to open the single shared WebSocket (probed with ping, showing
the server build). Reconnect uses bounded exponential backoff; Disconnect
stops it.
Features
- Pipeline list (search/refresh, empty/error/loading states), pipeline details (version list, content hash, source) and the workflow graph.
- Workflow graph composable: content-sized stage nodes laid out in one row in
declaration order, with
#failure/#successterminals sharing a lower row and arrows entering their top borders (anerror -> #failureroute 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 executedsuccess/errorroute 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 (routePointscomputes the path once per layout and stores it onEdgeLayout.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 purezoomAboutkeeps the content point under the fingers fixed (clamped toMIN_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'sshapes.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, terminalSuccess/Failurein their own colour); edges draw with round caps/joins and every right-angle bend is rounded by oneROUTE_CORNER_RADIUScontrol 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 inrememberSaveableand the panel refits on resize. Because the panel lives inside each screen'sverticalScrollcolumn, growing it only extends it below the fold, so expanding also requestsBringIntoViewRequesterto 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 shortCrossfade: 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, viaSlidingPaneStack. Only the selected section is composed at rest, each section is a singleLazyColumn, and each section's own saved state (its list scroll position) is kept under its stable tab key through arememberSaveableStateHolder, so returning to a section never resets its scroll. The Graph tab keeps the full-heightWorkflowGraphpanel with its Fit and expand controls. Narrow windows show a horizontally scrollingPrimaryScrollableTabRow; wide windows show an always-visible selectable rail (icon + label, no collapse control).selectedIndexis the single source of truth and a tap reports the new index throughonSelect. The tabs carry real tab semantics (Role.Tab+ selected state), so selection is never conveyed by colour alone, and the selected index isrememberSaveable(survives recomposition, configuration change and process death) and clamped byclampTabIndex. - 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/#failurenamed as terminals), memory, limits and notification policy, skipping what a stage does not have. The rows come from the samestageDefinitionFields/StageFieldRowthe 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.ktcard:surfaceContainerrole, 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 = nullrenders 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 isrememberSaveable, so it survives configuration changes; the sections are items of the tab's singleLazyColumn, 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 fromLocalConfiguration.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 isrememberSaveable, 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 definitionsection 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 viaformatDuration, 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 rawresultPreviewis no longer printed, and progress is shown honestly (completed visits + current stage, with an indeterminate indicator while executing; no invented total). - One centralised type scale (
ui/theme/Typography.kt, passed toMaterialThemeand 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
usageaggregates, 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 viaget_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 reusedrequest_key≤128 chars, the configured absolute workspace andinput.prompt) and cancel run (confirmation; sends theRunID, 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:assembleDebugand:app:testDebugUnitTestall 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 newzoomAboutanchor/clamp cases, plus duration formatting, run-state mapping and run day-grouping). Re-run with--rerun-tasksto confirm.- The debug APK was installed and driven on the
Pixel_Fold_API_36emulator (Android 16,adb shell cmd uimode night yes) against a live server atws://10.0.2.2:8080/connectwith workspace/Users/alan/repos/pipelines. Settings, pipeline list (all 9 pipelines), pipeline detail, the workflow graph, run history and run detail were captured tocaptures/andcaptures/style_pass/(both git-ignored) and reviewed. adb logcatfor the app package contained noFATAL 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) holdspipeline_detail_before/afterandrun_detail_before/afterpairs 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 logcatshowed noFATAL EXCEPTIONand 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:testDebugUnitTestreported 76 tests, 0 failures (up from 60: newStageDetailSheetTestfor the stage/step field derivation andStepMetaTestfor the step metadata pairing + details predicate, plus the icon/rail-width assertions inDetailTabsTestand the file-change/notification formatting inFormatTest).:app:assembleDebugand:app:installDebugsucceeded; the install reportedInstalled 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.pngfollowed byadb -s emulator-5554 pull(neverexec-out … >), tocaptures/space_pass/(git-ignored):narrow_pipeline_top_tabs(narrow window, tabs across the top),source_tab_narrow(rendered definition) andsource_tab_raw_narrow(theRawtoggle revealing the exact markdown),wide_source_rail_expanded(icon+label rail, Source tab) andwide_source_rail_collapsed(icon-only rail, content visibly wider),wide_run_steps_expandedandwide_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), pluswide_graph_stage_sheet(tapping a stage on the Graph tab still opens the refactoredStageDetailSheet). 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 density390→401: the activity recreated and the collapsed strip stayed collapsed (Expand tabswas still the control's description after the change; capturewide_detail_rail_collapsed_config_change). The saved tab index is clamped byclampTabIndex(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 -dcontained 0FATAL EXCEPTIONlines and 0E AndroidRuntimelines. The emulator was stopped withadb emu kill; noqemu-system-aarch64-headlessprocess 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.
GraphPaletteis a curated, fixed palette plus a pure deterministic outcome→index mapping (nohashCode() % 4).errorstays the theme error role andsuccessthe 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:GraphPaletteTestchecks the helper against known reference ratios (white/black 21,#777/white 4.48) and asserts every palette colour is ≥ 4.5:1 againstDarkSurface 0xFF0E1513(measured values range from 8.63:1,approved, to 13.78:1,fast;success11.73:1 anderror10.89:1 as the dark scheme supplies them). - Timeline + visit tabs. The run-detail
Stepstab is renamedTimeline(key keptsteps); 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 sharedStageDetailSheet. The sheet now takes a stage's orderedrunStepsplus aninitialVisitIndexand shows avisit 1..Ntab row only when there is more than one visit; the timeline opens on the tapped visit and the graph on the most recent.runStepFieldsgained 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 flatSurface, thinHorizontalDivider, leading element + title + secondary line, no per-row elevation) instead of a card per item. The selected row uses the same tonalsecondaryContainer/onSecondaryContainertreatment as the tab rail and destinations, exposed asselectableselected 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
NavigationBaris replaced by a floating roundedSurfaceat 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 plusRole.Tabselected 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 inapp/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 → RunningAutoMirrored.DirectionsRun, QueuedSchedule, SucceededCheckCircle, FailedError, CanceledCancel, InterruptedPauseCircle, ActiveBolt, UnknownAutoMirrored.HelpOutline. The debug APK is ~17 MB; note thatapp/build.gradle.ktssetsrelease { isMinifyEnabled = false }, so R8 does not strip unused extended icons in the current release config (that stripping only applies to a minified build). :app:testDebugUnitTestreported 93 tests, 0 failures (newGraphPaletteTest,TimelineTest,PipelinesNavTest; extendedStageDetailSheetTestandDetailTabsTest;StepMetaTestwas removed with the inline metadata grid it covered).:app:assembleDebugsucceeded.- Captures were written with
adb -s emulator-5554 shell screencap -p /sdcard/shot.pngfollowed byadb -s emulator-5554 pull(neverexec-out … >), tocaptures/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 crops16_pill_wide_2x,17_tabs_wide_2x,18_runstatus_icons_2x,18b_failed_status_2x,19_pill_narrow_2x. adb -s emulator-5554 logcat -dcontained 0FATAL EXCEPTIONlines and no Compose runtime exception. The wide layout was exercised withadb shell wm size 2000x3400(≈820dp at density 390); the emulator was stopped withadb emu killpluskill -9of any survivingqemu-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.
RunStepnow models the server'sartifacts(StageArtifact{name, size_bytes, content_type, url}),artifacts_skippedandartifacts_truncatedwith the exactinternal/protocol/runs.gowire names.ui/graph/Artifacts.ktrenders one row per file (name,humanBytessize, content type) with an open (ACTION_VIEW) and a copy-link action, an inline image thumbnail (OkHttp +BitmapFactorywithinSampleSizeoff the main thread, bytes cached once per URL) and a full-size view on tap; other types get a type icon. URLs are resolved byServerUrl.resolveArtifactUrlagainst the configured server URL (ws→http/wss→https,/connectdropped), never a hardcoded host; with no URL configured the actions are disabled and a hint is shown. Empty/partial states reuse the TUI strings frominternal/tui/file_changes.go. The Timeline rows carry a subtleAttachFileindicator (hasArtifacts) with a per-visitcontentDescription. - Collapsed defaults + self-describing titles.
SectionExpansionStatenow 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 byevidenceSectionTitle, e.g.Evidence - step 4, ui_reviewer visit 1, opencode, correlatingSessionEvidence.sequencewith 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
ScaffoldinPipelinesAppnow usescontentWindowInsets = 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 viawindowInsetsPadding(WindowInsets.navigationBars). While the connection banner is visible it owns the status-bar inset (padding inside itsSurface) and theNavHostbelow consumesstatusBarsso the app bar is not double-padded. - APK publish.
:app:assembleDebugproducedapp/build/outputs/apk/debug/app-debug.apk(18,181,943 bytes, sha25641c9df314da40bb19df7e3d90f27a83339a275768cefee537c4ba796efe01eab, 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 touchingandroid/) with a matchingshasum -a 256. At 17.3 MiB it exceeds the 8 MiB per-file inventory cap (internal/server/artifacts.gomaxArtifactFileBytes = 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.kthoists its derivations withremember(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.ArtifactBytesCacheis a byte-boundedLruCache(16 MiB) rather than an unbounded map, so a long session cannot retain every fetched artifact.artifactCaptureNotesreturns no notes for an empty artifact list, matchinginternal/tui/file_changes.goartifactLines(which returns nothing when the list is empty); the empty-state summary is unchanged.- The field-section title fallback is the pure
fieldSectionTitle, covered byTimelineTest#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:testDebugUnitTestreported 103 tests, 0 failures (newProtocolModelTest#runStepArtifactsParseWithExactWireNamesOrAbsent,FormatTestcases forhumanBytes/artifactMetaLine/artifactsSummary/artifactCaptureNotes,ServerUrlTest#resolvesArtifactUrlAgainstTheConfiguredServerUrlandresolveArtifactUrlReturnsNullWhenUnconfiguredOrBlank,DetailTabsTest#sectionsStartCollapsedAndToggleIsRemembered, andTimelineTestcases forhasArtifacts/evidenceSectionTitle/fieldSectionTitle).:app:assembleDebugsucceeded (18,181,943-byte debug APK).:app:lintDebugstill reports the two pre-existingNewApierrors forandroid:windowLightNavigationBar(minSdk 26) inres/values/themes.xmlandres/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 hardcodedlocalhost/10.0.2.2host.curl -IreturnedHTTP/1.1 200 OK,Content-Type: application/vnd.android.package-archive,Content-Length: 18181943; a streamedGETpiped toshasum -a 256returned41c9df314da40bb19df7e3d90f27a83339a275768cefee537c4ba796efe01eab, equal to the localapp-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 thanmaxArtifactFileBytes(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 noSlidingMasterDetail.kt,RightSlidingPanelorModalBottomSheetin 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, theonTogglePaneparameter and the "Collapse list pane"IconButtonon both list top bars,LIST_PANE_WIDTH(360.dp) andCOLLAPSED_LIST_PANE_WIDTH(56.dp), and the observed-side rail collapse (RailToggle,railWidthDp,COLLAPSED_RAIL_WIDTH_DP,WIDE_RAIL_WIDTH_DPcollapse branch, "Collapse tabs") are all gone; the wide rail is always visible as the section index.ui/CollapseRemovalTest.ktscanssrc/main/javafor those identifiers and fails if any return. The old full-screenpipeline/{id}/{version}andrun/{id}routes were removed, sodestinationSelectedis a plain route equality. - One shared host, one slide.
ui/components/SlidingMasterDetail.ktis 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 singleanimateDpAsState(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 ismeasuredWidth - 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 ispeekWidthDp(minimumInteractive, startInset) = maxOf(PEEK_WIDTH_DP, minimumInteractive + startInset), so the tappable strip left after the left system-gesture inset is still at leastLocalMinimumInteractiveComponentSize(48dp). The strip is positioned clear of the status/nav bars and the gesture area by offsetting/sizing it withWindowInsets.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 defaultspring()with no literal). - Sections open to the right.
DetailTabskeeps the index fixed in place and moves the section bodies into aHorizontalPager(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.ktbackStep) 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.PredictiveBackHandlerhandles the gesture;android:enableOnBackInvokedCallback="true"was added to the manifest. - Saved state.
PaneSelection(pane, item id/version, section index) is all primitives with aSaver, so the open pane and selected section survive rotation, configuration change and process death.rememberPagerStatealso saves the pager page. - Secondary surface. The wide stage-detail overlay reuses the same
right-slide (
RightSlidingPanel); on a narrow window it deliberately keeps itsModalBottomSheet(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 inStageDetailSheet.ktare 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:testDebugUnitTestreported 112 tests, 0 failures (newPaneStateTest— pane open,backStepat section > 0 / section 0 / list, section ordering and slide direction,Saverround trip and primitive payload; newCollapseRemovalTest; newSlidingMasterDetailTestforpeekWidthDp;DetailTabsTestupdated andPipelinesNavTestupdated for the removed routes). -
:app:assembleDebugsucceeded.:app:lintDebugstill reports only the two pre-existingNewApierrors forandroid:windowLightNavigationBar(minSdk 26) inres/values/themes.xmlandres/values-night/themes.xml; those files were not modified. -
grepoverapp/src/mainfor 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 dumpshowed 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 densitychange 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 logcatfor the package contained noFATAL EXCEPTIONorAndroidRuntimeerror during the sweep, and no run was started from the app.
- Tapping a pipeline row slid the detail in;
-
:app:testDebugUnitTestand 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) andslide-W5-closed-list(strip tapped again, list restored, byte-identical toslide-W1-list); the narrow window (wm size 1080x2340, ≈524dp) has the same setslide-N1…slide-N5(top tab row,N3graph,N4back to Summary,N5closed, identical toN1). - 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], theplannerheading and theDefinitionsection, dismissed by tapping the strip) and tapping a graph node (W9-graph-stage-overlay).
- The wide sequence was captured to
-
APK publish.
app/build/outputs/apk/debug/app-debug.apk(18,184,868 bytes, sha2567942795c1d979a66e4759a0c3e3f0399d60e256b29ba4a7266dfc52142245ac8) 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 frompython3 scripts/lan-address.py, neverlocalhost/10.0.2.2) returnedHTTP/1.1 200 OK,Content-Type: application/vnd.android.package-archive,Content-Length: 18184868; a streamedGET | shasum -a 256returned7942795c1d979a66e4759a0c3e3f0399d60e256b29ba4a7266dfc52142245ac8, 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.
Pane stack, click-outside back, stage pane and artifacts gallery (15 Oct 2026)
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. ThepaneOffsetDp/peekWidthDphelpers 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.
StageDetailSheetand itsModalBottomSheet/RightSlidingPanelbranches are gone.StageDetailPane(ui/graph/StageDetailPane.kt) is the stage level of the stack, wrapped in the sameScaffold/TopAppBarwith a back arrow as the other panes. Both entry points — a Timeline row and a graph node — now setPaneSelection(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 sharedSectionHeader+rememberSectionExpansion(stageKey).runStepFields,stageDefinitionFields,StageFieldRow,StageTypeChip,controlVisitLabel,numberFields/terminalFieldsand the visit tab row are all kept. - One three-level stack.
ui/components/SlidingPaneStack.ktreplacesSlidingMasterDetail: pane 0 fills the host, panes 1 and 2 overlay it atpaneOffsetDp(level, peek) = peek * levelandpaneWidthDp(hostWidth, level, peek) = hostWidth - peek * level(derived from the one namedPEEK_WIDTH_DPtoken and the measured width; no new offsets). Each covered pane keeps exactly one peek visible and its peek strip is tappable, callingonPopTo(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) andpopTo(selection, level)are the pure model;PaneSelectioncarriesstageKey/stageVisitand its saver encodes six primitives. - Back and the outside tap agree.
PredictiveBackHandleris enabled fordepth >= 1and 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.kthas the purerunArtifactGroups(steps)(grouped by stage then visit fromrunTimeline, stable order, duplicate names kept, empty run → empty) andartifactsEmptyMessage(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,humanBytessize, 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 unchangedArtifacts · N recordedsummary and capture notes. Every url resolves throughServerUrl.resolveArtifactUrl(no hardcoded host), andArtifactImage/ArtifactBytesCacheremain 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:testDebugUnitTestreported 122 tests, 0 failures (rewrittenPaneStateTest— three levels,depth,MAX_PANE_DEPTH,backStepat each level,popTolevels and the six-primitive saver; renamedSlidingPaneStackTest—peekWidthDppluspaneOffsetDp/paneWidthDp; newArtifactGroupsTest— grouping/order, duplicates kept, empty run, visit numbers vsrunTimeline, running-vs-finished empty message;StageDetailSheetTestgained the headline/evidence split assertions).CollapseRemovalTeststill passes.gradle :app:assembleDebugsucceeded (18,198,400 bytes).gradle :app:lintDebugstill reports only the two pre-existingNewApierrors forandroid:windowLightNavigationBarinres/values/themes.xmlandres/values-night/themes.xml.rg -n 'ModalBottomSheet|StageDetailSheet' android/app/src/mainandrg -n 'https?://' android/app/src/main/java/net/awan/pipelines/ui/graphboth return nothing;git diff --statshows no change underandroid/gradleor thebuild.gradle.ktsdependency blocks.- On
emulator-5554(2076x2152, density 390 ≈ 851dp wide; never the attached Pixel) against the live serverws://10.0.0.75:8080/connect(LAN address frompython3 -cimportingscripts/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 1header, then a grid ofPreview of …png); tapping a thumbnail opened the full-size dialog (02_sheet_ui_reviewer_top.png); a non-image row showedEVIDENCE.md,3.0 KiB · text/plain; charset=utf-8,Open/Copyenabled="true". - Tapping the Timeline row
reviewer · visit 1opened the stage pane as level 2 with two peeks visible (Back to runsat[73,165][190,1859],Back to runat[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 nodeStage revieweropened the same pane (Status completed,Outcome success,Visit 2 / 3,Target ui_reviewer). - Tapping the detail peek (
285 1000) → depth 1 (Back to runsonly); tapping the list peek (130 1000) → depth 0 (list, no strips).input keyevent 4at depth 2 → depth 1, at depth 1 → depth 0; the predictive-back swipeinput swipe 5 1000 900 1000 250at depth 2 → depth 1. settings put system user_rotation 1(config change) kept depth 2 and thereviewer/visit 1 selection; afteram kill net.awan.pipelines(verifiedpidofempty) the relaunch restored the same depth and selection.- The stage pane's Artifacts section expanded to
Artifacts · 6 recordedplus the visit's thumbnails; run 60 (executing) showed the run empty stateArtifacts · capture pending. adb logcat -d | grep -c 'FATAL EXCEPTION'and… | grep -c 'E AndroidRuntime'both returned 0; no run was started from the app.
- Summary of run 58 showed the grouped gallery (
- APK publish.
app/build/outputs/apk/debug/app-debug.apkwas copied to…/artifacts/60/2/pipelines-debug-059c85a.apk(059c85a=git log -1 --format=%h -- android/);shasum -a 256matched.curl -I http://10.0.0.75:8080/artifacts/60/2/pipelines-debug-059c85a.apkreturned 200 withContent-Type: application/vnd.android.package-archiveand aContent-Length; a streamedGET | shasum -a 256equalled 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.
Follow-up fix: narrow-window gallery (15 Oct 2026)
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.
ArtifactGallerynow measures the row once withBoxWithConstraintsand calls the pureartifactTileDp(availableWidth, columns, spacing, preferred)(the widest that fits, capped at the preferredARTIFACT_TILE_DP), so three tiles and their gaps always fit the pane. The only new named token isARTIFACT_TILE_SPACING_DP(8.dp), shared by the row arrangement and the fitting; no magic offsets. - Dead code removed.
ArtifactRowno longer carries an unreachable image branch (the gallery passes it only non-image artifacts); it renders the file glyph, name andartifactMetaLinewith open/copy. - No duplicated derivation.
runArtifactGroupsreusesrunTimeline's display visit number (entries→(stage, sequence) → visit) instead of re-derivingcontrol.visit ?: index + 1. - Docs corrected. The current-architecture bullet and the superseded
SlidingMasterDetail/RightSlidingPanel/ModalBottomSheetreferences 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:testDebugUnitTestreported 127 tests, 0 failures, 0 errors (the 5 newArtifactGalleryTestcases included);CollapseRemovalTeststill passes.gradle :app:assembleDebugsucceeded (17,830,569 bytes).gradle :app:lintDebugstill reports only the two pre-existingNewApierrors forandroid:windowLightNavigationBarinres/values/themes.xmlandres/values-night/themes.xml.rg -n 'ModalBottomSheet|StageDetailSheet|RightSlidingPanel|SlidingMasterDetail' android/app/src/mainandrg -n 'https?://' android/app/src/main/java/net/awan/pipelines/ui/graphboth return nothing;git diff --statshows no change underandroid/gradleor thebuild.gradle.ktsdependency blocks.- On
emulator-5554(never the attached Pixel) against the live serverws://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-imageemulator.logrow showed10.8 KiB · text/plain; charset=utf-8with enabledOpen/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 4at depth 2 → depth 1 and at depth 1 → depth 0; the predictive-back swipeinput swipe 5 1000 900 1000 250at depth 2 → depth 1. - A
wm density480 → 440 change kept depth 2 with thereviewervisit-1 selection and the expanded Artifacts section; afteram kill net.awan.pipelines(verifiedpidofempty) and relaunch, the same depth and selection returned. adb -s emulator-5554 logcat -dcontained 0FATAL EXCEPTIONand 0E AndroidRuntimelines; no run was started from the app.
- APK publish.
app/build/outputs/apk/debug/app-debug.apk(17,830,569 bytes, sha2566ac6004e9d4bc29d30457cc99009c226df7157dae2b41f07fa7c8a7a46a40498) was copied to…/artifacts/60/4/pipelines-debug-059c85a.apk(059c85a=git log -1 --format=%h -- android/);shasum -a 256matched.curl -I http://10.0.0.75:8080/artifacts/60/4/pipelines-debug-059c85a.apkreturnedHTTP/1.1 200 OK,Content-Type: application/vnd.android.package-archive,Content-Length: 17830569; a streamedGET | shasum -a 256equalled the local file.
Not verified in this follow-up: a different graph node tapped while the stage pane
is open (the covered graph stays blocked, so the replace-the-rightmost invariant
is covered by the PaneStateTest bound/popTo tests only); the explicit gallery
empty states (the run 60 card already carried artifacts during this sweep, so
neither the "capture pending" nor the finished "no artifacts recorded" message was
seen on device — both are covered by ArtifactGroupsTest/artifactsEmptyMessage);
the unconfigured (disabled open/copy) gallery row; the predictive-back animation
frames and pinch-zoom (adb cannot drive a two-finger pinch).
Adaptive pane navigation and a fixed peek budget (15 Oct 2026)
The pane stack was made adaptive to the window width and its peek space changed
from one peek per level to a single fixed budget shared between the covered
panes. android/ only; nothing in the Pipelines server, its Go source, the
Docker/compose files, the installer or the dependency blocks was touched, no run
was started from the app, and the attached Pixel 10 Pro Fold was never installed
on or driven (the debug APK was installed with adb -s emulator-5554 install -r).
- Narrow windows: no stack, no peek.
SlidingPaneStackgained awideparameter (the callers pass the existingisWideLayoutvalue). On a narrow window the peek budget is0.dp, so every pane's open offset is0and 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 existingspring()slide from the right edge; Back, the predictive-back gesture and the pane's own top-bar back control all run the same one-levelbackStep. - Wide windows: one fixed peek budget. The total space the covered panes
reserve is
PEEK_BUDGET_DP(224.dp, a named token), neverpeek * level, so the stack consumes the same width however deep it gets.paneOpenOffsetsDpplaces the active pane at exactly the budget — its width is thereforehostWidth - budgetat 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 leastPEEK_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) andMIN_ACTIVE_PANE_WIDTH_DP(320.dp) live beside the stack;peekBudgetDpclamps the budget so the active pane never collapses on a small host (hostWidth - MIN_ACTIVE_PANE_WIDTH_DP), andpaneWidthDpis 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:testDebugUnitTestreported 130 tests, 0 failures, 0 errors (the rewrittenSlidingPaneStackTesthas 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:assembleDebugsucceeded (17,990,397-byte debug APK, sha256b7ba9d600031f09472b06fff4c06cd50ec93b995cf7b1f7bf8a2115846a8e602).- On
emulator-5554(2076x2152, density 390 ≈ 852dp wide; never the attached Pixel) against the live serverws://10.0.0.75:8080/connect, driven withadb shell inputanduiautomator dump:- Wide,
uiautomator dumpof 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 at224dpat both depths — its width is constant — and the two covered strips sum to the same224dpbudget. - Narrow (
wm size 1080x1920,wm density 480, ≈360dp): the list, the detail and the stage pane each filled the window (uiautomator dumplisted noBack to …strips at any depth), a row tap opened the detail (Summarytab present) and the predictive-back swipeinput swipe 5 1000 900 1000 250returned to the list. adb -s emulator-5554 logcat -dcontained 0FATAL EXCEPTIONand 0E AndroidRuntimelines 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) andnarrow-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 theSlidingPaneStackTestgeometry cases instead.
- Wide,
- APK publish.
app/build/outputs/apk/debug/app-debug.apkwas copied to…/artifacts/61/1/pipelines-debug-wip-5314542.apk(5314542=git rev-parse --short HEAD);shasum -a 256matched.curl -I http://10.0.0.75:8080/artifacts/61/1/pipelines-debug-wip-5314542.apkreturnedHTTP/1.1 200 OK,Content-Type: application/vnd.android.package-archive,Content-Length: 17990397; a streamedGET | shasum -a 256equalled 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.ktno longer uses aHorizontalPagerfor the section bodies. The selected section cross-fades in place behind aCrossfade(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.Crossfadecomes fromandroidx.compose.animation:animation, already on the compile classpath transitively viaandroidx.compose.foundation(no new dependency was declared;gradle/libs.versions.tomland 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 itsspring()slide; only the section selector inside a detail changed. - The rail's selected state is kept. The narrow
PrimaryScrollableTabRowand the wide selectable rail are unchanged; selection is stillRole.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
LazyColumnscroll) is kept under its stable tab key withrememberSaveableStateHolder().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 existingDetailTabsTeststill covers the tab lists andclampTabIndex).app/build/outputs/apk/debug/app-debug.apkis 17,990,397 bytes, sha256ef467eaafd9cd7662167c17229a39281683aed6c890c48c9fabf0a1e3ed04172.- On
emulator-5554(2076x2152, density 390 ≈ 852dp wide; never the attached Pixel) against the live serverws://10.0.0.75:8080/connect(run 58, seven completed visits), driven withadb shell input:- A 13s
screenrecordof 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
HEADin a throwawaygit worktree, installed as a baseline) recorded asbefore-section-slide.mp4and framebefore-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.pngmatchesscroll-summary-scrolled.png(Finished/Duration/Artifacts still on screen), not the top. adb -s emulator-5554 logcat -dcontained 0FATAL EXCEPTIONand 0E AndroidRuntimelines; no run was started from the app.
- A 13s
- APK publish.
app-debug.apkwas copied to~/.local/share/pipelines/data/artifacts/62/1/pipelines-debug-wip-0b373d0.apk(0b373d0=git rev-parse --short HEAD);shasum -a 256matched.curl -I http://10.0.0.249:8080/artifacts/62/1/pipelines-debug-wip-0b373d0.apk(LAN address fromipconfig getifaddr en0, neverlocalhost/10.0.2.2) returnedHTTP/1.1 200 OK,Content-Type: application/vnd.android.package-archive,Content-Length: 17990397; a streamedGET | shasum -a 256returnedef467eaafd9cd7662167c17229a39281683aed6c890c48c9fabf0a1e3ed04172, 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.ktgained the pureSTAGE_CONFIG_HEADLINE_LABELS({"Model", "Provider"}),stageConfigHeadlineFields(definition)andremainingDefinitionFields(definition).StageDetailBodyrendersheadlineFields(runFields) + stageConfigHeadlineFields(definition)as the headline andremainingDefinitionFields(definition)inside the collapsed Definition section, so a promoted row is never rendered twice. Both derivations areremember(definition)-keyed; the run-evidence split staysrunStepFields/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). StageDetailSheetTestgaineddefinitionModelAndProviderArePromotedToTheHeadlineWithoutDuplicationandaDefinitionWithNoConfigsPromotesNothing.
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.apkis 17,991,256 bytes, sha2562252e6964cd73f1d666da24f3684bd8e0b79cf3e07e0fdc018842a4f1cab2ccf.gradle :app:lintDebugunder JDK 17 fails only on the two pre-existingNewApierrors forandroid:windowLightNavigationBarinres/values/themes.xmlandres/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 serverws://10.0.0.75:8080/connect, driven withadb 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 toArtifacts · 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 2tabs, 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.pngis 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.pngbytes begin with theadb 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.apkwas copied to~/.local/share/pipelines/data/artifacts/64/1/pipelines-debug-wip-791d3dd.apk(791d3dd=git rev-parse --short HEAD);shasum -a 256matched.curl -I http://10.0.0.249:8080/artifacts/64/1/pipelines-debug-wip-791d3dd.apk(LAN address fromipconfig getifaddr en0, neverlocalhost/10.0.2.2) returnedHTTP/1.1 200 OK,Content-Type: application/vnd.android.package-archive,Content-Length: 17991256; a streamedGET | shasum -a 256returned2252e6964cd73f1d666da24f3684bd8e0b79cf3e07e0fdc018842a4f1cab2ccf, equal to the local file.
Not verified in this pass: the reported "content lost" symptom could not be
reproduced at 791d3dd, so there is no before/after diff of a fixed regression;
the "definition-only, never-visited stage" and blank status/outcome edge cases are
covered by the existing unit tests (StageDetailSheetTest, FormatTest) rather than
driven on the device; the narrow/wide gallery thumbnail failure for run 60's corrupt
artifacts is a data issue in that run, not re-tested against a repaired copy.
Covered panes show a compact identity, with a minimum peek width (16 Oct 2026)
A wide-window stack no longer squeezes a full pane into each covered peek: a
covered pane now renders only its compact identity (a title and at most one
status/subtitle, centred in its strip) and its full body — tab rail, list,
gallery, scroll body — is never drawn into a sliver. android/ only; nothing in
the Pipelines server, its Go source, the Docker/compose files or the installer was
touched, no dependency was added, no run was started from the app, and the
attached Pixel 10 Pro Fold was never installed on or driven (the debug APK was
installed with adb -s emulator-5554 install -r).
- Compact covered panes.
SlidingPaneStack'spanelambda now receives acovered: Boolean; on a wide window a covered level is composed inside a box constrained to its visible strip, and the caller renders onlyui/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 acoveredbranch 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.peekStripsDpshows at mostbudget / MIN_COVERED_PANE_WIDTH_DPcovered 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:testDebugUnitTestreported 134 tests, 0 failures, 0 errors;gradle :app:assembleDebugsucceeded (17,992,288-byte debug APK, sha2563923224136be7ef9bdd8eb87111fae1f6af0211a7ba070af0e5270e324a0fc93). The rewrittenSlidingPaneStackTesthas 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 serverws://10.0.2.2:8080/connect, driven withadb shell inputanduiautomator dump:- Wide,
uiautomator dumpof 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 at224dp(constant width) and each covered pane now keeps at least112dpfor its identity. - Narrowest wide size (
wm size 1463x2152, density 390 = 600dp): the same224dpbudget, 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 (onlyBack to pipelinesleft); tapping the list peek (173 1000) popped to the list (no strips).input keyevent 4at depth 2 returned to depth 1 (oneBack to pipelinesstrip). - Narrow (
wm size 1080x1920,wm density 480, ≈360dp): opening a pipeline showed 0Back to …strips and the detail tabs as before. adb -s emulator-5554 logcat -dcontained 0FATAL EXCEPTION; no run was started from the app.- Screenshots were written to the run's artifacts directory:
wide-2-levels.png(the list covered asPipelines · 11 on this server),wide-3-levels.png(list and detail covered, stage active) andwide-narrowest.png(600dp);wide-2-levels-after-peek.pngis the state after the peek tap.
- Wide,
- APK publish.
app/build/outputs/apk/debug/app-debug.apkwas copied to…/artifacts/65/1/pipelines-debug-wip-206953e.apk(206953e=git rev-parse --short HEAD);shasum -a 256matched.curl -I http://10.0.0.249:8080/artifacts/65/1/pipelines-debug-wip-206953e.apk(LAN address fromipconfig getifaddr en0) returnedHTTP/1.1 200 OK,Content-Type: application/vnd.android.package-archive,Content-Length: 17992288; a streamedGET | shasum -a 256equalled 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.
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.ktrendersheadlineFields(Status, Outcome, Duration, Visit, Target, Model target — the run-side facts) immediately, then the run-side result sections inSTAGE_RESULT_SECTIONSorder:Artifacts(the per-visit gallery, first, per the operator's earlier "artifacts at the top" preference),Output,Input, then the remaining evidence underThis run. Each is collapsed by default via the unchangedSectionHeader/rememberSectionExpansion, and a new privateStageSectionrenders them all through one header+content helper. - One collapsed definition. The previous Model/Provider headline promotion is
reverted:
STAGE_CONFIG_HEADLINE_LABELS,stageConfigHeadlineFieldsandremainingDefinitionFieldsare gone, and the fullstageDefinitionFields(type, prompt, output contract, outcomes, model, provider, configs, tools, limits, memory, notify) renders in the singleStage definitionsection (STAGE_DEFINITION_KEY/STAGE_DEFINITION_TITLE). Nothing visible before is removed — Model/Provider are reachable by expanding the section. - Run vs. definition-only.
StageDetailPanegainedrunContext(default false);RunStagePanepassestrue(Timeline, run graph and run stage list all go through it),PipelineStagePaneleaves itfalse. The puredefinitionStartsExpanded(runContext)seeds the section's default: collapsed in a run pane, expanded in a pipeline stage pane, where the definition is the only content.rememberSectionExpansiongained aninitiallyExpandedset (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.StageDetailSheetTestdropped the two promotion tests and gainedtheRunHeadlineIsRunSideOnlyAndTheDefinitionKeepsModelAndProvider,theDefinitionStartsExpandedOnlyWithoutARunContextandtheRunResultSectionsLeadWithTheArtifactsGallery(12 cases, 0 failures).app/build/outputs/apk/debug/app-debug.apkis 18,011,770 bytes, sha2561ba2119ad2e2c34b0928460036bdda7b02e2b4d819be2c68d225dd9b072611b8.gradle :app:lintDebugunder JDK 17 fails only on the two pre-existingNewApierrors forandroid:windowLightNavigationBarinres/values/themes.xmlandres/values-night/themes.xml(unchanged by this pass).- On
emulator-5554(narrowwm size 1080x1920/wm density 480≈ 360dp; widewm size reset/wm density reset= 2076x2152 / 390 ≈ 852dp; never the attached Pixel) against the live serverws://10.0.2.2:8080/connect, driven withadb shell inputanduiautomator dump; run 60'simplementer(two visits) and pipeline 11 v1'simplementer:narrow_timeline_top.png/narrow_timeline_sections.pngandwide_timeline_stage.png: theimplementerpane opened from the Timeline rowimplementer · visit 2— title,modelchip,visit 1/visit 2tabs, Status/Outcome/Duration/Visit/Target, thenArtifacts,Output,Input,This run,Stage definition(all collapsed) in that order.narrow_graph_top.png/narrow_graph_sections.pngandwide_graph_stage.png: the same pane opened by tapping theimplementergraph node (starts on visit 2), identical ordering.wide_pipeline_stage_definition.png: pipeline 11 v1'simplementeropened from the pipeline graph — no visit tabs and no run sections,Stage definitionexpanded with Type/Prompt/Output, because a pipeline stage has no run.narrow_run_definition_model_provider.png: the run pane'sStage definitionexpanded to Typemodel, Prompt, Outcomes, Modeldeepseek-v4.1-flash, Provideropencode-go, Retries, Timeout, Tools, Memory — nothing removed.narrow_run_artifacts_gallery.png: theArtifactssection (the first result):Artifacts · 47 recorded · partial captureand the thumbnail grid. (Run 60's own artifact files are the corruptadb screencapcaptures 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 …(--checkre-validated all eight).adb -s emulator-5554 logcat -dcontained 0FATAL EXCEPTION, 0E AndroidRuntimeand noE-levelnet.awan.pipelinesline; no run was started from the app. Screenshots and the rawuiautomatordumps are in~/.local/share/pipelines/data/artifacts/68/2/.
- APK publish.
app/build/outputs/apk/debug/app-debug.apkwas 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 256matched.curl -I http://10.0.0.249:8080/artifacts/68/1/pipelines-debug-wip-cd85f69.apk(LAN address fromipconfig getifaddr en0) returnedHTTP/1.1 200 OK,Content-Type: application/vnd.android.package-archive,Content-Length: 18011770; a streamedGET | shasum -a 256returned1ba2119ad2e2c34b0928460036bdda7b02e2b4d819be2c68d225dd9b072611b8, 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.
StageDetailPanegives the pane the theme'ssurfaceContainerrole through a singlepaneContainerColor()used by all of the pane's own surfaces: theScaffoldcontainer, theTopAppBar, the visitPrimaryScrollableTabRowand every section header (StageSectionpasses it to the sharedSectionHeader, which gained acontainerColorparameter defaulting to the previousbackground). The pane therefore fully covers the area it occupies — including under a section header — as one tone, and sits a clear step above thebackgroundpeeks and above the content it covers on a narrow window. The covered pane's peek is unchanged and still expected.CodeBlockand the artifactsArtifactRowmoved fromsurfaceContainertosurfaceContainerHigh(the full-size artifact dialog tosurfaceContainerHighest), so a card stays a visible card on both the app background and a pane'ssurfaceContainersheet. 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.apkis 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 theimplementerpane opened over run 69's Graph tab and over its Timeline tab is a solidsurfaceContainersheet starting at the fixed peek budget, clearly lighter than theRuns/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, thePrompt/Transcriptcode 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), sha25667f5223bd8f1c5ce8939ea786b62a222cdb5e59763d8bf3fd636ba5d52b6985e.curl -I http://10.0.0.249:8080/artifacts/71/1/pipelines-debug-wip-cfd5887.apkreturnedHTTP/1.1 200 OK,Content-Type: application/vnd.android.package-archive,Content-Length: 18012281; a streamedGET | shasum -a 256returned 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.apkis 17,846,953 bytes, sha256d47c5bf993ca28293b188829c7fd5eec709fac49f04cca520377df96d393c887.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.pngandpane-opaque-narrow-over-graph.png/pane-opaque-narrow-over-timeline.png: theimplementerpane opened over run 72's Graph and Timeline is one opaquesurfaceContainersheet — 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 -dcontained 0FATAL EXCEPTION/E AndroidRuntimelines 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.apkreturnedHTTP/1.1 200 OK,Content-Type: application/vnd.android.package-archive,Content-Length: 17846953; a streamedGET | shasum -a 256returned the samed47c5bf…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 --offlinere-ran all 18 result XMLs to 137 tests, 0 failures, 0 errors, 0 skipped. The freshapp-debug.apkis 17,846,953 bytes, sha2568ff68d24…— the same size but a different hash fromd47c5bf…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) andpane-opaque-narrow-over-graph.png/pane-opaque-narrow-over-timeline.png(wm size 1080x1920,wm density 480≈ 360dp): run 76's runningimplementerpane is one solidsurfaceContainersheet, 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 -dheld 0FATAL EXCEPTION/E AndroidRuntimelines;wm size/densitywere 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 streamedshasum -a 256both return8ff68d24….curl -I http://10.0.0.249:8080/artifacts/77/1/pipelines-debug-wip-1fece88.apkreturnedHTTP/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.
SlidingPaneStacknow slides every pane with one shared spec (paneSlideSpec): a fixedPANE_SLIDE_MILLIS(300) duration and a symmetricPANE_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 newrememberPaneContent(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,
paneSlideDelayMilliswaitsPANE_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 --offlinere-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>theninput keyevent KEYCODE_BACKon run 80's Timeline, captured withscreenrecordand split intoopen-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 inmulti-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 atx=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/densityreset 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 -dheld 0FATAL EXCEPTION/E AndroidRuntimelines;animator_duration_scalewas left at 1.- APK publish.
app-debug.apk(18,012,493 bytes, sha256d1c5506f…) 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.apkreturnedHTTP/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.
rememberPaneContentnow 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 --offlinere-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.pngputs the review's emptypl-pop-090.png(left) beside a frame of this build (right); every frame inmulti-level-pop-pipelines-sheet.pngshows the closing stage pane still renderingimplementer/model/Stage definitionwith its Prompt, instead of the emptyterminalstate. - 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), sorunIdis 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 -dheld 0FATAL EXCEPTION/E AndroidRuntimelines;animator_duration_scalewas left at 1.- APK publish.
app-debug.apk(18,012,767 bytes, sha256b3b7d948…) 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.apkreturnedHTTP/1.1 200 OK,Content-Type: application/vnd.android.package-archive,Content-Length: 18012767; a streamedGET | shasum -a 256returned the sameb3b7d948….
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:
SlidingPaneStackreads it (unioned withsystemGestures) 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 itsTopAppBar(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 toSettingsScreen. - No inset is applied twice: while the connection banner is shown it owns the top
inset and the
NavHostconsumespaneSafeArea().only(Top)(wasstatusBars), so the pane's app bar directly below the banner is not padded a second time. - The search field lives inside the pane's
Scaffoldcontent, so it is already inside the safe area; a future floating overlay must read the samepaneSafeArea(). - 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.apkis 18,029,402 bytes, sha25645c1bd09b9622dfe023ff62129a80c44b060bf7c15963757e3f1a5dfa5f851fb.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 84implementerstage 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 -dheld 0FATAL EXCEPTION/E AndroidRuntimelines;wm sizewas 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.apkreturnedHTTP/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.ktrenders a scrim-backed full-screenDialog(usePlatformDefaultWidth = false,decorFitsSystemWindows = false); aSideEffectstretches the dialog window toMATCH_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-appliespaneSafeArea()(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 windowconfirms 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 pureclampImageOffsetso 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: 0Close viewernodes and the run detail still shown after Back). The image loads through the existing cached, off-main-threadrememberArtifactBitmap(nowinternal, 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 lightinverseSurfacerole, which contrasts with the always-black scrim (the previousinverseOnSurfacewas a dark colour on the scrim, measured ~1.6:1). - Pure helpers.
fitImageSize,clampImageOffsetandtoggleZoomScaleinArtifactViewer.kt;ArtifactViewerTestcovers them (fitting, centre/edge clamping, the toggle, and an anchored-zoom-then-clamp invariant).zoomAboutand 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 newArtifactViewerTest).app/build/outputs/apk/debug/app-debug.apkis 18,043,579 bytes, sha2561b3653dbdce9d62fc8dcfdcb986635829b70db38437d6769c77f91d16b7d6b3a.gradle :app:lintDebug→ only the two pre-existingwindowLightNavigationBarNewApi errors (values/themes.xml,values-night/themes.xml); no new lint finding is attributed toArtifactViewer.kt(39 warnings, down from 40 once the cutout constant was API-guarded).- On
emulator-5554against the live server, the run 90 summary artifacts grid was opened andcaptures/viewer/(git-ignored, every PNG validated byscripts/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.pngandviewer_gestures.mp4(29 s). Pairwise pixel diffs (captures/imgdiff.py): open→double-tap 19.72, double-tap→pinch 6.72, pinch→pan 5.29, and05_clamp_1→20.75 →05_clamp_2→30.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 0Close viewernodes and the run detail is shown; a single tap leaves the viewer open (diff 0.02).Loading image…andCouldn't load image.were produced against a hanging and a 404 endpoint. adb shell inputcannot synthesise a two-finger pinch (it injects one pointer) and the shell cannot write/dev/input(sendeventis permission-denied on this production image), so pinch and the timed double-tap were driven with a test-onlyapp_processinjector (captures/viewer/tools/Injector.java→Injector.jar) that injects multi-pointerMotionEvents via the hiddenInputManager.injectInputEvent, the same mechanism the platforminputcommand uses. It is verification tooling only, not part of the app or its dependencies.adb -s emulator-5554 logcat -dheld 0FATAL EXCEPTION/ 0E AndroidRuntimelines.- 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.apkreturnedHTTP/1.1 200 OK,Content-Type: application/vnd.android.package-archive,Content-Length: 18043579, and a streamedGET | shasum -a 256equalled the local file's1b3653db…. 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 areArtifactSharingTest(file/link fallback decision, artifact-to-file naming: content-type/url extension, suffix de-duplication, path sanitisation, per-url distinctness, andshareMimeType).gradle :app:assembleDebug→ succeeded,app-debug.apk18,283,787 bytes, sha25652ad15a6….- On
emulator-5554(density 390) against the live server, run 91's summary: the uiautomator dump shows a clickable share node of117x117px= 48dp with aShare …content description beside every preview; the grid and the.mp4row were captured (validated byscripts/capture_png.sh -s emulator-5554) togrid_cell_share.pngandlist_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.mp4row's share resolved toclip={video/mp4 …}; the cached files areviewer_01_viewer_open_2f01f94a.pngandviewer_viewer_gestures_8e1a3ba4.mp4undercache/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 resolvedhttp://10.0.2.2:8080/artifacts/91/1/viewer/viewer_gestures.mp4as text (share_fallback_link.png);adb logcat -dheld 0FATAL 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), sha25652ad15a6…;curl -I http://10.0.0.75:8080/artifacts/94/1/pipelines-debug-wip-d339827.apkreturnedHTTP/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.75isscripts/lan-address.py's output;10.0.0.249served 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 immutableArtifactSelectionkeyed 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(alistSaver) +rememberArtifactSelectionsave/restore it across configuration and reseed per run/visit. - Action bar.
ArtifactSelectionBaris the pane'sTopAppBar(it replaces the normal bar while selecting): titleN selected, a close, a copy and a share, all Material 3IconButtons (the measured 117x117 px = 48dp targets) with accurate descriptions ("Exit selection", "Copy selected links", "Share selected artifacts"). It applies the samepaneSafeArea()top/horizontal insets as the bar it replaces, so it stays inside the status bar/cutout and above — never over — the items. - Copy links.
artifactSelectionLinksresolves each selected url against the configured server through the existingresolvedArtifactUrl(no hardcoded host), joins one resolved absolute link per line, and copies it through the new one-linecomponents/Clipboard.copyText(the single copy path, now also used by the code blocks, the pipeline source, the artifact row and the viewer). ASnackbarconfirmsCopied N links. Back leaves selection mode first (a pane-scopedBackHandler), only then runs the pane's own Back. - Bulk share.
shareArtifactsfetches every selected artifact through the existingAppViewModel.fetchArtifactBytesand reuses the single-itemwriteSharedArtifact(same bounded cache, sameFileProvider, samepruneSharedArtifacts) before oneIntent.ACTION_SEND_MULTIPLEcarrying every uri. Its type is the new purebulkShareMimeType(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 astext/plain(shareLinks). No parallel share path and no new dependency (icons come from the declaredmaterial-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 newArtifactSharingTestcases (shareTargetsresolution/drop,bulkShareMimeTypecommon-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 newArtifactSelectionTestplus the two bulk-share cases).app-debug.apkis 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-existingwindowLightNavigationBarNewApi 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" onStageDetailPane.- On
emulator-5554(never the physical Pixel, neveremulator-5556; 2076x2152, density 390) against the live server, run 94's summary and per-visit list were driven. Every capture is incaptures/selection/(git-ignored) and was validated byscripts/capture_png.sh -s emulator-5554:01_longpress_selection.png— long-press ongrid_cell_share.pngentered the mode: the action bar reads1 selectedand 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 thesecondaryContainer/onSecondaryContainertreatment.03_bulk_copy_confirmation.png— Copy links showed theCopied 4 linksSnackbar; 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— withcmd connectivity airplane-mode enable(10.0.2.2 unreachable) the same Share fell back in one action totext/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— afteruser_rotation 1(2152x2076) the2 selectedselection 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 -dheld 0FATAL EXCEPTION/ 0E AndroidRuntime.
- APK publish.
app-debug.apkcopied to~/.local/share/pipelines/data/artifacts/97/1/pipelines-debug-wip-1195535.apk(1195535=git rev-parse --short HEAD);curl -I/-oagainsthttp://10.0.0.249:8080/artifacts/97/1/pipelines-debug-wip-1195535.apk(and10.0.0.75) returnedHTTP 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 (ArtifactSelectionTestgrew to 9 withresolvedSelectionKeepsOnlyTheCandidatesStillSelected).app-debug.apkis 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 byscripts/capture_png.sh -s emulator-5554and kept incaptures/selection-run100-final/and~/.local/share/pipelines/data/artifacts/100/1/:01_longpress_selection.png— long-press ongrid_cell_share.pngentered the mode: bar reads1 selected, the cell wears the tonal ring + check, and every per-itemShare/Open/Copy linknode is gone from theuiautomatordump.02_several_toggled.png— three cells then thelint-results-debug.txtrow toggled on → the action bar reads4 selected; the two action-barIconButtons 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 theCopied 4 linksSnackbar, 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. oneACTION_SEND_MULTIPLEcarrying 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 unchangedshareLinksfallback (unit-covered byshareDeliveryIsAFileOnlyWhenTheFetchReturnedBytes) 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 94still present);adb -s emulator-5554 logcat -dheld 0FATAL EXCEPTION/ 0E AndroidRuntime.
-
APK publish.
app-debug.apkcopied to~/.local/share/pipelines/data/artifacts/100/1/pipelines-debug-wip-1195535.apk(1195535=git rev-parse --short HEAD);curlagainsthttp://10.0.0.249:8080/artifacts/100/1/pipelines-debug-wip-1195535.apk(and10.0.0.75) returnedHTTP 200,Content-Type: application/vnd.android.package-archive, 17,913,089 bytes. -
Doc-accuracy pass (16 Oct 2026). The
ArtifactSelection.ktdoc 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, becauseresolvedSelectionfilters 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.apkis 17,913,089 bytes, sha256a6d5caeb0c1e69da879aabfcc7df2eec09e4a44c85000adba3444558a1d3d82b. 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 toArtifactSelection.ktleft onlyclasses6.dexdifferent) — so run 100's build read763806783f…. The APK was published to~/.local/share/pipelines/data/artifacts/100/3/pipelines-debug-wip-1195535.apk;curlagainsthttp://10.0.0.75:8080/artifacts/100/3/pipelines-debug-wip-1195535.apk(and10.0.0.249) returnedHTTP 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 inSlidingPaneStack.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) andMotionStandard(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 theMAX_MOTION_MILLIS(300ms) cap and both easings are monotonic ease-in-out curves;MotionStandardis symmetric, which is what keeps a pane close the exact reverse of its open. A call site asks a token for its concrete spec viaspec(); it never writes a duration. The pane slide, the sectionCrossfadeand the chevron now use the tokens (PANE_SLIDE_*/SECTION_SWAP_MILLISare gone), and the pane pop stagger moved in asMOTION_STAGGER_MILLIS. - Per-item list animation. A single shared
LazyItemScope.animateListItem()(ListRow.kt) wraps Compose's supportedModifier.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_HOMEset) →BUILD SUCCESSFUL.gradle :app:testDebugUnitTest --rerun-tasks --offlinere-ran every result XML to 174 tests across 22 classes, 0 failures, 0 errors, 0 skipped; the newMotionTest(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 monotonic0→1, thatMotionStandardreverses itself, and that a spec carries its token's timing.SlidingPaneStackTestnow reads the pane's timing from the token.- Filter change (
filter.mp4, framessheet1.png/sheet2.png): atanimator_duration_scale 5, typingdockerinto 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, framesnewrun_arrival.png/newrun_sheet1.png): run 105 was admitted out-of-band withpipelines 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 returnedblocked), so nothing had to be reclaimed. - Reduced motion (
red_sheet.png): atanimator_duration_scale 0, typingd/do/doc/dockleaves 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 -dheld 0FATAL EXCEPTION/ 0E AndroidRuntimelines;animator_duration_scalewas left at 1.- APK publish.
app-debug.apk(17,913,089 bytes, sha2564bc1b781…) 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.apkreturnedHTTP/1.1 200 OK,Content-Type: application/vnd.android.package-archive,Content-Length: 17913089, and a streamedcurl | shasum -a 256returned the same4bc1b781….
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.
LoadPhaseis 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)anddetailLoadPhase(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 onContent(the screen shows the error inline), exactly as before — only the presentation changed.StateCrossfade(phase)wraps the branch in aCrossfadewithMotionStandard.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 toPipelineListScreen,RunHistoryScreen,PipelineDetailScreenandRunDetailScreen.LoadingState,ErrorStateandEmptyStatethemselves 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 existinganimateListItem(), 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-tasksre-ran all 23 result XMLs to 184 tests, 0 failures, 0 errors, 0 skipped (up from 174; the newLoadPhaseTestadds 10 pure cases for the classifiers and the message-carrying phases).app/build/outputs/apk/debug/app-debug.apkis 17,913,089 bytes, sha256e99bb970….- On
emulator-5554only (fold AVD, 2076x2152 / 390dpi; never the attached Pixel, neveremulator-5556), against the live server, each frame captured and validated withscripts/capture_png.sh -s emulator-5554,animator_duration_scaleused 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 showsLoading pipeline…and the summary then fades in;load-to-content-10x-overlap.pngfreezes 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): typingzzzinto the pipelines search makesNo 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) anddisabled-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.
- Loading → content at
adb -s emulator-5554 logcat -dheld 0FATAL EXCEPTION/ 0E AndroidRuntimelines;animator_duration_scalewas left at 1; no run was started from the app.- APK publish.
app-debug.apkcopied 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), sha256e99bb970….curl http://10.0.0.75:8080/artifacts/106/1/pipelines-debug-wip-934994d.apkreturnedHTTP/1.1 200 OK,Content-Type: application/vnd.android.package-archive,Content-Length: 17913089, and a streamedGET | shasum -a 256returned the samee99bb970…(10.0.0.249served 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 puredestinationIndicatorOffsetDp, 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
ListRowanimates its tonal container and content colour underMotionQuickinstead of switching, so selecting a pipeline/run row fades thesecondaryContainerhighlight 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 inAnimatedVisibilitywithexpandVertically/shrinkVertically+ fade underMotionQuick— the same token theSectionHeaderchevron turns with — so the content and the chevron move together. BothcollapsibleSection(the lazy variant) and the stage pane'sStageSectionuse it; collapsed, the body is not composed, so a resting section is unchanged. (The section switch was already an in-placeCrossfadewith no lateral motion and is unchanged.) - A live run's status change animates.
StatusChipeases its container and label colour underMotionQuickandRunStatusIconeases 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 --offlinere-ran every result XML to 186 tests across 23 classes, 0 failures, 0 errors, 0 skipped. The newPipelinesNavTestcases 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 leavespill_0on Pipelines,pill_1freezes the highlight between the two icons, andpill_5settles under Runs. - Section collapsing at
animator_duration_scale 15(sec2_expand_3.png,sec2_collapse_2.png): the Input tab'spromptsection expands with the code block revealing under a down chevron, and collapses with the block clipped and the followingpwdheader rising as the chevron returns. - Live status change (
status3_post_01/02/03.png): run 112 was started out-of-band withpipelines run … --pipeline 1 --prompt "… sleep 45 …"(not from the app) and watched in its open detail; its summary chip goes fromrunning(status3_post_01) through the mid-transition tint (status3_post_02) tosucceeded(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 -dheld 0FATAL EXCEPTION/ 0E AndroidRuntimelines;animator_duration_scalewas left at 1.- APK publish.
app-debug.apk(18,133,184 bytes, sha256567c437d…) 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.apkreturnedHTTP/1.1 200 OK,Content-Type: application/vnd.android.package-archive,Content-Length: 18133184, and a streamedcurl | shasum -a 256returned the same567c437d….
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.ktis the single source of truth for app geometry, alongsideTypography.ktfor 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(fromSlidingPaneStack.kt),DESTINATION_PILL_RESERVE(fromPipelinesApp.kt),WIDE_RAIL_WIDTH_DPandDETAIL_MAX_WIDTH_DP(fromDetailTabs.kt). The removedLIST_PANE_WIDTH,COLLAPSED_LIST_PANE_WIDTHandCOLLAPSED_RAIL_WIDTH_DPno longer exist, so there was nothing to move for the "list pane width" or the rail's collapsed width; the collapsed strip that survives isPEEK_WIDTH_DP. Call sites import the tokens; their values (56/224/320/112/88/200/840) are unchanged.ui/theme/DimensTest.ktscans the app's Kotlin sources (src/main/java, excludingDimens.kt) for rawdp/spliterals, 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 thesptypography values owned byTypography.kt). A literal that is neither a token nor allow-listed fails withfile: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-tasksre-ran all 24 result XMLs to 188 tests, 0 failures, 0 errors, 0 skipped (up from 186/23; the newDimensTestaddsrawDimensionLiteralsAreTokensOrReasonedAllowListEntriesandeveryAllowListEntryHasAWrittenReason).app/build/outputs/apk/debug/app-debug.apkis 17,929,473 bytes, sha256e52ceb25….- Enforcement proof. Adding
private val PROBE_RAW_LITERAL = 123.dptoui/PipelinesApp.ktmadegradle :app:testDebugUnitTest --tests net.awan.pipelines.ui.theme.DimensTestFAILEDwithraw 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 taskBUILD SUCCESSFUL. The probe was reverted. - Before/after screenshots on
emulator-5554only (fold AVD, 2076x2152 / 390dpi; never the attached Pixel, neveremulator-5556), against the live server, each frame captured and validated withscripts/capture_png.sh -s emulator-5554: the before APK was built from HEADd019213(android changes stashed, built, then restored) and the after APK from the working tree, each installed withadb -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.pyreports([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 -dheld 0FATAL EXCEPTION/ 0E AndroidRuntimelines;animator_duration_scalewas left at 1; no run was started from the app.- APK publish.
app-debug.apkcopied 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), sha256e52ceb25….curl -I http://10.0.0.249:8080/artifacts/116/1/pipelines-debug-wip-d019213.apkreturnedHTTP/1.1 200 OK,Content-Type: application/vnd.android.package-archive,Content-Length: 17929473, and a streamedGET | shasum -a 256returned the samee52ceb25….
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/XLtokens (andSPACING_XXSfor the 2dp chip gaps); no value changed. The 10dp dense row padding, the 2dp progress hairline and the0.dpelevations stay as reasoned allow-list entries because they are not on the spacing scale. - Glyph sizes. Four new tokens in
ui/theme/Dimens.ktname the icon sizes that cannot derive from layout:ICON_STATUS_DP(14dp),ICON_INLINE_DP(18dp),ICON_LIST_DP(20dp) andICON_RAIL_DP(24dp), used byRunStatus,CodeBlock,RunHistoryScreen,RunDetailScreen,PipelineDetailScreenandDetailTabs. - The allow-list shrinks.
ui/theme/DimensTest.kt's allow-list drops from 30 to 24 entries:14.dp,18.dpand20.dpare gone because their last call site migrated, and the already-unused32.dp,11.spand13.spentries 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 thesptype values owned byTypography.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-tasksre-ran all 30 result XMLs to 259 tests, 0 failures, 0 errors, 0 skipped.app/build/outputs/apk/debug/app-debug.apkis 17,995,009 bytes, sha256d40d7b78….- Allow-list shrinks.
git show HEAD:…DimensTest.ktcounts 30 entries; the working tree counts 24 (14.dp,18.dp,20.dp,32.dp,11.sp,13.spgone, the rest re-reasoned). - Enforcement proof. Appending
private val PROBE_RAW_LITERAL = 123.dptoui/components/ListRow.ktmadegradle :app:testDebugUnitTest --tests net.awan.pipelines.ui.theme.DimensTestFAILEDwithraw 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-5554only (fold AVD, 2076x2152 / 390dpi, dark mode; narrow 1080x2340 and wide 2000x3400 viawm size; neveremulator-5556or the attached Pixel), against the live server atws://10.0.2.2:8080/connect, each frame captured and validated withscripts/capture_png.sh -s emulator-5554. The before APK was built from HEAD8e49a0c(sha256e50bb381…) with the working changes stashed; the after APK from the working tree (sha256d40d7b78…). Every converted screen was captured at both widths (Pipelines list, Runs list, pipeline detail, run detail):geom-<screen>-<width>-before.png/-after.pngin~/.local/share/pipelines/data/artifacts/122/1/.captures/imgdiff.pyreports 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 -dheld 0FATAL EXCEPTION/ 0E AndroidRuntimelines;animator_duration_scalewas left at 1; no run was started from the app.- APK publish.
app-debug.apkcopied 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), sha256d40d7b78….curl -I http://10.0.0.249:8080/artifacts/122/1/pipelines-debug-wip-8e49a0c.apkreturnedHTTP/1.1 200 OK,Content-Type: application/vnd.android.package-archive,Content-Length: 17995009, and a streamedGET | shasum -a 256returned the samed40d7b78….
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 structural0.dprecorded 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'sGRAPH_LEGEND_PAD_X(6dp),GRAPH_LEGEND_PAD_Y(3dp) andGRAPH_LEGEND_GAP(10dp); the collapsedGRAPH_PANEL_MIN_HEIGHT(320dp, moved offWorkflowGraph.ktand now imported by its test); the gallery'sARTIFACT_TILE_DP(96dp),ARTIFACT_THUMB_DP(56dp),ARTIFACT_BADGE_DP(16dp),ARTIFACT_PROGRESS_DP(24dp) andARTIFACT_PROGRESS_STROKE_DP(2dp); and the stage-type chip'sSTAGE_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.dpand96.dpare 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 thesptype values owned byTypography.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-tasksre-ran all 30 result XMLs to 259 tests, 0 failures, 0 errors, 0 skipped.app/build/outputs/apk/debug/app-debug.apkis 17,995,009 bytes, sha256c5da095aec8a01120d4d847da69f71fa2fe0f937290f3c9a5190a9de8b813b0f.- Allow-list shrinks.
git show HEAD:…DimensTest.ktcounts 24 entries; the working tree counts 21. - Enforcement proof. Appending
private val PROBE_RAW_LITERAL = 123.dptoui/graph/Artifacts.ktmadegradle :app:testDebugUnitTest --tests net.awan.pipelines.ui.theme.DimensTestFAILEDwithraw 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 taskBUILD SUCCESSFUL. The probe was reverted. - Before/after screenshots on
emulator-5554only (fold AVD, 2076x2152 / 390dpi; narrow 1080x2340 and wide 2000x3400 viawm size; neveremulator-5556or the attached Pixel), against the live server atws://10.0.2.2:8080/connect, each frame captured and validated withscripts/capture_png.sh -s emulator-5554. The before APK was built from agit archive HEADtree (3765fdf, sha256d40d7b78…, byte-identical to the previous item's published APK); the after APK from the working tree (sha256c5da095a…). Three surfaces were captured at both widths — the Pipelines list (the panes), the "Friend demo" pipeline Graph tab, and the opened stage detail sheet — asgraph-*,sheet-*andlist-{narrow,wide}-{before,after}.pngin~/.local/share/pipelines/data/artifacts/125/1/.captures/imgdiff.pyreports a mean channel difference of0.0for the wide sheet,0.01for the wide/narrow graph and the wide list, and0.03for 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 -dheld 0FATAL EXCEPTION/ 0E AndroidRuntimelines;animator_duration_scalewas left at 1; no run was started from the app.- APK publish.
app-debug.apkcopied 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), sha256c5da095a….curl -I http://10.0.0.249:8080/artifacts/125/1/pipelines-debug-wip-3765fdf.apkreturnedHTTP/1.1 200 OK,Content-Type: application/vnd.android.package-archive,Content-Length: 17995009, and a streamedGET | shasum -a 256returned the samec5da095a….
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.ktdefines oneEntry(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.runStateColoris now a pure function over this palette (noMaterialTheme), 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.
GraphPaletteand the terminalsuccess/errorroles are untouched; run status and stage outcome stay different vocabularies. The runs-list Timeline step chips (and their leading glyphs) previously rendered throughrunStateOf/StatusChip, i.e. the run-status mapping, so they were pointed at the graph's outcome palette instead: they now call the sharedgraphColors(scheme)factory (extracted fromWorkflowGraph, which uses it too) andoutcomeColor, 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.ktgainedColoredChip(label, colour, icon, …)— the single pill layout now used by bothStatusChip(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:testDebugUnitTestreported 143 tests, 0 failures, 0 errors (newRunStatusPaletteTest: WCAG-AA contrast ≥ 4.5:1 for every status colour againstDarkSurface 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:assembleDebugsucceeded (18,009,527-byte debug APK, sha25617f52f23e40f4ba0c524ac2929adfd6a8f39353e68ccdeedb2e029019225e350).- On
emulator-5556(FoldB_API_36, 2208x1840, density 420) in dark mode (adb shell cmd uimode night yes) against the live serverws://10.0.2.2:8080/connect, driven withadb shell inputanduiautomator dump. Every capture below was written withandroid/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 stashbuild): runs-list usage values were Succeeded#F2C879(amber), Running card#6FD3B8(mint); a run header read#F2C879(succeeded) and#6FD3B8(running) — the reported bug,capturesinruns_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#7FB2F0and 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
approvedstep chip sampled#BEC9C5(the run-statusUnknowngrey). After, thesuccessstep chip sampled#F2C879(the graph's tertiary terminal role) and theapprovedchip#C0A3F5(GraphPaletteindex 5), both equal to the graph'soutcomeColor(run_timeline_before.png,run_timeline_after.png). adb -s emulator-5556 logcat -dcontained 0FATAL EXCEPTION/E AndroidRuntimelines (the only app-matched lines were expectedInputDispatcher … Consumer closed input channelwarnings from the force-stop/reinstall).
- Before (pre-change tree,
- APK publish.
app/build/outputs/apk/debug/app-debug.apkwas copied to…/artifacts/69/1/pipelines-debug-wip-cd85f69.apk(cd85f69=git rev-parse --short HEAD);shasum -a 256matched.curl -I http://10.0.0.249:8080/artifacts/69/1/pipelines-debug-wip-cd85f69.apk(LAN address fromipconfig getifaddr en0) returnedHTTP/1.1 200 OK,Content-Type: application/vnd.android.package-archive,Content-Length: 18009527; a streamedGET | shasum -a 256equalled 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 (RunStatusPaletteTest7/7, including the per-status WCAG-AA contrast check).gradle --offline :app:assembleDebugsucceeded; the APK is 18,009,527 bytes, sha25617f52f23e40f4ba0c524ac2929adfd6a8f39353e68ccdeedb2e029019225e350.- Before/after captured on
emulator-5556(sdk_gphone16k_arm64, 2208x1840, density 420, dark mode) withandroid/scripts/capture_png.sh -s emulator-5556. The pre-change build was produced from a cleangit archive cd85f69tree (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; theapprovedTimeline chip#BEC9C5(run-statusUnknowngrey). - After: Succeeded
#7FE0A8(green), Failed#FFB4AB, Canceled#889391, Interrupted#E8C06A, Active#7FB2F0; run 69 header#7FE0A8, run 72 header#7FB2F0; theapprovedTimeline chip#C0A3F5(graph palette index 5) while thesuccesschip stays#F2C879(the graph's tertiary role), so a step chip agrees with the graph.logcatafter a fresh launch had 0FATAL EXCEPTION/E AndroidRuntimelines.
- Before: runs-list usage Succeeded
- APK publish.
app/build/outputs/apk/debug/app-debug.apkcopied 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.apkreturnedHTTP/1.1 200 OK,Content-Type: application/vnd.android.package-archive,Content-Length: 18009527, and a streamedGET | shasum -a 256matched.
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.ktaddspipelineRunBadges(runs, now), which folds the history onto aMap<Long, PipelineRunBadge>keyed by pipeline id withrunId,state(runStateOf),ranAgoandduration. Recency comes from the run timestamps, not the input order — the higher run id breaks an exact tie (or a missing/blankcreated_at), so an unsorted or partial response is still correct.PipelineRunBadge.metaLine()formatsago · duration · run Nand drops any fragment that is genuinely absent (a still-running run has nofinished_at); it never prints a blank separator.formatRanAgomirrors theformatDurationinteger rhythm (just now, thenNm ago/Nh ago/Nd ago) and clamps clock skew tojust now. A pipeline with no run is simply absent from the map and the row prints the explicitNO_RUNS_RECORDED("no runs recorded") instead of a blank line. The last-run line is withheld untilrunsState.data != null(runsKnown), so a not-yet-loaded history never makes the false "no runs recorded" claim. - Row.
PipelineListScreen.ktrefreshes runs alongside pipelines, anchors "now" once per composition (remember), and renders the chip + meta line in aRowunder 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), eachformatRanAgoscale plus blank/bad input, and theNO_RUNS_RECORDEDwording.
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 (PipelineLastRunTest10/10).gradle :app:assembleDebug --rerun-tasks --no-build-cachesucceeded →app-debug.apk17,863,337 bytes, sha256b22550660c1ce9f42719eb5a32a296055d9f3df97fa0fd94bb26fa3868730506. This is a full rebuild of the current tree; the review's blocker was that the earlier publishedartifacts/83/1/pipelines-debug-wip-5444390.apk(17,997,811 bytes, sha2560fb07207…) was a different revision ofPipelineListScreen.kt, so it has been rebuilt and republished (see below).- Screenshots on
emulator-5556(FoldB_API_36, 2208x1840, density 420, dark mode) withandroid/scripts/capture_png.sh -s emulator-5556: the narrow window viaadb 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 carryingago · duration · run N, and pipeline id 3 "Plan, implement, review" printingno 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.apkreturnedHTTP/1.1 200 OK,Content-Type: application/vnd.android.package-archive,Content-Length: 17863337, and a streamedGET | shasum -a 256returned the sameb2255066…as the local file. The same APK was installed on the emulator and the pulled installedbase.apkhashed tob2255066…, 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.ktdefines thePipelineSort(ServerOrderdefault,NameAsc,NameDesc,RecentRun,FewestStages,MostStages) andRunSort(NewestFirstdefault,OldestFirst,LongestDuration,ShortestDuration,PipelineName,Status) enums plus one purepipelineComparator/runComparatorper sort and thesortPipelines/sortRunshelpers. 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.ServerOrderis a zero comparator, so the stable sort preserves the server's own order exactly.RecentRunuses the shared per-pipeline latest-run fold (latestRunByPipeline, extracted from the last-run badge join inPipelineLastRun.kt) rather than folding the history twice. - Shared time helpers.
ui/Format.ktgainedparseInstant(moved out ofPipelineLastRun.kt) anddurationSeconds; the existingformatDurationnow delegates todurationSeconds, so the printed duration and the sort key can never disagree. - Shared control.
ui/components/SortMenu.ktis the one top-bar control both screens use: anIconButton(its own glyph and content description, so it cannot collide with the adjacent Refresh action or a future search entry point) opening aDropdownMenuof 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 isIcons.AutoMirrored.Filled.Sort(the RTL-aware form, so noIcons.Default.Sortdeprecation warning at build time and the arrow mirrors correctly). - Persistence.
data/SettingsRepository.ktstores each choice as its stable storage key (pipeline_sort,run_sort) with aStateFlow, exactly like the server URL/workspace;AppViewModelexposes them and their setters. The list screens resolve the stored string withPipelineSort.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.
groupRunsByDaynow 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 newListSortTesthas 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;RunGroupingTestgained an explicit-order case).compileDebugKotlinemits 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.apk17,879,721 bytes, sha256cb68fbb13e469e81c15837ba95314a2ab40f1f29f4769e4a615bbc0ce4636a30.- On
emulator-5556(FoldB_API_36, 2208x1840, density 420, dark mode) against the live serverws://10.0.2.2:8080/connect, driven withadb shell inputanduiautomator dump; every capture below was written withandroid/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 pipelinesopened the six options plusReset(01_wide_pipelines_sort_open.png); choosingName Z–Areordered the list to descending names and storedpipeline_sort=name_desc(02_wide_pipelines_name_za.png).Sort runsopened the six run options plusReset(03_wide_runs_sort_open.png);Oldest firstshowed run 1 → 2 → 3 and storedrun_sort=oldest_first(04_wide_runs_oldest_first.png). The sort icon and the adjacentRefreshstay separate actions at both widths (the icon's ownSort pipelines/Sort runscontent description sits left ofRefresh …). - Persistence proof. After setting pipelines
Name Z–Aand runsOldest first,run-as net.awan.pipelines cat shared_prefs/pipelines_settings.xmlshowedpipeline_sort=name_desc,run_sort=oldest_first.am force-stop net.awan.pipelines(verifiedpidofempty) thenam startand a freshuiautomator dumpshowed 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. Reseton the pipelines menu restored the server order (id 1 → 5 → 11 → 6 → 4 → 9 → 3) and storedpipeline_sort=server_order;Reseton the runs menu restoredrun_sort=newest_firstand run 87 → 86 → 85 → 84 → 83 → 82 (10_narrow_runs_reset_newest_first.png).- Narrow (
adb shell wm size 1080x2340≈ 411dp;wm size resetafterwards): bothSort pipelinesandSort runsopened their menus (07_narrow_runs_sort_open.png);Statusordered Canceled → Failed → Failed … and storedrun_sort=status(08_narrow_runs_status_sort.png);Most recent runordered the rows by recency 10h → 3d → 3d → 4d → 4d → 5d and put the runless pipeline (no runs recorded) last, storingpipeline_sort=recent_run(09_narrow_pipelines_recent_run.png). - Stale-key tolerance on device. With
pipeline_sortandrun_sortset togarbage_keyinshared_prefs/pipelines_settings.xml(verified viarun-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.
- Wide (2208x1840 ≈ 841dp): tapping
- APK publish.
app-debug.apkwas copied to~/.local/share/pipelines/data/artifacts/87/1/pipelines-debug-wip-3480461.apk(3480461=git rev-parse --short HEAD);shasum -a 256matched.curl -I http://10.0.0.249:8080/artifacts/87/1/pipelines-debug-wip-3480461.apkreturnedHTTP/1.1 200 OK,Content-Type: application/vnd.android.package-archive,Content-Length: 17879721, and a streamedGET | shasum -a 256returned the samecb68fbb1…as the local file. The deterministic full-rebuild APK was installed onemulator-5556(adb -s emulator-5556 install -r) and the pulled installedbase.apkhashed tocb68fbb1…, 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.ktdefinesRunTimeRange(AnyTimedefault,Today,Last7Days,Last30Days),RunPresence(Anydefault,HasRuns,NoRuns) and theRunFilters/PipelineFiltersdata classes plus one pure predicate per facet (runMatchesStatuses,runMatchesPipeline,runMatchesTimeRange,pipelineMatchesPresence,pipelineMatchesLastRunStatus) and the AND-combiningfilterRuns/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-onlyactive/unknownbuckets. 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.fromStoragetolerates stale/unknown/blank values by returning the default, andencodeRunStates/decodeRunStatesround-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
filterPipelinesleaves the list unfiltered until that history is known rather than briefly hiding every row. - Shared control.
ui/components/FilterMenu.ktis the one top-bar control both screens use: anIconButtoncarrying 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). ItsoptionContentslot receives adismisscallback, so single-select entries close the menu while multi-select toggles keep it open;FilterCheckItemis the shared leading-check row. It has no geometry literals and anchors correctly at both window widths. - Empty states.
ui/components/States.kt'sEmptyStategained optionalactionLabel/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.ktstores 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 aStateFlow, exactly like the sorts;AppViewModelexposes them and their setters. The screens resolve the stored strings withRunFilters.fromStorage/PipelineFilters.fromStorage(the repository stays unaware of the UI enums). - Shared time helper. The run screen's file-private
runDatewas removed in favour ofListFilter.kt'srunLocalDate, so the day-grouping label and the time-range predicate share one parse.groupRunsByDayis 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 newListFilterTesthas 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, therunsKnownguard, 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.apk17,912,489 bytes, sha256eaa34c0b030511c2e4de1964dc4e905e62e822e876b5c0128bfff4d918933fc5.- On
emulator-5556(sdk_gphone16k_arm64, 2208x1840, dark mode) against the live serverws://10.0.2.2:8080/connect, driven withadb shell inputanduiautomator dump; every capture below was written withandroid/scripts/capture_png.sh -s emulator-5556(validated PNG, named display id) into…/artifacts/89/1/:- Selecting status
failednarrowed the runs list to the failed runs and showed the badge1(01_runs_filtered_failed.png), read back from the accessibility tree. - The runs
Filter runsmenu opened with its Status, Pipeline and Time range sections, the active-count badge andClear filters(02_runs_filter_menu_open.png). - Filtered-empty state. Adding pipeline
Complete a Taskto thefailedstatus matched run 43, but the contradictoryrunningstatus (noComplete a Taskrun is running) yielded no match: the list showedNo runs match the current filters.with aClear filtersbutton and badge2(03_runs_filtered_empty.png); the button restored the full list and removed the badge. - The pipelines
Filter pipelinesmenu carries the Runs (Any/Has runs/No runs) and Last run status sections, the badge andClear filters(05_pipelines_filter_menu_open.png).Has runs+ last-run statussucceedednarrowed the list to its succeeded-last-run pipelines (04_pipelines_filtered_has_runs_succeeded.png);No runs+ last-run statussucceededis contradictory and showedNo pipelines match the current filters.withClear filtersand badge2(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
failedand pipelineshas_runs+ last-run statussucceeded,run-as net.awan.pipelines cat shared_prefs/pipelines_settings.xmlshowedrun_filter_statuses=failed,pipeline_filter_presence=has_runs,pipeline_filter_run_statuses=succeeded.am force-stop net.awan.pipelines(verifiedpidofempty) thenam startand a freshuiautomator dumpshowed the pipelines list still narrowed with badge2(07_pipelines_filtered_after_relaunch.png) and the runs list still filtered tofailedwith badge1(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.
- Selecting status
- APK publish.
app-debug.apkwas copied to~/.local/share/pipelines/data/artifacts/89/1/pipelines-debug-wip-1c925d7.apk(1c925d7=git rev-parse --short HEAD);shasum -a 256matched.curl -I http://10.0.0.249:8080/artifacts/89/1/pipelines-debug-wip-1c925d7.apkreturnedHTTP/1.1 200 OK,Content-Type: application/vnd.android.package-archive,Content-Length: 17912489, and a streamedGET | shasum -a 256returned the sameeaa34c0b…as the local file. The deterministic full-rebuild APK was installed onemulator-5556(adb -s emulator-5556 install -r) and the pulled installedbase.apkhashed toeaa34c0b…, 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 at0.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 asNrises. - Reset always visible. The single
Clear filtersaction is now a leading header row (Filters+ the resetTextButton, 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.navigationBarsbottom 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"), andFilterCheckItemexposestoggleableStateplusRole.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 (newFilterMenuTest: the height helper's proportional/positive growth and the description's 0/1/2/negative wording).gradle --offline :app:assembleDebugsucceeded →app-debug.apk18,005,500 bytes, sha2567351c13b….- On
emulator-5556(2208x1840, density 420, dark mode) againstws://10.0.2.2:8080/connect, captured withandroid/scripts/capture_png.sh -s emulator-5556into…/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 filterssit at the top (y=133–186) and after four swipes the last itemLast 30 daysis at y=1466–1519, fully visible with the nav spacer below it (02_runs_filter_menu.png). uiautomator dumpreports the runs filter rowscheckable=truewith the selected rowchecked=true(Any time), and the iconcontent-descisFilter runs, 2 filters active/Filter runs, 1 filter activematching the badge (03_runs_filtered_failed.png,01_runs_filtered_empty.png).- The pipelines menu (
Filters/Clear filtersat the top,RunsandLast run statussections) is[1542,93]–[1945,1622], also above the inset (04_pipelines_filter_menu.png);Has runs+ last-runsucceededfiltered the list (05_…png),No runs+succeededshowedNo pipelines match the current filters.withClear filters(06_…png). - Persistence proof.
am force-stop net.awan.pipelines(verifiedpidofempty) thenam startand a fresh dump showed the pipelines screen still filtered (badge2) and the runs list stillFilter 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.
- The runs menu now has window
- APK publish.
app-debug.apkcopied to…/artifacts/89/4/pipelines-debug-wip-1c925d7.apk(1c925d7=git rev-parse --short HEAD);shasum -a 256matched.curlagainsthttp://10.0.0.75:8080/artifacts/89/4/pipelines-debug-wip-1c925d7.apkreturnedHTTP 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.ktnow 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-legibleonSurfaceVariantlabel. The oldalpha = 0.25f/0.3fdimming is gone, so the distinction survives a screenshot, a dim screen and a colour-blind reader. - Shared, testable predicates.
stageIsExecuted(key, runState)andedgeIsExecuted(edge, runState)(bothrunState == null⇒ executed) replace the privateEdgeLayout.isExecutedand the inlinevisitedStagescheck, so drawing and the screen-readergraphDescriptionshare one definition. - Dash token.
INACTIVE_DASH_INTERVALS = floatArrayOf(14f, 10f)is the one line-style token;INACTIVE_DASH_EFFECTis the lazily-builtPathEffectused 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 labelledExecuted; a dashed, arrowless swatch labelledNot executed) is drawn as a one-lineRowpinned 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
runStateevery 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 executedsuccess/errorroute 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;WorkflowGraphTest34 tests (3 new: the executed predicates over the definition view and aRunGraphState, the dash pattern being a positive even-length rhythm, and the legend naming both states with executed first). The clean:app:assembleDebugproducedapp-debug.apk17,912,489 bytes, sha25649631a3a2763bf1d9232eb9e7c8f9ff3edd719355ac0a99b7c91f7f40c3a1cc5(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_reviewerran,committerdid not) was opened in the app against the live serverws://10.0.2.2:8080/connectin dark mode, driven withadb shell input, and every capture below was written withandroid/scripts/capture_png.sh -s emulator-5556(validated PNG magic bytes; the fold emulator has two displays, so ascreencapredirect 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 legendgraph_partly_exec_wide_1x_zoom.png. - Grayscale check. Greyscale conversions (
PILImage.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
54af453worktree) and on this build; the graph pane is pixel-identical (no legend on either side). APIL ImageChops.differenceover the graph pane (x 1150–2208, y 150–1500) reportedbbox None/0differing pixels of 1,428,300 / max channel diff0. Before/after pair:def_before_p8.png/def_after_p8.png(pipeline 8 Graph tab); the same source's pipeline-11 Graph tab after isgraph_definition_only_wide_1x.png. adb -s emulator-5556 logcat -dcontained 0FATAL EXCEPTIONand 0E AndroidRuntimelines.
- Narrow 1080x1920 @ density 480 (≈360dp):
- APK publish.
app-debug.apkcopied to…/artifacts/93/1/pipelines-debug-wip-54af453.apk(54af453=git rev-parse --short HEAD);shasum -a 256matched.curl -I http://10.0.0.249:8080/artifacts/93/1/pipelines-debug-wip-54af453.apk(10.0.0.249fromipconfig getifaddr en0) returnedHTTP/1.1 200 OK,Content-Type: application/vnd.android.package-archive,Content-Length: 17912489, and a streamedGET | shasum -a 256equalled 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.ktnow treatssuccess(pass) anderror(fail) as the emphasised outcomes (isPassFailOutcome). An executed pass/fail edge is drawn atPASSFAIL_EDGE_STROKE = 7f— noticeably heavier than the previous3f— with a stronger, more saturated stroke and a filled arrowhead proportional to its own width (edgeArrowHeadSize, i.e.strokeWidth * ARROW_HEAD_SCALEwithARROW_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 finerINACTIVE_EDGE_STROKE = 2.5f, so the two emphasised outcomes dominate. No outcome hue changed. - Stronger, same-hue stroke.
boostSaturation(color, factor)inui/graph/GraphPalette.ktscales HSV saturation byPASSFAIL_SATURATION = 1.6f, clamping at 1 while preserving hue, value and alpha. On the dark theme the executedsuccessstroke moves from#F2C879(hue 39.2°) to a vivid#F2AF30-ish core (hue 39.3°, measured pixel(242,175,48)) and the executederrorstroke 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,edgeArrowHeadSizeandedgeStrokeColorpick the token for an edge; the old12farrowhead literal is gone (the draw scope takes the size as a parameter). The legend swatch keeps the baseEDGE_STROKE/ARROW_HEAD_SIZEbecause 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;WorkflowGraphTest36 (2 new: the executed pass/fail edge is the widest and its arrowhead scales, and onlysuccess/errorare pass/fail outcomes) andGraphPaletteTest10 (3 new:boostSaturationraises 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:assembleDebugproducedapp-debug.apk17,912,489 bytes, sha256ce63722b851ce26322da69fa47bdc91958c3d7db3e339c1340efc3e04b6780f8.- 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_reviewerwitherror) was opened in the app against the live serverws://10.0.2.2:8080/connectin dark mode; its taken routes include asuccessand anerroredge. "Before" is HEAD9c47527(the six edited files stashed, rebuilt, installed; verified by the help line without "thickest"); "after" is this change. Captures were written withandroid/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.pngand stacked before/after sheetscompare_wide_1x.png/compare_wide_2x.pngshow the two ambersuccessedges and the rederroredge as the boldest lines after the change, with the dashedblocked/rejected/approved/skippedroutes and the not-executedcommitter/SUCCESSedges unchanged. adb -s emulator-5556 logcat -dcontained 0FATAL EXCEPTIONand 0E AndroidRuntimelines.
- Wide 2208x1840 @ density 420 (≈841dp):
- APK publish.
app-debug.apkcopied to…/artifacts/98/1/pipelines-debug-wip-9c47527.apk(9c47527=git rev-parse --short HEAD);shasum -a 256matched.curl -I http://10.0.0.249:8080/artifacts/98/1/pipelines-debug-wip-9c47527.apk(10.0.0.249fromipconfig getifaddr en0) returnedHTTP/1.1 200 OK,Content-Type: application/vnd.android.package-archive,Content-Length: 17912489, and a streamedGET | shasum -a 256equalled 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.ktreadsMaterialTheme.shapes.mediumonce 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 puretonalFill(surface, accent, fraction)blends a raisedsurfaceContainerHighwith a subtle fraction of the node's semantic colour (NEUTRAL_TINT/KIND_TINTfor a stage by kind,TERMINAL_TINTfor a terminal's success/error hue), and the hard outline is replaced by a softoutlineVariantborder (NODE_BORDER, strengthened for a selected stage withNODE_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
cardTitlerole and the outcome labels itslabelrole (no ad-hoc13.sp/11.sp), with the theme's own line height and letter spacing; the[brackets]and the all-capsSUCCESS/FAILUREare gone — the graph showsSuccess/Failurein the terminal's own colour (the new purenodeDisplayLabel; the sharedGraphSemantics.nodeLabelthe 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 singleROUTE_CORNER_RADIUScontrol offset (the purecornerCutRadiusclamps a short adjacent segment to half its length so two cut-backs can never meet), usesStrokeCap.Round/StrokeJoin.Round, and scales the filled arrowhead to the line with oneARROW_HEAD_SCALE(edgeArrowHeadSize = edgeStrokeWidth * ARROW_HEAD_SCALE). Labels sit on a rounded tonal chip (tonalFillof 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.dpto 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.graphColorsandoutcomeColorkeep 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:WorkflowGraphTestfor the readable node labels, the arrowhead proportional to its stroke and the corner-cut clamp, andGraphPaletteTestfortonalFill).compileDebugKotlinemitted no warnings (the deprecatedquadraticBezierTowas replaced byquadraticTo).gradle --offline :app:assembleDebug→BUILD SUCCESSFUL;app-debug.apkis 17,928,873 bytes, sha256ba5bcc467989425b69aad2ae70799c0cf4d9eaf54be30243b4631fb7e94916b3.- On
emulator-5556(FoldB_API_36, dark mode) against the live serverws://10.0.2.2:8080/connect, driven withadb shell inputanduiautomator dump. Every capture was written withandroid/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 atcommitter:implementer/reviewer/ui_reviewerand the failedcommitterexecuted,Successnot) 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 cleangit archive 8b39c08tree (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_reviewerwere visited and the failedcommitterwas visited too (it was entered and then failed), so all four stages are filled and the selectedcommitterinverts (lightinverseSurfacefill, solid primary border); the executedsuccess/errorroutes are the boldest lines, and the not-executedSuccessterminal is hollow with a dashed border (theFailureterminal, reached by the executederroredge, 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 selectedcommitternode (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 -dcontained 0FATAL EXCEPTIONand 0E AndroidRuntimelines 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.apkwas copied to~/.local/share/pipelines/data/artifacts/108/1/pipelines-debug-wip-8b39c08.apk(8b39c08=git rev-parse --short HEAD);shasum -a 256matched.curl -I http://10.0.0.249:8080/artifacts/108/1/pipelines-debug-wip-8b39c08.apk(LAN address fromipconfig getifaddr en0) returnedHTTP/1.1 200 OK,Content-Type: application/vnd.android.package-archive,Content-Length: 17928873, and a streamedGET | shasum -a 256returned the sameba5bcc46…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 intolabelBackground, so the chip geometry lives once. - Redundant geometry.
cornerCutRadiusnow takes the adjacent segment lengths the caller has already measured (cornerCutRadius(inLength, outLength, radius)), soroundedRoutePathcomputes each corner's twohypots once instead of twice. - Redundant width. The new pure
arrowHeadSizeFor(strokeWidth)is the one arrowhead-from-stroke mapping;drawEdgePathspasses the width it has just computed (arrowHeadSizeFor(width)) instead of re-deriving it, andedgeArrowHeadSizedelegates to the same function. - Geometry tokens.
ROUTE_CORNER_RADIUS(7.dp) and the chipEDGE_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 (thecornerCutRadiustest now exercises the length-based clamp).gradle --offline :app:compileDebugKotlin --rerun-tasks→BUILD SUCCESSFULwith now:warnings.gradle --offline :app:assembleDebug --rerun-tasks→BUILD SUCCESSFUL;app-debug.apkis 17,928,873 bytes, sha256ab99e734b0b190294ebfad8d342caf599286cefda23a0faf39f0244496e3af1a. (A full--rerun-tasksrebuild is byte-reproducible — two consecutive runs produced this same hash — whereas incremental packaging is not, so the published APK is the--rerun-tasksone.)- 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 viaandroid/scripts/capture_png.sh -s emulator-5556:followup_wide_1x_definition.png(the pipeline 3 definition graph) andfollowup_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 selectedcommitterinverted (light fill, solid primary border) and the not-executedFailureterminal 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'is0; 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.apkreturnedHTTP/1.1 200 OK,Content-Type: application/vnd.android.package-archive,Content-Length: 17928873, and a streamedGET | shasum -a 256returned the sameab99e734…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.
drawEdgeLabelsdeclaredaccentandtextColorholding the identical value (bothoutcomeColor(...)when the edge executed, elsecolors.labelText); they are now the singlelabelColor, 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), matchingWorkflowGraph.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 SUCCESSFULwith now: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.apkis 17,928,873 bytes, sha256c95fab884d392a2b3df6170ec2e16ccc4fdf6f1fef4e946425f5dcda56c881a7, reproducibly (two consecutive--rerun-tasksrebuilds matched).- Smoke captures on
emulator-5556(native 2208x1840 @420) with this APK, written viaandroid/scripts/capture_png.sh -s emulator-5556:followup2_wide_1x_launch.png,followup2_wide_1x_definition.png(pipeline 3) andfollowup2_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 (filledFailure/Success) and chipped labels; run 109 fills the visited stages, inverts the selectedcommitter(light fill, solid primary border) and leaves the not-executedFailureterminal hollow with a dashed border.adb -s emulator-5556 logcat -d | grep -cE 'FATAL EXCEPTION|E AndroidRuntime'is0. - 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.apkreturnedHTTP/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.apkis 17,928,873 bytes, sha256c95fab884d392a2b3df6170ec2e16ccc4fdf6f1fef4e946425f5dcda56c881a7(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 newtonalFill,nodeDisplayLabel,arrowHeadScalesWithTheStrokeItTerminatesandcornerCutNeverExceedsHalfTheShorterSegmenttests 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 selectedcommitter), written withandroid/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.pngnode crops, and the stackedcompare_{wide,narrow}_1x_{definition,run}.pngsheets. Thebeforeimages were rebuilt fromHEAD(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 theafterimages show the rounded tonal stages, pill terminals (Failurehollow/dashed when not executed,Successfilled) and chipped labels.adb -s emulator-5556 logcat -d | grep -cE 'FATAL EXCEPTION|E AndroidRuntime'is0. - 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.apkreturnedHTTP/1.1 200 OK,Content-Type: application/vnd.android.package-archive,Content-Length: 17928873.
One artifacts gallery everywhere, with a type icon for non-media (16 Oct 2026)
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'sArtifactTilereplaces the oldArtifactTile+ArtifactRowsplit. 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 chunkedRows, so it never nests a scrollable inside the SummaryLazyColumnor the pane's scroll. - Type-to-icon mapping. The new pure
ui/graph/ArtifactType.ktclassifies an artifact from its content type (parameters tolerated) and, when the server's sniff is generic, its name's extension, intoArtifactKind(Image/Video/Audio/Pdf/Json/Archive/Spreadsheet/Log/Code/Document/Other), andartifactIcon(kind)gives each kind a distinct shape (PDF, JSON, archive, spreadsheet, log, code, document, audio, generic file).Format.ktgained the companionisVideoContentTypepredicate besideisImageContentType. - Video poster frame.
ui/graph/ArtifactImage.ktgainedArtifactVideoFrame/rememberArtifactVideoFrame: the artifact's bytes are fetched through the same bounded cache as an image and the representative sync frame is extracted with the platformMediaMetadataRetrieverover an in-memoryMediaDataSource(no temp file, no new dependency, no inline playback). The full-screen viewer takes avideoflag 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.ktgainsARTIFACT_TYPE_ICON_DP(28dp),ARTIFACT_PLAY_BADGE_DP(32dp) andARTIFACT_TILE_ACTION_DP(32dp); the tile still stretchesARTIFACT_TILE_DPcells across the measured width via the unchanged pureartifactGrid.
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 newui/graph/ArtifactTypeTesthas 6 cases: the media kinds from the content type, the named kinds, the extension fallback for a generic sniff, the never-crashOtherfallback, the explicit type-to-icon mapping, and that no two kinds share a glyph).ArtifactGalleryTeststill covers the grid sizing (narrow → fewer, larger cells; wider → more preferred-shaped columns; degenerate inputs).compileDebugKotlinemits no warnings.gradle --offline :app:assembleDebug --rerun-tasks --no-build-cachesucceeded →app-debug.apk18,011,393 bytes, sha256faa9df077c960b23eef4afbac1b7effa1a50180eabcee2d638cabb232974cfa8.- On
emulator-5554(native 2076x2152 @390;wm size/wm densityused for the narrow pass and reset afterwards) against the live serverws://10.0.2.2:8080/connect, driven withadb shell inputanduiautomator dump; every capture was written withandroid/scripts/capture_png.sh -s emulator-5554(validated PNG, named display id) into…/artifacts/140/1/. Run 136'simplementervisit 1 is a real mixed set: fiveimage/pngscreenshots pluschat_stub_approval.py(text/plain, code glyph) andstub.log(text/plain, log glyph).- Wide (2076x2152 ≈ 532dp):
evidence_wide_run136_summary_gallery.pngshows the five thumbnails with their share controls and, in the same grid, the.pytile with the<>code glyph and the.logtile with the log glyph, each with its name and9.3 KiB/220 Bbeneath it and the copy + share actions;evidence_wide_run136_stage_pane.pngshows the same gallery in the stage pane under the unchangedArtifacts · 7 recorded · partial capturewording and the1 files excluded from artifact capture.note. - Narrow (1080x2340 @480 ≈ 360dp):
evidence_narrow_run136_summary_gallery.pngandevidence_narrow_run136_stage_pane.pngshow 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 dumpreported the01_approval_pending.pngimage plusOpen … externally,Copy link …andClose 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.
- Wide (2076x2152 ≈ 532dp):
- APK publish.
app-debug.apkcopied to…/artifacts/140/1/pipelines-debug-wip-c700b28.apk(c700b28= shortHEAD);shasum -a 256matched.curl -I http://10.0.0.249:8080/artifacts/140/1/pipelines-debug-wip-c700b28.apkreturnedHTTP/1.1 200 OK,Content-Type: application/vnd.android.package-archive,Content-Length: 18011393, and a streamedGET | shasum -a 256returned the samefaa9df07…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 removedartifactMetaLineassertions were replaced byisVideoContentTypecoverage in the sameFormatTestmethod).gradle --offline :app:assembleDebug --rerun-tasks --no-build-cachesucceeded →app-debug.apk18,011,393 bytes, sha2562adaf03e5ac0bdb29b012d1487a0e10917f8ebabda973ddc63c7315b6df25dda; it was published to…/artifacts/140/3/pipelines-debug-wip-c700b28.apkandcurl -I http://10.0.0.249:8080/artifacts/140/3/pipelines-debug-wip-c700b28.apkreturnedHTTP/1.1 200 OK,Content-Length: 18011393, with a streamedGET | shasum -a 256matching the local2adaf03e….
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.
Collapsible artifacts gallery in the run summary (16 Oct 2026)
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'sRunSummaryTabrenders the gallery through the sharedLazyListScope.collapsibleSection, keyed"artifacts"and seeded withrememberSectionExpansion(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 capturewhen any visit excluded or omitted files; with no artifacts it reuses the sharedartifactsEmptyMessage. Its count is exactlyrunArtifactGroups'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.ArtifactGroupsTestgainedheaderReportsTheCountWithASingularTitleForOne,headerAddsPartialCaptureOnlyWhenFilesWereExcludedOrOmitted,headerEmptyCaseUsesTheSharedEmptyWordingandheaderCountMatchesTheGalleryRecordedTotal.gradle --no-daemon --offline :app:assembleDebug→app-debug.apk18,011,393 bytes, sha256c5655269e490db34cbacccf68eaec468a3a41c46c661b41e6ad2d92295235247; installed withadb -s 58281FDCG000JF install -r, and the pulledbase.apksha 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.pngshows the summary led by a lone collapsedArtifacts · 17 recorded · partial captureheader (right chevron) with the run's facts immediately below and no gallery;summary_wide_expanded.pngshows the same header expanded to the unchanged gallery — theimplementer · visit 1andui_reviewer · visit 1groups of image thumbnails plus thechat_stub_approval.py(<>code glyph) andstub.log(log glyph) tiles with their names,9.3 KiB/220 Bsizes and share/copy actions. - Narrow (
wm size 1080x2152on the inner display ≈ 524dp, reset to the native size afterwards):summary_narrow_collapsed.pngandsummary_narrow_expanded.pngshow the same collapsed header and, expanded, the same gallery re-flowed to four cells per row (wide uses five). - Persistence.
uiautomator dumpreportedArtifacts · 17 recorded · partial capture, collapsedon a freshly opened run; toggling it and round-tripping Summary → Graph → Summary, and awm sizeconfiguration 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 usbKEYCODE_WAKEUP) and every capture usedscreencap -p -d <display-id>+adb pull. Screenshots,uiautomatordumps and the APK are in…/artifacts/155/1/.
- Wide (inner display, 2152×2076 @330 ≈ 1043dp):
- APK publish.
app-debug.apkcopied to…/artifacts/155/1/pipelines-debug-wip-95150c7.apk(95150c7= shortHEAD; the working tree is uncommitted WIP on top of it);shasum -a 256matched.curl -I http://10.0.0.249:8080/artifacts/155/1/pipelines-debug-wip-95150c7.apkreturnedHTTP/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.ktgains an optionaltitleon bothRunSummaryandRunDetail(the server'sRunSummary.title). It is nullable and defaults to absent, so a server that does not send it degrades cleanly. - One shared fallback. New
ui/RunIdentity.ktholdsrunLabel(title, name)(mirroring the server'sRunSummary.Label) andrunIdentity(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.RunRowshows 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.StageDetailPanetakes an optionalrunLabeland 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_titlecommand andlist_runs/get_runreturn notitlefield, 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 newRunIdentityTest(5 cases) covers the title/fallback/trim logic, andProtocolModelTestgained a case for a present and one for an absent title on both the run summary and the run detail.:app:assembleDebug→app-debug.apk18,257,214 bytes, sha256bce661069b2bd013f0802545402766a3ae8fed97e1bbe0109f81a4bfb6233601.- Server capability probe (read-only, through the installed CLI):
pipelines runsandpipelines rpc '{"type":"get_run","run_id":155}'return notitlefield, and the runningpipelines-serverbinary contains noset_run_titlestring. 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.apkcopied to…/artifacts/162/1/pipelines-debug-wip-e1c531a.apk(e1c531a= shortHEAD; the working tree is uncommitted WIP on top of it);shasum -a 256matched.curl -I http://10.0.0.249:8080/artifacts/162/1/pipelines-debug-wip-e1c531a.apkreturnedHTTP/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.ktgainsStageVerdictand an optionalverdictonRunStep, mirroringinternal/protocol/verdict.go({option, reason, reason_source, artifacts}under theverdictwire 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.ktholds the pure helpers and the composable.StageVerdictBlockis 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
ColoredChipin 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 nomaxLinesclip. - References.
referencedVerdictArtifactsresolves the verdict's referenced names to the visit's recorded artifacts (recorded order, deduplicated, an unrecorded/invented name dropped).verdictReasonSegmentssplits the reason around those names — by full recorded name or basename, longest match first — and the segments become inlineLinkAnnotation.Clickablereferences colouredprimarywith an underline. An image/video reference opens the sharedArtifactViewer; anything else goes through the existingopenArtifactaction. The same references areFlowRowchips (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 newdp/spliteral 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. NewStageVerdictTest(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) andProtocolModelTest#runStepVerdictParsesWithItsReasonSourceAndReferencedArtifacts.:app:assembleDebug→app-debug.apk18,270,824 bytes, sha25685847c6fe32498f38464741ca1b8f592dbbd7a9e1f34dd649121e723836b0903.- APK publish.
app-debug.apkcopied to~/.local/share/pipelines/data/artifacts/167/1/pipelines-debug-wip-8b0d7b1.apk(8b0d7b1= shortHEAD);shasum -a 256matched. The LAN URLhttp://10.0.0.249:8080/artifacts/167/1/pipelines-debug-wip-8b0d7b1.apkreturnedHTTP/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.