Files
pipelines/android/README.md
T
alan 3480461ffb Show the last run on every pipeline row
Each pipeline row in the Android list now renders its most recent run:
the status chip, how long ago it started, its recorded duration and its
run id. Pipelines that have never run say "no runs recorded" instead of
leaving a blank line, and the line is withheld until the run history has
loaded so a missing history is never reported as "no runs".

The list_runs history already arrives whole (id DESC), so the join is
client-side: PipelineLastRun.kt folds it onto a Map keyed by pipeline id,
recency decided from the timestamps with the higher run id breaking an
exact tie, and formats "ago · duration · run N", omitting any genuinely
absent fragment. The change is android/-only, adds no server field or
dependency, keeps the existing title/secondary structure and selected-row
highlight, and never starts a run.

PipelineLastRunTest covers most-recent-wins, no runs, unknown pipeline
id, equal timestamps, a bad timestamp, an unknown status word, the
formatRanAgo scales and the "no runs recorded" wording. README records
the verification: :app:testDebugUnitTest (153 tests, 0 failures) and a
full --rerun-tasks assembleDebug (17,863,337 bytes, sha256 b2255066…).
2026-10-16 03:43:29 +01:00

1438 lines
92 KiB
Markdown
Raw Blame History

This file contains invisible Unicode characters
This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# Pipelines Android client
A native Android (Kotlin + Jetpack Compose Material 3) client for an existing
Pipelines server. All execution, model credentials, definitions and run history
stay on the server; the app only speaks the existing WebSocket protocol.
## Scope and safety
- **Trusted LAN/VPN only.** The Pipelines API has **no authentication** and is
**not internet-safe**. Do not expose the server to untrusted networks.
- **No secrets.** The app stores no credentials, tokens or provider keys and
sends no auth headers. Only the server URL and workspace path are persisted as
plain, non-secret preferences.
- **No hardcoded server.** The server URL and workspace path must be entered
explicitly by the user; there is no default/disposable address baked in.
- The app does **not** run Docker, execute stages, or reimplement any Go
parsing/execution logic. `android/` contains only the client.
## Requirements
- JDK 17 (see `compileOptions` / `kotlinOptions.jvmTarget`).
- Android SDK with a platform and build-tools matching `compileSdk = 35`
(`app/build.gradle.kts`), and `ANDROID_HOME`/`ANDROID_SDK_ROOT` set.
- Gradle 8.9+ (AGP 8.7.2, Kotlin 2.0.21).
The version numbers above are deliberate defaults chosen without a discovered
SDK; adjust `compileSdk`, `targetSdk`, and the versions in
`gradle/libs.versions.toml` to whatever is actually installed. If a required
SDK/Gradle component is missing, fix the environment rather than downloading
untracked artifacts.
### Gradle wrapper
`gradle/wrapper/gradle-wrapper.jar` is a generated binary and is intentionally
**not committed**. Generate a working wrapper on a machine with Gradle installed:
```sh
cd android
gradle wrapper --gradle-version 8.9
```
Until then, build with a locally installed Gradle:
```sh
cd android
gradle :app:assembleDebug
```
## Build, test and install
```sh
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:
```sh
android/scripts/capture_png.sh -s <serial> <out.png> # capture + validate
android/scripts/capture_png.sh --check <file.png> # validate an existing file
```
The helper resolves the primary SurfaceFlinger display id (`dumpsys
SurfaceFlinger --display-id`, the id `screencap -d` expects - not the logical
`dumpsys display` id), captures `-d <id>` to `/sdcard`, pulls, and checks the
PNG magic bytes (and the reported type). A file that is not a real image is
deleted and the helper exits non-zero, so a bad capture stops the run with
`blocked` instead of reaching an approval. Every UI-capturing run must use this
helper and state in its evidence that each image was validated.
## Configuration
Open the **Settings** tab and enter:
- **Server URL** — `ws://HOST:PORT/connect` (LAN/VPN) or `wss://…/connect`
(proxy/VPN). A path is optional and defaults to `/connect`, matching the Go
server's `GET /connect`. `http(s)`, userinfo and fragments are rejected with a
specific message.
- **Workspace path** — an **absolute directory that already exists on the
execution server**. This is *not* the phone's storage. For Docker, mount the
host directory at the same absolute path with the owner's UID/GID so the
server can resolve it (see `docs/docker.md` and `compose.yaml`). The field
flags a non-absolute path and will not save it, mirroring the repository's
start-run guard.
Tap **Connect** to open the single shared WebSocket (probed with `ping`, showing
the server build). Reconnect uses bounded exponential backoff; **Disconnect**
stops it.
## Features
- Pipeline list (search/refresh, empty/error/loading states), pipeline details
(version list, content hash, source) and the workflow graph.
- Workflow graph composable: content-sized stage nodes laid out in one row in
declaration order, with `#failure`/`#success` terminals sharing a lower row and
arrows entering their top borders (an `error -> #failure` route leaves its
source's bottom); labelled outcome edges (`error*` marks the implicit
fallback), loops and branches, pan/zoom, and run highlighting (executed routes
highlighted, others dimmed) plus a screen-reader description. Edges are drawn as
axis-aligned orthogonal polylines like the TUI (`routePoints` computes the
path once per layout and stores it on `EdgeLayout.points`), and each arrowhead
points along its route's final segment rather than the from-to chord. Pinch
zoom is anchored to the gesture centroid: the pure `zoomAbout` keeps the
content point under the fingers fixed (clamped to `MIN_SCALE`/`MAX_SCALE`) and
the existing pan clamp is applied afterwards, so the content no longer slides
away from the fingers.
- One shared graph-panel height (`collapsedGraphHeight`/`expandedGraphHeight`)
replaces the former 360.dp and 340.dp literals, so both detail screens render
the graph at the same size: about 58% of the window height floored at a height
that still fits a 4-stage graph with its terminal row. The graph's TopEnd
control cluster pairs "Fit graph to view" with an expand/collapse toggle that
grows the panel to about the full window height; the expanded state is stored
in `rememberSaveable` and the panel refits on resize. Because the panel lives
inside each screen's `verticalScroll` column, growing it only extends it below
the fold, so expanding also requests `BringIntoViewRequester` to scroll the
taller panel back into the visible viewport instead of leaving the graph
centred off-screen.
- Dark-first Material 3 theme with an app-owned colour scheme (no dynamic/
wallpaper colour): the dark scheme is the default and the window background and
system bars are dark so launching shows no light flash; a complete light scheme
is retained for when it is explicitly requested.
- Consistent Material 3 top app bars on Pipelines, Runs and Settings (and the
existing back/refresh/start/cancel/retry bars on the detail screens).
- Both detail screens are tabbed via one shared `ui/components/DetailTabs.kt`:
run detail exposes Summary, Graph, Input, Output, Evidence and Timeline, pipeline
detail Summary, Graph and Source, with Summary first and the default. Every tab
carries a meaningful icon alongside its label. The section index stays fixed and
visible while the selected section's panel swaps in place behind a short
`Crossfade`: selecting a section is an ordinary tab change with no lateral
motion, so there is nothing to swipe — the sections are not a left-to-right
pager. Only navigation between levels (list → detail → stage pane) slides, via
`SlidingPaneStack`. Only the selected section is composed at rest, each section
is a single `LazyColumn`, and each section's own saved state (its list scroll
position) is kept under its stable tab key through a
`rememberSaveableStateHolder`, so returning to a section never resets its
scroll. The Graph tab keeps the full-height `WorkflowGraph` panel with its Fit
and expand controls. Narrow windows show a horizontally scrolling
`PrimaryScrollableTabRow`; wide windows show an always-visible selectable rail
(icon + label, no collapse control). `selectedIndex` is the single source of
truth and a tap reports the new index through `onSelect`. The tabs carry real tab
semantics (`Role.Tab` + selected state), so selection is never conveyed by
colour alone, and the selected index is `rememberSaveable` (survives
recomposition, configuration change and process death) and clamped by
`clampTabIndex`.
- The Source tab fills the whole tab area and renders the parsed definition
instead of dumping the raw markdown: one collapsible section per stage (name ·
type) holding labelled blocks for prompt, output, tools, configs, edges
(outcomes with their resolved targets, `#success`/`#failure` named as
terminals), memory, limits and notification policy, skipping what a stage does
not have. The rows come from the same `stageDefinitionFields`/`StageFieldRow`
the stage detail sheet uses, so the two views cannot diverge. The exact source
stays available behind a "Raw" toggle and a whole-definition copy action.
- The Summary tab carries what each page header carried: for a run the
status/outcome/executing chip row, recorded + completed visits, pipeline
id/version, stage, workspace, content hash, start/finish/duration and the
failure diagnostic; for a pipeline the name, id/version, stages, content hash,
created/updated, latest version/version-created and the version list.
- Code-like content (Input, Output, Source, session transcripts, per-field and
evidence data, diagnostics) renders through one themed `ui/components/
CodeBlock.kt` card: `surfaceContainer` role, default rounded shape, a small
label header, a whole-block copy action (`LocalClipboardManager`) and monospace
at the shared size/line height, with a bounded height that scrolls internally
instead of pushing the page. `maxHeight = null` renders a block unbounded so the
surrounding page scrolls as a whole (the Source tab uses this); the default
bounded behaviour is unchanged for every other caller. Blank content renders
nothing, and no raw bordered monospace box remains.
- Inside each tab the existing `LazyListScope.collapsibleSection` (`SectionHeader`)
provides inner sections where content naturally breaks down: Output per result
field, Input per labelled part, Steps per stage group and Evidence per entry.
Each defaults to expanded and its collapsed set is `rememberSaveable`, so it
survives configuration changes; the sections are items of the tab's single
`LazyColumn`, so no scrollable nests inside a same-direction scrollable.
- Foldable-responsive layout driven by window size (`ui/WindowSize.kt`,
`isWideLayout(widthDp)` at a 600dp breakpoint, read from
`LocalConfiguration.current.screenWidthDp`): both window widths use one
adaptive sliding pane stack (`ui/components/SlidingPaneStack.kt`) — pane 0 is
the pipeline (or run) list, pane 1 the selected detail and pane 2 the selected
stage/graph node. On a **narrow** window there is no stack and no peek: every
opened pane is a full-window screen that slides in over the last, and Back,
the back gesture or the pane's own back control returns one level with nothing
left over on the left. On a **wide** window the panes stack, but the space the
covered panes reserve is one fixed budget shared between them
(`PEEK_BUDGET_DP`), so the active (topmost) pane's left edge is always exactly
the budget and its width never shrinks as levels are added; the leftmost strip
is widened first so it stays tappable after the gesture inset, and the rest of
the budget is split evenly. Tapping a covered pane's peek closes every pane to
its right. There is no collapse control, no collapsed strip and no master-pane
width constant any more. The section index presentation does follow
the window width: a narrow window shows the tab row across the top, a wide
window the always-visible side rail, with the text column capped at a
comfortable width and the graph using the extra width. No material3-adaptive
dependency is added.
- Both detail screens' sections are still collapsible via the shared
`SectionHeader`: tapping a header toggles it, an animated chevron rotates with
the state, the header sticks to the top of the list while its content scrolls
under an opaque background, and the state is exposed to accessibility
(`"Steps, expanded"`). Expanded state is `rememberSaveable`, per section and
per screen, defaulting to expanded. Real lists (versions, steps, session
evidence) are items of the one outer list, so nothing nests a scrollable.
- Steps render as a timeline in run detail: a leading status glyph connected to
the next step by an outcome-coloured line (kept aligned with the step title),
the stage with its sequence and an outcome chip. A step's metadata is a set of
aligned label/value rows (`KeyValueRow`) — paired side by side in two columns on
a wide window and stacked in one column on a narrow one — with a single
consistent vertical rhythm (one bottom gap per step, no doubled gap when a step
has no expandable detail) and full-width monospace evidence cards. Every
retained field stays: status, outcome, duration, visit/maxVisits/limitReached/
model target, target, session id, agent active, diagnostic and, behind the
collapsed-by-default detail, input, output, transcript, file changes (including
binary/truncated and skipped) and notification receipts.
- The runs list is grouped by day (`Today`/`Yesterday`/date, newest first) under
sticky headers, with the usage aggregates as a metrics block (total, average
via `formatDuration`, and colour-coded succeeded/failed/canceled/interrupted/
active counts). Each card shows the pipeline name with a version chip, a
colour-coded status chip with a distinct icon per state
(running/queued/succeeded/failed/canceled/interrupted/active/unknown), a meta
row (run id, start time, duration) and the diagnostic only when non-blank,
clamped to two lines. The raw `resultPreview` is no longer printed, and
progress is shown honestly (completed visits + current stage, with an
indeterminate indicator while executing; no invented total).
- One centralised type scale (`ui/theme/Typography.kt`, passed to
`MaterialTheme` and exposed as named roles) defines the screen/app-bar title,
section header, card title, subtitle/meta, body and monospace data, applied on
the list and both detail screens.
- Run history with server `usage` aggregates, and run details with steps
(status/outcome/diagnostic/session/transcript/file changes/notifications/
control evidence). Session evidence is scoped to the selected run and each
record is rendered (sequence/session id/backend/directory/data/diagnostic) on
demand via `get_run_evidence`; it is never part of the 1s poll.
- A shared connection banner above every screen surfaces a distinct
Idle/Connecting/Disconnected state with a Reconnect action (and stays hidden
while connected), so a dropped connection is not just a generic request error.
- Start run (confirmation dialog; sends `PipelineID`, `Version`, a reused
`request_key` ≤128 chars, the configured absolute workspace and `input.prompt`)
and cancel run (confirmation; sends the `RunID`, then refreshes). Retry is
offered only for terminal failed runs.
- A run being polled at a fixed 1s interval is stopped as soon as it is no
longer executing.
## Architecture
```
data/protocol kotlinx.serialization models mirroring internal/protocol/*
(Message, Graph/Stage, RunDetail/RunStep, UsageStats, …) plus
GraphSemantics reproducing internal/tui/graph.go rules.
data/transport ServerUrl validation (mirrors internal/client/config.go) and
PipelinesClient — one reused WebSocket, serialized requests,
client ids matched against replies, unsolicited envelopes
dropped, bounded reconnect backoff.
data SettingsRepository (non-secret prefs) and PipelinesRepository
(typed request builders + per-session graph/detail cache).
ui Compose Material 3 screens, one AppViewModel, navigation.
```
## Verification status
Verified on macOS with the host toolchain (JDK 17 from Android Studio,
`ANDROID_HOME=/Users/alan/Library/Android/sdk`, Gradle 8.11.1 `--offline`):
- `:app:compileDebugKotlin`, `:app:assembleDebug` and `:app:testDebugUnitTest`
all succeed; **53 unit tests, 0 failures** (protocol model, graph semantics,
server URL, workflow-graph layout including the terminal row, bottom exits,
back edges, orthogonal routing/axis alignment, arrowhead direction, the
shared panel height and the new `zoomAbout` anchor/clamp cases, plus duration
formatting, run-state mapping and run day-grouping). Re-run with
`--rerun-tasks` to confirm.
- The debug APK was installed and driven on the `Pixel_Fold_API_36` emulator
(Android 16, `adb shell cmd uimode night yes`) against a live server at
`ws://10.0.2.2:8080/connect` with workspace `/Users/alan/repos/pipelines`.
Settings, pipeline list (all 9 pipelines), pipeline detail, the workflow graph,
run history and run detail were captured to `captures/` and
`captures/style_pass/` (both git-ignored) and reviewed.
- `adb logcat` for the app package contained no `FATAL EXCEPTION`, Compose or
other runtime exception during the sweep.
- The orthogonal-edge / resizable-panel pass was verified the same way: a
baseline APK was built from the pre-change tree and installed, then the new
build was installed and driven to the 4-stage pipeline-detail graph and a
run-detail graph with the executed route highlighted. `captures/graph_pass/`
(git-ignored) holds `pipeline_detail_before/after` and `run_detail_before/after`
pairs plus a panned state and the expanded panel after tapping the toggle
(`pipeline_detail_expanded_after`, `run_detail_panned_after`,
`run_detail_expanded_after`). A review of that pass found the expanded panel
scrolled below the fold (blank) and the PNGs prefixed by an adb stderr warning,
so the expand now scrolls the panel into view and the after-captures were
re-taken with a display id (`adb exec-out screencap -p -d <display-id>`) so no
warning leaks into the files. `adb logcat` showed no `FATAL EXCEPTION` and no
app/Compose exception during the sweep.
Known limitations of that run: pinch-zoom could not be driven through `adb`
(single-touch pan only) and one portrait Fold viewport was used. A follow-up pass
fitted the graph to its viewport on first layout, clamped panning so the content
cannot leave the view, added a "Fit graph to view" action, connected on launch
when a server URL is already saved, and made the completed/recorded visit wording
and the outcome-label contrast consistent. The fitted graph still sits slightly
above the box's vertical centre, because the layout box includes padding that is
not drawn. A later style pass made the theme dark-first (app-owned scheme; the
launch window/bar colours match it) and moved the `#failure`/`#success` terminals
to a lower row beneath the stage row; before/after captures for the theme, graph
and app bar/style are under `captures/style_pass/` (`*_before.png` are the
pre-change baseline referenced by the task, `*_after.png` are the new build).
The Runs-area pass (centroid zoom, collapsible sticky sections, runs list, steps
timeline, type hierarchy) was verified the same way on the `Pixel_Fold_API_36`
emulator (dark mode, `adb shell cmd uimode night yes`) against the live server:
the debug APK was installed, the list/detail/step flows were driven with
`adb shell input` and `uiautomator dump`, and captures were written to
`captures/runs_pass/` (git-ignored): `runs_list_top`,
`runs_list_scrolled_sticky` (a `13 Oct 2026` header pinned under the app bar),
`runs_list_states`, `runs_card_interrupted`, `run_detail_top`,
`run_detail_graph_collapsed`, `run_detail_steps`, `run_detail_step_expanded`,
`run_detail_sticky_section` (a `Steps, expanded` header pinned mid-list),
`pipeline_detail_sections`, `pipeline_detail_section_collapsed`,
`pipeline_graph_panned` and `pipeline_graph_fit`. `adb logcat` for the app
package contained no `FATAL EXCEPTION` or Compose/other runtime exception during
the sweep. As before, `adb` cannot synthesise a two-finger pinch, so the
centroid-anchored zoom is verified primarily by the `zoomAbout` unit tests and
the on-device graph was exercised with pan + "Fit graph to view" only.
The tabs / code-block / foldable pass was verified on the same
`Pixel_Fold_API_36` emulator (dark mode, `adb shell cmd uimode night yes`) against
the live server: `:app:testDebugUnitTest` reported **60 tests, 0 failures**
(including new `WindowSizeTest` for `isWideLayout` at 400/600/800 and
`DetailTabsTest` for the tab lists and `clampTabIndex`) and `:app:assembleDebug`
succeeded. The debug APK was installed and driven; captures were written to
`captures/tabs_pass/` (git-ignored): every run-detail tab (`05_run_summary`,
`06_run_graph`, `07_run_input`, `08_run_output`, `10_run_evidence`,
`11_run_steps`), every pipeline-detail tab (`01_pipeline_summary`,
`02_pipeline_graph`, `03_pipeline_source`), a long Input/Output block showing the
themed card scrolling internally (`07_run_input`/`08_run_output`, whose block
`ScrollView` measures the 320dp cap), a collapsed inner section
(`09_run_output_collapsed`, `"input, collapsed"`), a step's expanded evidence code
blocks (`12_run_step_expanded`) and the wide two-pane layouts with the vertical
tab rail (`13_wide_runs_split`, `14_wide_run_summary`, `15_wide_pipelines_split`,
`16_wide_pipeline_summary`, `17_wide_pipeline_graph`). Tab-selection persistence
across a configuration change was exercised by switching `wm density` 390→401
with the run detail open; the selected tab stayed selected
(`18_before_config`, `18_after_config`). `adb logcat` for the app package
contained no `FATAL EXCEPTION` and no Compose/other runtime exception.
The space-usage pass (collapsible icon rail, roomier Steps, rendered Source tab)
was verified on the same `Pixel_Fold_API_36` emulator (dark mode after
`adb shell cmd uimode night yes`) against the live server at
`ws://10.0.2.2:8080/connect`:
- `:app:testDebugUnitTest` reported **76 tests, 0 failures** (up from 60:
new `StageDetailSheetTest` for the stage/step field derivation and
`StepMetaTest` for the step metadata pairing + details predicate, plus the
icon/rail-width assertions in `DetailTabsTest` and the file-change/notification
formatting in `FormatTest`). `:app:assembleDebug` and `:app:installDebug`
succeeded; the install reported `Installed on 1 device` (the emulator — no
physical device was attached at install time).
- Captures were written with `adb -s emulator-5554 shell screencap -p
/sdcard/shot.png` followed by `adb -s emulator-5554 pull` (never
`exec-out … >`), to `captures/space_pass/` (git-ignored):
`narrow_pipeline_top_tabs` (narrow window, tabs across the top),
`source_tab_narrow` (rendered definition) and `source_tab_raw_narrow` (the
`Raw` toggle revealing the exact markdown), `wide_source_rail_expanded`
(icon+label rail, Source tab) and `wide_source_rail_collapsed` (icon-only rail,
content visibly wider), `wide_run_steps_expanded` and
`wide_run_steps_expanded_rail_collapsed` (a step with the two-column metadata
grid — Status/Outcome, Duration/Visit, Target/Session — and full-width Input/
Output/File-changes/Transcript cards), plus `wide_graph_stage_sheet` (tapping a
stage on the Graph tab still opens the refactored `StageDetailSheet`). No
clipping, even step spacing and a height-filling Source tab were confirmed by
eye.
- Rail-collapse persistence across a configuration change was exercised by
collapsing the rail on a detail screen and switching `wm density` 390→401: the
activity recreated and the collapsed strip stayed collapsed (`Expand tabs` was
still the control's description after the change; capture
`wide_detail_rail_collapsed_config_change`). The saved tab index is clamped by
`clampTabIndex` (unit-tested), so a stale index never indexes out of bounds.
- The wide layout was exercised by resizing the emulated display
(`adb shell wm size 2000x3400`, ≈820dp at density 390) and reset afterwards
(`wm size reset`); the attached Pixel 10 Pro Fold was never used and no run was
started from the app.
- `adb -s emulator-5554 logcat -d` contained 0 `FATAL EXCEPTION` lines and 0
`E AndroidRuntime` lines. The emulator was stopped with `adb emu kill`; no
`qemu-system-aarch64-headless` process survived.
Because `adb` cannot physically fold the phone, the wide two-pane/rail layout was
exercised on the emulator by resizing the emulated display (`adb shell wm size
2000x3400`, ≈820dp at density 390) and the narrow single-pane layout at the
default width (1080px ≈ 443dp); the attached Pixel 10 Pro Fold was not used to
drive the app. Note that `:app:installDebug` installs to *every* connected
device: that Gradle task therefore also (re)installed the debug APK on the
attached Pixel 10 Pro Fold; all device-driving commands targeted the emulator
serial (`adb -s emulator-5554`) explicitly. The emulator was stopped with
`adb emu kill` plus `kill -9` of the surviving `qemu-system-aarch64-headless`.
## Distinct graph colours, Timeline + visit tabs, real list pane, floating pill
Four UI changes were verified on the same `Pixel_Fold_API_36` emulator (dark mode
after `adb shell cmd uimode night yes`) against the live server at
`ws://10.0.2.2:8080/connect`. Nothing in the Pipelines server, its Go source,
Docker/compose files or the installer was touched, no run was started from the
app, and the attached Pixel 10 Pro Fold was never driven (the debug APK was
installed with `adb -s emulator-5554 install -r`, not `:app:installDebug`, so the
physical device was not re-installed by this pass either).
- **Graph colours.** `GraphPalette` is a curated, fixed palette plus a pure
deterministic outcome→index mapping (no `hashCode() % 4`). `error` stays the
theme error role and `success` the theme tertiary (positive); every other
outcome uses one palette colour for both its edge stroke and its label text.
Node fills differ by kind (`GraphNodeKind`: terminal success, terminal failure,
model, ntfy, other/custom); a selected stage inverts (light fill / dark text)
plus a 4px border, and executed-vs-dimmed alpha still applies on top. WCAG
contrast is *measured*: `GraphPaletteTest` checks the helper against known
reference ratios (white/black 21, `#777`/white 4.48) and asserts every palette
colour is ≥ 4.5:1 against `DarkSurface 0xFF0E1513` (measured values range from
8.63:1, `approved`, to 13.78:1, `fast`; `success` 11.73:1 and `error` 10.89:1 as
the dark scheme supplies them).
- **Timeline + visit tabs.** The run-detail `Steps` tab is renamed `Timeline`
(key kept `steps`); it renders one compact line per recorded visit (stage,
visit number, outcome chip, duration and a brief diagnostic/target description)
and nothing else — the heavy evidence moved entirely into the shared
`StageDetailSheet`. The sheet now takes a stage's ordered `runSteps` plus an
`initialVisitIndex` and shows a `visit 1..N` tab row only when there is more
than one visit; the timeline opens on the tapped visit and the graph on the
most recent. `runStepFields` gained the step Input/Output blocks, so the sheet
still carries status, outcome, duration, visit/max/limit, model target, target,
session, agent, diagnostic, transcript, input, output, file changes,
notifications and the stage definition.
- **Real list pane.** Pipelines and runs now share one `ListRow` (a single flat
`Surface`, thin `HorizontalDivider`, leading element + title + secondary line,
no per-row elevation) instead of a card per item. The selected row uses the
same tonal `secondaryContainer`/`onSecondaryContainer` treatment as the tab
rail and destinations, exposed as `selectable` selected state; opening a row
selects it and Back clears it. The wide list pane collapses to a 56dp strip
(`rememberSaveable`), with the freed width going to the detail.
- **Floating destination pill.** The bottom `NavigationBar` is replaced by a
floating rounded `Surface` at the bottom right holding the three destinations
as 48dp icon targets, inset by the Scaffold's system-bar padding plus 16dp;
selected state is a tonal circle plus `Role.Tab` selected semantics (not colour
alone). The same pill is used on **both** window widths (no compact strip);
the app reserves 88dp at the bottom so no scrollable content is hidden behind
it.
- **Icons.** Icons are taken from `material-icons-extended` (already declared in
`app/build.gradle.kts`/`libs.versions.toml`, BOM-managed — no new dependency
and no non-offline Gradle invocation was needed; the artifact was already in
the cache). Mapping: Pipelines → `AccountTree`, Runs → `History`, Settings →
`Settings`; Graph tab → `Hub`, Timeline → `AutoMirrored.List`, Input →
`AutoMirrored.Input`, Output → `AutoMirrored.Send`, Evidence →
`AutoMirrored.FactCheck`, Source → `Code`; run statuses → Running
`AutoMirrored.DirectionsRun`, Queued `Schedule`, Succeeded `CheckCircle`,
Failed `Error`, Canceled `Cancel`, Interrupted `PauseCircle`, Active `Bolt`,
Unknown `AutoMirrored.HelpOutline`. The debug APK is ~17 MB; note that
`app/build.gradle.kts` sets `release { isMinifyEnabled = false }`, so R8 does
**not** strip unused extended icons in the current release config (that
stripping only applies to a minified build).
- `:app:testDebugUnitTest` reported **93 tests, 0 failures** (new
`GraphPaletteTest`, `TimelineTest`, `PipelinesNavTest`; extended
`StageDetailSheetTest` and `DetailTabsTest`; `StepMetaTest` was removed with the
inline metadata grid it covered). `:app:assembleDebug` succeeded.
- Captures were written with `adb -s emulator-5554 shell screencap -p
/sdcard/shot.png` followed by `adb -s emulator-5554 pull` (never
`exec-out … >`), to `captures/nav_timeline_pass/` (git-ignored):
`01_launch`, `02_runs_narrow` (narrow lists + pill), `04_timeline` (the concise
Timeline tab), `05_sheet_from_timeline_visits` (sheet from the timeline opening
on the tapped visit 1, with visit tabs), `05b_sheet_single_visit_no_tabs` (a
single-visit stage shows no tab row), `06_sheet_run_section` (Input/Output in
the sheet), `07_run_graph` (executed route highlighted), `08_sheet_from_graph`
(same stage opened from the graph, on the most recent visit 2),
`09_pipeline_4stage_graph` + `_2x`, `10_pipeline_1stage_graph` + `_2x`,
`11_wide_pane_expanded`, `12_wide_pane_selected`, `13_wide_pane_collapsed`,
`14_wide_runs_pane`, `15_wide_run_detail`, and the icon close crops
`16_pill_wide_2x`, `17_tabs_wide_2x`, `18_runstatus_icons_2x`,
`18b_failed_status_2x`, `19_pill_narrow_2x`.
- `adb -s emulator-5554 logcat -d` contained 0 `FATAL EXCEPTION` lines and no
Compose runtime exception. The wide layout was exercised with
`adb shell wm size 2000x3400` (≈820dp at density 390); the emulator was stopped
with `adb emu kill` plus `kill -9` of any surviving
`qemu-system-aarch64-headless`.
## Per-visit artifacts, collapsed defaults, single top inset, APK publish (15 Oct 2026)
Four changes were implemented in `android/` only. Nothing in the Pipelines
server, its Go source, Docker/compose files or the installer was touched, no run
was started from the app, and the 8 MiB per-file artifact cap
(`internal/server/artifacts.go` `maxArtifactFileBytes`) was left unchanged.
- **Artifacts.** `RunStep` now models the server's `artifacts`
(`StageArtifact{name, size_bytes, content_type, url}`), `artifacts_skipped` and
`artifacts_truncated` with the exact `internal/protocol/runs.go` wire names.
`ui/graph/Artifacts.kt` renders one row per file (name, `humanBytes` size,
content type) with an open (`ACTION_VIEW`) and a copy-link action, an inline
image thumbnail (OkHttp + `BitmapFactory` with `inSampleSize` off the main
thread, bytes cached once per URL) and a full-size view on tap; other types get
a type icon. URLs are resolved by `ServerUrl.resolveArtifactUrl` against the
configured server URL (ws→http/wss→https, `/connect` dropped), never a
hardcoded host; with no URL configured the actions are disabled and a hint is
shown. Empty/partial states reuse the TUI strings from
`internal/tui/file_changes.go`. The Timeline rows carry a subtle `AttachFile`
indicator (`hasArtifacts`) with a per-visit `contentDescription`.
- **Collapsed defaults + self-describing titles.** `SectionExpansionState` now
persists the set of *expanded* keys (default empty), so every inner section in
the run detail (input/output/evidence) and pipeline detail (Versions, Source)
starts collapsed while operator choices still survive configuration changes.
Evidence section titles are built by `evidenceSectionTitle`, e.g.
`Evidence - step 4, ui_reviewer visit 1, opencode`, correlating
`SessionEvidence.sequence` with the run's steps once per data change; a blank
field key already falls back to its prefix and never yields an empty title.
- **Top inset.** The outer `Scaffold` in `PipelinesApp` now uses
`contentWindowInsets = WindowInsets(0, 0, 0, 0)` so the inner Material 3 app
bars own the status-bar inset exactly once (removing the duplicate top band);
the floating pill clears the navigation bar via
`windowInsetsPadding(WindowInsets.navigationBars)`. While the connection banner
is visible it owns the status-bar inset (padding inside its `Surface`) and the
`NavHost` below consumes `statusBars` so the app bar is not double-padded.
- **APK publish.** `:app:assembleDebug` produced
`app/build/outputs/apk/debug/app-debug.apk` (18,181,943 bytes, sha256
`41c9df314da40bb19df7e3d90f27a83339a275768cefee537c4ba796efe01eab`, rebuilt
after the follow-up fixes below), copied to
`~/.local/share/pipelines/data/artifacts/58/1/pipelines-debug-d00bd37.apk`
(`d00bd37` = short SHA of the last commit touching `android/`) with a matching
`shasum -a 256`. At 17.3 MiB it exceeds the 8 MiB per-file inventory cap
(`internal/server/artifacts.go` `maxArtifactFileBytes = 8 << 20`), so it is
served by direct URL but deliberately absent from the step inventory.
### Follow-up fixes (code review of the first pass)
- `ui/graph/Artifacts.kt` hoists its derivations with `remember(step)` /
`remember(artifact.url, configuredServerUrl)` / `remember(artifact)` so the
summary text, the partial-capture notes, the resolved URL, the image test and
the meta line are computed once per data change, never per recomposition.
- `ArtifactBytesCache` is a byte-bounded `LruCache` (16 MiB) rather than an
unbounded map, so a long session cannot retain every fetched artifact.
- `artifactCaptureNotes` returns no notes for an empty artifact list, matching
`internal/tui/file_changes.go` `artifactLines` (which returns nothing when the
list is empty); the empty-state summary is unchanged.
- The field-section title fallback is the pure `fieldSectionTitle`, covered by
`TimelineTest#fieldSectionTitleFallsBackToPrefixAndIsNeverEmpty`.
Evidence actually obtained in this pass (macOS, JDK 17 from Homebrew
`openjdk@17`, Gradle 8.11.1 from the wrapper cache,
`ANDROID_HOME=/Users/alan/Library/Android/sdk`):
- `:app:testDebugUnitTest` reported **103 tests, 0 failures** (new
`ProtocolModelTest#runStepArtifactsParseWithExactWireNamesOrAbsent`,
`FormatTest` cases for `humanBytes`/`artifactMetaLine`/`artifactsSummary`/
`artifactCaptureNotes`, `ServerUrlTest#resolvesArtifactUrlAgainstTheConfiguredServerUrl`
and `resolveArtifactUrlReturnsNullWhenUnconfiguredOrBlank`,
`DetailTabsTest#sectionsStartCollapsedAndToggleIsRemembered`, and `TimelineTest`
cases for `hasArtifacts`/`evidenceSectionTitle`/`fieldSectionTitle`).
- `:app:assembleDebug` succeeded (18,181,943-byte debug APK).
- `:app:lintDebug` still reports the two pre-existing `NewApi` errors for
`android:windowLightNavigationBar` (minSdk 26) in `res/values/themes.xml` and
`res/values-night/themes.xml`; those files were not modified by this change.
Verified against the live server (running as
`pipelines-server -addr 0.0.0.0:8080`, the app configured
`ws://10.0.2.2:8080/connect`; LAN address `10.0.0.249` from `ipconfig getifaddr en0`):
- The published APK is served at
`http://10.0.0.249:8080/artifacts/58/1/pipelines-debug-d00bd37.apk` (LAN), not a
hardcoded `localhost`/`10.0.2.2` host. `curl -I` returned `HTTP/1.1 200 OK`,
`Content-Type: application/vnd.android.package-archive`, `Content-Length:
18181943`; a streamed `GET` piped to `shasum -a 256` returned
`41c9df314da40bb19df7e3d90f27a83339a275768cefee537c4ba796efe01eab`, equal to the
local `app-debug.apk`.
- Run 55 step 4's real artifacts are served:
`curl -I http://10.0.0.249:8080/artifacts/55/4/graph_crop_error_rejected.png`
→ 200, `image/png`, 52,168 bytes and
`.../swatch_error_vs_rejected.png` → 200, `image/png`, 5,008 bytes.
- The server has no HTTP inventory endpoint (only `GET /artifacts/…`,
`GET /healthz`, `GET /connect`); the step inventory is delivered over the
websocket and clips entries larger than `maxArtifactFileBytes` (8 MiB), so the
17.3 MiB APK is intentionally absent from it.
Not verified in this pass — no device was attached (`adb devices` listed no
devices, and no emulator was running): the on-device/emulator narrow/wide
before/after screenshots for the top inset and the collapsed sections, the
`logcat` sweep and the install on the Pixel 10 Pro Fold. The previous pass's
emulator screenshots for the artifacts sheet (narrow/wide run detail) are in
`~/.local/share/pipelines/data/artifacts/58/3/`.
## Sliding master/detail, right-opening sections, no collapse (15 Oct 2026)
> **Superseded** by the pane-stack pass below (same day): the shared host is now
> `ui/components/SlidingPaneStack.kt` (three levels), Back no longer steps the
> section index, and the stage detail is a pane — there is no
> `SlidingMasterDetail.kt`, `RightSlidingPanel` or `ModalBottomSheet` in the
> tree. The bullets and evidence here record what that pass did at the time.
The collapse-based master/detail interaction was replaced by a sliding one, in
`android/` only. No Pipelines server/Go/Docker/installer file was touched, no run
was started from the app, and colours, the graph and the information shown are
unchanged — only the navigation model and its geometry.
- **Removed, not repaired.** `CollapsedListPane`, the `onTogglePane` parameter
and the "Collapse list pane" `IconButton` on both list top bars, `LIST_PANE_WIDTH`
(`360.dp`) and `COLLAPSED_LIST_PANE_WIDTH` (`56.dp`), and the observed-side rail
collapse (`RailToggle`, `railWidthDp`, `COLLAPSED_RAIL_WIDTH_DP`,
`WIDE_RAIL_WIDTH_DP` collapse branch, "Collapse tabs") are all gone; the wide
rail is always visible as the section index. `ui/CollapseRemovalTest.kt` scans
`src/main/java` for those identifiers and fails if any return. The old
full-screen `pipeline/{id}/{version}` and `run/{id}` routes were removed, so
`destinationSelected` is a plain route equality.
- **One shared host, one slide.** `ui/components/SlidingMasterDetail.kt` is used
by both the Pipelines and Runs destinations at both window widths: the list
fills the window and the detail overlays it, sliding in from the right via a
single `animateDpAsState(spring())` until a peek strip stays visible; a rapid
run of taps only retargets that one animator, so the pane always settles fully
open or fully closed (never half-slid). The detail width is `measuredWidth -
peek` (never hardcoded) and the list behind is hidden from accessibility and
made non-interactive while the detail is open, so TalkBack focus follows the
visible pane and a tap can never select a row through the peek.
- **The peek geometry is derived, with one named token.** `PEEK_WIDTH_DP`
(`56.dp`) is the only new dimension literal; the actual peek is
`peekWidthDp(minimumInteractive, startInset) = maxOf(PEEK_WIDTH_DP,
minimumInteractive + startInset)`, so the tappable strip left after the left
system-gesture inset is still at least `LocalMinimumInteractiveComponentSize`
(48dp). The strip is positioned clear of the status/nav bars and the gesture
area by offsetting/­sizing it with `WindowInsets.systemBars ∪
WindowInsets.systemGestures` (read once per layout), and it carries the content
description "Back to list". No other numeric literals were added (the animation
uses the default `spring()` with no literal).
- **Sections open to the right.** `DetailTabs` keeps the index fixed in place and
moves the section bodies into a `HorizontalPager` (compose-foundation, already
in the BOM): a tap or a swipe slides the section in, later sections from the
right and earlier ones from the left. Back (`ui/PaneState.kt` `backStep`) is one
level — section > 0 → previous section, section 0 → list, list → app exit — and
the peek tap, the detail's back arrow and the system Back button/gesture all run
that same step. `PredictiveBackHandler` handles the gesture;
`android:enableOnBackInvokedCallback="true"` was added to the manifest.
- **Saved state.** `PaneSelection` (pane, item id/version, section index) is all
primitives with a `Saver`, so the open pane and selected section survive
rotation, configuration change and process death. `rememberPagerState` also
saves the pager page.
- **Secondary surface.** The wide stage-detail overlay reuses the same
right-slide (`RightSlidingPanel`); on a narrow window it deliberately keeps its
`ModalBottomSheet` (a right panel on a phone-width window would crowd the
content, and the sheet is the platform-appropriate narrow surface). The overlay
is hosted at the screen level, a sibling of the tabs, so it covers the
whole detail pane rather than being nested inside a pager page (a pager-nested
copy sized to zero). The pure helpers in `StageDetailSheet.kt` are unchanged, so
no information changed.
Evidence obtained in this pass (macOS, JDK 17 from Homebrew `openjdk@17`, Gradle
8.11.1 from the wrapper cache, `ANDROID_HOME=/Users/alan/Library/Android/sdk`):
- `:app:testDebugUnitTest` reported **112 tests, 0 failures** (new `PaneStateTest`
— pane open, `backStep` at section > 0 / section 0 / list, section ordering and
slide direction, `Saver` round trip and primitive payload; new
`CollapseRemovalTest`; new `SlidingMasterDetailTest` for `peekWidthDp`;
`DetailTabsTest` updated and `PipelinesNavTest` updated for the removed routes).
- `:app:assembleDebug` succeeded. `:app:lintDebug` still reports only the two
pre-existing `NewApi` errors for `android:windowLightNavigationBar` (minSdk 26)
in `res/values/themes.xml` and `res/values-night/themes.xml`; those files were
not modified.
- `grep` over `app/src/main` for the banned collapse identifiers returned nothing.
- The debug APK was installed and driven on the attached Pixel 10 Pro Fold
(`adb -s 58281FDCG000JF`, inner display 2076x2152, density 330 ≈ 1006dp wide)
against a live server (`ws://10.0.0.249:8080/connect`):
- Tapping a pipeline row slid the detail in; `uiautomator dump` showed the
"Back to list" strip at `[61,185][160,1904]` (48dp wide, offset past the ~30dp
left gesture inset and below the status bar) with the list rows absent from
the accessibility tree; tapping the strip's centre closed the detail and
restored all nine rows. A tap in the gesture area (`x = 30 < 61`) selected no
row (the list is blocked).
- Tapping the Graph rail tab (and the narrow top tab row) changed the section
while the rail/tab row and the strip stayed in place; the selected rail node
exposed `selected="true"`.
- `adb shell input swipe 5 1000 900 1000 250` (predictive-back gesture) closed
the detail at section 0, and from Source (section 2) stepped back to Graph
(section 1) — one level.
- A live `wm density` change 330 → 300 → 330 kept the pane open and the section
selected; the narrow layout (`wm size 1080x2340`, ≈524dp) showed the full-width
list, the top tab row index and a 48dp strip, and both the section tab and the
strip back worked there.
- `adb logcat` for the package contained no `FATAL EXCEPTION` or
`AndroidRuntime` error during the sweep, and no run was started from the app.
- `:app:testDebugUnitTest` and the APK build were re-run after the final code
change; the beats above are the final-build run.
- The wide sequence was captured to `captures/` (git-ignored) and mirrored to
the run artifacts: `slide-W1-list`, `slide-W2-detail-peek` (detail slid in,
48dp strip on the left), `slide-W3-section` (Graph tab selected, index still
in place), `slide-W4-back-section` (strip tapped once, back to Summary) and
`slide-W5-closed-list` (strip tapped again, list restored, byte-identical to
`slide-W1-list`); the narrow window (`wm size 1080x2340`, ≈524dp) has the same
set `slide-N1`…`slide-N5` (top tab row, `N3` graph, `N4` back to Summary,
`N5` closed, identical to `N1`).
- The wide stage-detail overlay was driven from both entry points: tapping a
timeline row (`W8-timeline`, `W7-stage-overlay`: the panel slid in with the
"Close stage details" strip at `[221,477][320,1838]`, the `planner` heading and
the `Definition` section, dismissed by tapping the strip) and tapping a graph
node (`W9-graph-stage-overlay`).
- **APK publish.** `app/build/outputs/apk/debug/app-debug.apk` (18,184,868 bytes,
sha256 `7942795c1d979a66e4759a0c3e3f0399d60e256b29ba4a7266dfc52142245ac8`) was
copied to
`~/.local/share/pipelines/data/artifacts/59/2/pipelines-debug-059c85a.apk`
(`059c85a` = `git log -1 --format=%h -- android/`). `curl -I
http://10.0.0.249:8080/artifacts/59/2/pipelines-debug-059c85a.apk` (LAN address
from `python3 scripts/lan-address.py`, never `localhost`/`10.0.2.2`) returned
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18184868`; a streamed `GET | shasum -a 256` returned
`7942795c1d979a66e4759a0c3e3f0399d60e256b29ba4a7266dfc52142245ac8`, equal to the
local file. At 17.3 MiB it exceeds the 8 MiB per-file inventory cap
(`internal/server/artifacts.go`), so it is served by direct URL only.
Not verified in this pass: `onOpenRun` from a pipeline detail to a freshly
started run cannot be exercised without starting a run, so that path is kept
compiling and functional but untested; the predictive-back gesture's frame-by-frame
preview is not driven through `adb`, so its behaviour (one level back) is
verified but not its animation; a real hardware fold to the narrow cover display
was not exercised (narrow was produced with `wm size`); the emulator
(`emulator-5554`) was not used, the physical Pixel was.
## 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. The `paneOffsetDp`/`peekWidthDp` helpers named here no longer
> exist; the bullets record what that pass did at the time.
This pass turned the stage detail into a real pane, made the stack behave like
Back at every level, and added an artifacts gallery to the summary.
- **The stage detail is a pane, not a popup.** `StageDetailSheet` and its
`ModalBottomSheet`/`RightSlidingPanel` branches are gone. `StageDetailPane`
(`ui/graph/StageDetailPane.kt`) is the stage level of the stack, wrapped in the
same `Scaffold`/`TopAppBar` with a back arrow as the other panes. Both entry
points — a Timeline row and a graph node — now set
`PaneSelection(pane = Stage, stageKey, stageVisit)` and open it as the rightmost
pane; the covered graph/timeline is hidden from accessibility and blocked, so
nothing leaks through.
- **Headline-first content.** The identity/result facts (Status, Outcome, Target,
Duration, Visit, Model target; `STAGE_HEADLINE_LABELS`) are rendered outside any
collapsible, so a freshly opened pane never reads as empty. Definition, Input,
Output, Artifacts and the remaining run evidence are collapsible via the shared
`SectionHeader` + `rememberSectionExpansion(stageKey)`. `runStepFields`,
`stageDefinitionFields`, `StageFieldRow`, `StageTypeChip`, `controlVisitLabel`,
`numberFields`/`terminalFields` and the visit tab row are all kept.
- **One three-level stack.** `ui/components/SlidingPaneStack.kt` replaces
`SlidingMasterDetail`: pane 0 fills the host, panes 1 and 2 overlay it at
`paneOffsetDp(level, peek) = peek * level` and `paneWidthDp(hostWidth, level,
peek) = hostWidth - peek * level` (derived from the one named `PEEK_WIDTH_DP`
token and the measured width; no new offsets). Each covered pane keeps exactly
one peek visible and its peek strip is tappable, calling `onPopTo(level)` to
close every pane to its right. `MasterPane { List, Detail, Stage }`, `depth`,
`MAX_PANE_DEPTH = 2`, `backStep` (one pane per step, no section stepping) and
`popTo(selection, level)` are the pure model; `PaneSelection` carries
`stageKey`/`stageVisit` and its saver encodes six primitives.
- **Back and the outside tap agree.** `PredictiveBackHandler` is enabled for
`depth >= 1` and the system Back button/gesture, the peek tap and the pane's
back arrow all run the same one-level step; `backStep(Stage)` → Detail,
`backStep(Detail)` → List, list → app exit.
- **Artifacts gallery.** `ui/ArtifactGroups.kt` has the pure
`runArtifactGroups(steps)` (grouped by stage then visit from `runTimeline`,
stable order, duplicate names kept, empty run → empty) and
`artifactsEmptyMessage(executing)`. `ArtifactGallery` (`ui/graph/Artifacts.kt`)
renders each group's image artifacts as a non-lazy chunked grid of thumbnails
(a tap opens the full-size dialog) and its non-images as rows with name,
`humanBytes` size, content type and open/copy; the Summary tab shows the run
gallery and the stage pane's Artifacts section shows that visit's group plus the
unchanged `Artifacts · N recorded` summary and capture notes. Every url resolves
through `ServerUrl.resolveArtifactUrl` (no hardcoded host), and
`ArtifactImage`/`ArtifactBytesCache` remain the single loader.
Evidence obtained in this pass (macOS, JDK 17 from Homebrew `openjdk@17`, Gradle
8.11.1 from the wrapper cache, `ANDROID_HOME=/Users/alan/Library/Android/sdk`,
`--offline`):
- `gradle :app:testDebugUnitTest` reported **122 tests, 0 failures** (rewritten
`PaneStateTest` — three levels, `depth`, `MAX_PANE_DEPTH`, `backStep` at each
level, `popTo` levels and the six-primitive saver; renamed `SlidingPaneStackTest`
— `peekWidthDp` plus `paneOffsetDp`/`paneWidthDp`; new `ArtifactGroupsTest` —
grouping/order, duplicates kept, empty run, visit numbers vs `runTimeline`,
running-vs-finished empty message; `StageDetailSheetTest` gained the
headline/evidence split assertions). `CollapseRemovalTest` still passes.
- `gradle :app:assembleDebug` succeeded (18,198,400 bytes). `gradle :app:lintDebug`
still reports only the two pre-existing `NewApi` errors for
`android:windowLightNavigationBar` in `res/values/themes.xml` and
`res/values-night/themes.xml`.
- `rg -n 'ModalBottomSheet|StageDetailSheet' android/app/src/main` and
`rg -n 'https?://' android/app/src/main/java/net/awan/pipelines/ui/graph` both
return nothing; `git diff --stat` shows no change under `android/gradle` or the
`build.gradle.kts` dependency blocks.
- On `emulator-5554` (2076x2152, density 390 ≈ 851dp wide; **never** the attached
Pixel) against the live server `ws://10.0.0.75:8080/connect` (LAN address from
`python3 -c` importing `scripts/lan-address.py`; the script has no `__main__`,
so it prints nothing when run directly):
- Summary of run 58 showed the grouped gallery (`reviewer · visit 1` header, then
a grid of `Preview of …png`); tapping a thumbnail opened the full-size dialog
(`02_sheet_ui_reviewer_top.png`); a non-image row showed `EVIDENCE.md`,
`3.0 KiB · text/plain; charset=utf-8`, `Open`/`Copy` `enabled="true"`.
- Tapping the Timeline row `reviewer · visit 1` opened the stage pane as level 2
with two peeks visible (`Back to runs` at `[73,165][190,1859]`, `Back to run`
at `[190,165][380,1859]`) and the headline facts shown unexpanded
(`reviewer`/`model`, `Status completed`, `Outcome rejected`, `Duration 7m 41s`,
`Visit 1 / 3`, `Target implementer`); Definition/Input/Output/Artifacts/This run
were collapsed. Tapping the graph node `Stage reviewer` opened the same pane
(`Status completed`, `Outcome success`, `Visit 2 / 3`, `Target ui_reviewer`).
- Tapping the detail peek (`285 1000`) → depth 1 (`Back to runs` only); tapping
the list peek (`130 1000`) → depth 0 (list, no strips). `input keyevent 4` at
depth 2 → depth 1, at depth 1 → depth 0; the predictive-back swipe
`input swipe 5 1000 900 1000 250` at depth 2 → depth 1.
- `settings put system user_rotation 1` (config change) kept depth 2 and the
`reviewer`/visit 1 selection; after `am kill net.awan.pipelines` (verified
`pidof` empty) the relaunch restored the same depth and selection.
- The stage pane's Artifacts section expanded to `Artifacts · 6 recorded` plus
the visit's thumbnails; run 60 (executing) showed the run empty state
`Artifacts · capture pending`.
- `adb logcat -d | grep -c 'FATAL EXCEPTION'` and `… | grep -c 'E AndroidRuntime'`
both returned 0; no run was started from the app.
- **APK publish.** `app/build/outputs/apk/debug/app-debug.apk` was copied to
`…/artifacts/60/2/pipelines-debug-059c85a.apk` (`059c85a` =
`git log -1 --format=%h -- android/`); `shasum -a 256` matched. `curl -I
http://10.0.0.75:8080/artifacts/60/2/pipelines-debug-059c85a.apk` returned 200
with `Content-Type: application/vnd.android.package-archive` and a
`Content-Length`; a streamed `GET | shasum -a 256` equalled the local file. At
17.3 MiB it exceeds the server's 8 MiB per-file inventory cap, so it is served
by direct URL only.
Not verified in this pass: a different graph node tapped *while the stage pane is
open* is not reachable because the covered graph is intentionally blocked, so the
"selection replaces the rightmost pane at depth 2" invariant is covered by the
`PaneStateTest` bound/`popTo` tests rather than by a device tap; the unconfigured
(disabled open/copy) gallery row and the finished-run "no artifacts recorded" empty
state were not exercised (only the running "capture pending" one); the
predictive-back animation frames and pinch-zoom were not driven through `adb`; the
narrow layout was not separately exercised (the stage pane no longer branches on
width); the physical Pixel was not touched.
### 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.** `ArtifactGallery` now measures the row once with
`BoxWithConstraints` and calls the pure `artifactTileDp(availableWidth, columns,
spacing, preferred)` (the widest that fits, capped at the preferred
`ARTIFACT_TILE_DP`), so three tiles and their gaps always fit the pane. The only
new named token is `ARTIFACT_TILE_SPACING_DP` (`8.dp`), shared by the row
arrangement and the fitting; no magic offsets.
- **Dead code removed.** `ArtifactRow` no longer carries an unreachable image
branch (the gallery passes it only non-image artifacts); it renders the file
glyph, name and `artifactMetaLine` with open/copy.
- **No duplicated derivation.** `runArtifactGroups` reuses `runTimeline`'s display
visit number (`entries` → `(stage, sequence) → visit`) instead of re-deriving
`control.visit ?: index + 1`.
- **Docs corrected.** The current-architecture bullet and the superseded
`SlidingMasterDetail`/`RightSlidingPanel`/`ModalBottomSheet` references above were
updated; the previous pass's section is marked superseded.
- New unit test `ui/graph/ArtifactGalleryTest`: narrow width shrinks the tile so
the row never overflows, a width that fits keeps the preferred tile, exact fit
and degenerate inputs.
Evidence obtained in this follow-up (macOS, JDK 17 from Homebrew `openjdk@17`,
Gradle 8.11.1 from the wrapper cache, `ANDROID_HOME=/Users/alan/Library/Android/sdk`,
`--offline`):
- `gradle :app:testDebugUnitTest` reported **127 tests, 0 failures, 0 errors**
(the 5 new `ArtifactGalleryTest` cases included); `CollapseRemovalTest` still
passes. `gradle :app:assembleDebug` succeeded (17,830,569 bytes).
`gradle :app:lintDebug` still reports only the two pre-existing `NewApi` errors
for `android:windowLightNavigationBar` in `res/values/themes.xml` and
`res/values-night/themes.xml`.
- `rg -n 'ModalBottomSheet|StageDetailSheet|RightSlidingPanel|SlidingMasterDetail'
android/app/src/main` and `rg -n 'https?://'
android/app/src/main/java/net/awan/pipelines/ui/graph` both return nothing;
`git diff --stat` shows no change under `android/gradle` or the
`build.gradle.kts` dependency blocks.
- On `emulator-5554` (never the attached Pixel) against the live server
`ws://10.0.0.75:8080/connect`:
- Run 58 Summary showed the gallery grouped by stage/visit; at the wide
(851dp, density 390) size the tiles measured 234px (96dp).
- Setting `wm size 1080x1920` + `wm density 480` (360dp): the Summary gallery's
three tiles measured 78dp and the third's right edge (`[798,492][1032,582]`
→ x=1032) coincided with the pane content edge — no clipping. In the depth-2
stage pane (`Artifacts, expanded`) the three tiles measured 52dp
(`[516,796][672,952]`, `[696,…][852,…]`, `[876,…][1032,…]`) and also reached
the pane edge exactly; the non-image `emulator.log` row showed
`10.8 KiB · text/plain; charset=utf-8` with enabled `Open`/`Copy`.
- Timeline row → stage pane (depth 2, two peeks) and graph node → stage pane both
opened with the headline facts visible (`reviewer`/`model`, `Status completed`,
`Outcome rejected`/`success`, `Duration`, `Visit`, `Target`) and every other
section collapsed. Detail peek (`285 1000`) → depth 1; list peek (`131 1000`)
→ depth 0; `input keyevent 4` at depth 2 → depth 1 and at depth 1 → depth 0;
the predictive-back swipe `input swipe 5 1000 900 1000 250` at depth 2 →
depth 1.
- A `wm density` 480 → 440 change kept depth 2 with the `reviewer` visit-1
selection and the expanded Artifacts section; after `am kill net.awan.pipelines`
(verified `pidof` empty) and relaunch, the same depth and selection returned.
- `adb -s emulator-5554 logcat -d` contained 0 `FATAL EXCEPTION` and 0
`E AndroidRuntime` lines; no run was started from the app.
- **APK publish.** `app/build/outputs/apk/debug/app-debug.apk` (17,830,569 bytes,
sha256 `6ac6004e9d4bc29d30457cc99009c226df7157dae2b41f07fa7c8a7a46a40498`) was
copied to `…/artifacts/60/4/pipelines-debug-059c85a.apk` (`059c85a` =
`git log -1 --format=%h -- android/`); `shasum -a 256` matched. `curl -I
http://10.0.0.75:8080/artifacts/60/4/pipelines-debug-059c85a.apk` returned
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 17830569`; a streamed `GET | shasum -a 256` equalled the local
file.
Not verified in this follow-up: a different graph node tapped *while the stage pane
is open* (the covered graph stays blocked, so the replace-the-rightmost invariant
is covered by the `PaneStateTest` bound/`popTo` tests only); the explicit gallery
empty states (the run 60 card already carried artifacts during this sweep, so
neither the "capture pending" nor the finished "no artifacts recorded" message was
seen on device — both are covered by `ArtifactGroupsTest`/`artifactsEmptyMessage`);
the unconfigured (disabled open/copy) gallery row; the predictive-back animation
frames and pinch-zoom (adb cannot drive a two-finger pinch).
## Adaptive pane navigation and a fixed peek budget (15 Oct 2026)
The pane stack was made adaptive to the window width and its peek space changed
from one peek per level to a single fixed budget shared between the covered
panes. `android/` only; nothing in the Pipelines server, its Go source, the
Docker/compose files, the installer or the dependency blocks was touched, no run
was started from the app, and the attached Pixel 10 Pro Fold was never installed
on or driven (the debug APK was installed with `adb -s emulator-5554 install -r`).
- **Narrow windows: no stack, no peek.** `SlidingPaneStack` gained a `wide`
parameter (the callers pass the existing `isWideLayout` value). On a narrow
window the peek budget is `0.dp`, so every pane's open offset is `0` and each
pane is a full-window screen; a covered pane is fully hidden, there is no strip
and nothing is left over on the left. Tapping a list row or a stage/graph node
opens the pane with the existing `spring()` slide from the right edge; Back,
the predictive-back gesture and the pane's own top-bar back control all run the
same one-level `backStep`.
- **Wide windows: one fixed peek budget.** The total space the covered panes
reserve is `PEEK_BUDGET_DP` (`224.dp`, a named token), never `peek * level`, so
the stack consumes the same width however deep it gets. `paneOpenOffsetsDp`
places the active pane at exactly the budget — its width is therefore
`hostWidth - budget` at every depth, constant as levels are added — and shares
the budget between the covered panes, widening the leftmost strip first so that
after the left gesture inset (`systemBars ∪ systemGestures`) its tappable part
is still at least `PEEK_WIDTH_DP` (`56.dp`) and the platform minimum
interactive size, then splitting the rest evenly. At two levels the one covered
pane takes the whole budget; at three the budget is split in two; at four (four
panes, three covered) it is split in three.
- **Named tokens, no literals.** `PEEK_WIDTH_DP` (`56.dp`), `PEEK_BUDGET_DP`
(`224.dp`) and `MIN_ACTIVE_PANE_WIDTH_DP` (`320.dp`) live beside the stack;
`peekBudgetDp` clamps the budget so the active pane never collapses on a small
host (`hostWidth - MIN_ACTIVE_PANE_WIDTH_DP`), and `paneWidthDp` is never
negative. Everything else is derived from the measured width and the insets.
- Both models keep the other pane rules: opening and closing are exact mirrors
(the same offsets and `spring()` retarget in reverse), panes are opaque, the
peek strips are inset inside the status/nav bars and the gesture area, and a
section inside a detail is a selection on its own tab row, never a navigation
level.
Evidence obtained in this pass (macOS, JDK 17 from Homebrew `openjdk@17`, Gradle
8.11.1 from the wrapper cache, `ANDROID_HOME=/Users/alan/Library/Android/sdk`,
`--offline`):
- `gradle :app:testDebugUnitTest` reported **130 tests, 0 failures, 0 errors**
(the rewritten `SlidingPaneStackTest` has 8 cases: narrow spends no peek at any
depth, the wide active pane's width is constant across depths, four levels share
the one fixed budget with every strip at least the named minimum, the first
strip clears the gesture inset, the budget clamps so the active pane never
collapses, a tiny host never yields negative geometry, offsets are monotonic and
deterministic, and widths are host-less-offset and never negative).
- `gradle :app:assembleDebug` succeeded (17,990,397-byte debug APK, sha256
`b7ba9d600031f09472b06fff4c06cd50ec93b995cf7b1f7bf8a2115846a8e602`).
- On `emulator-5554` (2076x2152, density 390 ≈ 852dp wide; **never** the attached
Pixel) against the live server `ws://10.0.0.75:8080/connect`, driven with
`adb shell input` and `uiautomator dump`:
- Wide, `uiautomator dump` of the peek strips: at two levels the single strip
was `[73,165]–[546,1859]`, i.e. `[30dp, 224dp]` — the whole budget after the
~30dp left gesture inset; at three levels the two strips were `[73,165]–[273,
1859]` and `[273,165]–[546,1859]`, i.e. `[30dp,112dp]` and `[112dp,224dp]`.
The active pane therefore starts at `224dp` at both depths — its width is
constant — and the two covered strips sum to the same `224dp` budget.
- Narrow (`wm size 1080x1920`, `wm density 480`, ≈360dp): the list, the detail
and the stage pane each filled the window (`uiautomator dump` listed **no**
`Back to …` strips at any depth), a row tap opened the detail (`Summary` tab
present) and the predictive-back swipe `input swipe 5 1000 900 1000 250`
returned to the list.
- `adb -s emulator-5554 logcat -d` contained 0 `FATAL EXCEPTION` and 0
`E AndroidRuntime` lines after a clean sweep; no run was started from the app.
- Screenshots and recordings were written to the run's artifacts directory:
`wide-1-level-list.png`, `wide-2-levels-detail.png`, `wide-3-levels-stage.png`,
`narrow-1-level-list.png`, `narrow-2-levels-detail.png`,
`narrow-3-levels-stage.png`, `wide-open-close.mp4` (opening two and three
levels then closing) and `narrow-open-close.mp4` (opening and closing the
detail). The four-level layout (four panes, three covered) is not reachable in
the app, which has exactly three pane levels (`MasterPane.List/Detail/Stage`);
the shared budget at four levels is covered exactly by the
`SlidingPaneStackTest` geometry cases instead.
- **APK publish.** `app/build/outputs/apk/debug/app-debug.apk` was copied to
`…/artifacts/61/1/pipelines-debug-wip-5314542.apk` (`5314542` =
`git rev-parse --short HEAD`); `shasum -a 256` matched. `curl -I
http://10.0.0.75:8080/artifacts/61/1/pipelines-debug-wip-5314542.apk` returned
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 17990397`; a streamed `GET | shasum -a 256` equalled the local
file. At 17.2 MiB it exceeds the server's 8 MiB per-file inventory cap, so it is
served by direct URL only.
Not verified in this pass: the four-level layout on a device (unreachable — the
app has three pane levels); the predictive-back animation frames (adb cannot drive
a two-finger pinch and the frame-by-frame preview is not captured); the wide
recording's final close-detail frame lands at the end of the clip. The narrow
layout was produced with `wm size`/`wm density` (a real hardware fold was not
exercised).
## Sections change in place, not sideways (15 Oct 2026)
Selecting a section in a run or pipeline detail now swaps the section body in
place instead of sliding it in from the side. `android/` only; nothing in the
Pipelines server, its Go source, the Docker/compose files or the installer was
touched, no run was started from the app, no dependency was added, and the
attached Pixel 10 Pro Fold was not installed on or driven (every device command
targeted `emulator-5554`).
- **In-place swap instead of a pager.** `ui/components/DetailTabs.kt` no longer
uses a `HorizontalPager` for the section bodies. The selected section
cross-fades in place behind a `Crossfade` (`SECTION_SWAP_MILLIS = 180`), so a tap
on the rail/tab row is an ordinary tab change with no lateral motion and nothing
to swipe. `Crossfade` comes from `androidx.compose.animation:animation`, already
on the compile classpath transitively via `androidx.compose.foundation` (no new
dependency was declared; `gradle/libs.versions.toml` and the dependency blocks
are unchanged). Only the selected section is composed at rest.
- **Level navigation still slides.** The `SlidingPaneStack` (list → detail → stage
pane) is untouched, so navigation between levels keeps its `spring()` slide; only
the section selector inside a detail changed.
- **The rail's selected state is kept.** The narrow `PrimaryScrollableTabRow` and
the wide selectable rail are unchanged; selection is still `Role.Tab` + selected
semantics plus the tonal container, never colour alone.
- **A section's scroll position is not reset on return.** Each section's saved
state (its `LazyColumn` scroll) is kept under its stable tab key with
`rememberSaveableStateHolder().SaveableStateProvider(tab.key)`, so leaving and
returning to a section restores where the operator left off (this matches the
previous pager's per-page saved state).
- The two call sites' stale "pager composes only the visible section" comments were
updated; no other behaviour changed.
Evidence obtained in this pass (macOS, JDK 17 from Homebrew `openjdk@17`, Gradle
8.11.1 from the wrapper cache, `ANDROID_HOME=/Users/alan/Library/Android/sdk`,
`--offline`):
- `gradle :app:testDebugUnitTest :app:assembleDebug` → `BUILD SUCCESSFUL in 2s`;
the test-result XMLs aggregate to **130 tests, 0 failures, 0 errors, 0 skipped**
(the existing `DetailTabsTest` still covers the tab lists and `clampTabIndex`).
- `app/build/outputs/apk/debug/app-debug.apk` is 17,990,397 bytes, sha256
`ef467eaafd9cd7662167c17229a39281683aed6c890c48c9fabf0a1e3ed04172`.
- On `emulator-5554` (2076x2152, density 390 ≈ 852dp wide; **never** the attached
Pixel) against the live server `ws://10.0.0.75:8080/connect` (run 58, seven
completed visits), driven with `adb shell input`:
- A 13s `screenrecord` of tapping Summary → Graph → Input → Output → Evidence →
Timeline (`after-section-swap.mp4`), with stills of each section
(`after-run-summary/graph/evidence/timeline.png`): the rail's selected state
moves and the body changes, and an extracted mid-transition frame
(`frame-3.65.png`) shows the outgoing and incoming panels overlapping **at the
same x** — a cross-fade, not a slide.
- The same sequence on the pre-change build (built from `HEAD` in a throwaway
`git worktree`, installed as a baseline) recorded as `before-section-slide.mp4`
and frame `before-frame-2.05.png`: the outgoing panel is visibly shifted left
with the incoming panel entering from the right — the old lateral slide, by
contrast.
- Scroll preservation: Summary was scrolled down, Graph selected, then Summary
re-selected; `scroll-summary-returned.png` matches `scroll-summary-scrolled.png`
(Finished/Duration/Artifacts still on screen), not the top.
- `adb -s emulator-5554 logcat -d` contained 0 `FATAL EXCEPTION` and 0
`E AndroidRuntime` lines; no run was started from the app.
- **APK publish.** `app-debug.apk` was copied to
`~/.local/share/pipelines/data/artifacts/62/1/pipelines-debug-wip-0b373d0.apk`
(`0b373d0` = `git rev-parse --short HEAD`); `shasum -a 256` matched. `curl -I
http://10.0.0.249:8080/artifacts/62/1/pipelines-debug-wip-0b373d0.apk` (LAN
address from `ipconfig getifaddr en0`, never `localhost`/`10.0.2.2`) returned
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 17990397`; a streamed `GET | shasum -a 256` returned
`ef467eaafd9cd7662167c17229a39281683aed6c890c48c9fabf0a1e3ed04172`, equal to the
local file. At 17.3 MiB it exceeds the server's 8 MiB per-file inventory cap, so
it is served by direct URL only.
Not verified in this pass: the cross-fade's exact duration/frames beyond the single
extracted frame and the 180 ms spec; a real hardware fold (the wide layout is the
emulator's default 852dp); the narrow top-tab-row presentation (the emulator was
driven wide only) — the narrow selector code is unchanged and shared, so this is a
presentation difference the existing `WindowSizeTest`/`DetailTabsTest` still cover
where they can. The `after-section-swap.mp4` frame is the only mid-transition
sample taken; `before-frame-2.05.png` is the only baseline mid-slide sample.
## Run stage pane: surface Model/Provider in the headline (16 Oct 2026)
The report was "the adaptive-panes change lost the stage screen's content: only the
title, the model chip and one collapsed Definition remain". That symptom is the
**definition-only** branch of `StageDetailBody` (`selectedStep == null`, i.e. no
recorded visits). It is what a *pipeline* stage pane (`PipelineStagePane`, level 2
of the Pipelines destination) legitimately shows, and it is exactly what the run-61
artifacts (`~/.local/share/pipelines/data/artifacts/61/1/wide-3-levels-stage.png`,
`narrow-3-levels-stage.png`) capture — those screenshots are the Pipelines
destination, not the Runs one, so they are the expected definition-only look and not
the regression. Re-driving the current build from the Runs destination does **not**
reproduce the loss: from a Timeline row (`implementer · visit 2`, run 60) and from a
graph node the pane showed Status/Outcome/Duration/Visit/Target, the visit tab row
(visit 2 selected), and Definition/Input/Output/Artifacts/This run collapsed with
their content on expansion. No regression was present at `791d3dd`.
The one real gap against the requested headline facts was that the stage's recorded
`Model`/`Provider` configs lived only inside the collapsed Definition section (they
were always visible in the pre-pane sheet). They are now promoted to the
always-visible headline, without duplication:
- `ui/graph/StageDetailPane.kt` gained the pure `STAGE_CONFIG_HEADLINE_LABELS`
(`{"Model", "Provider"}`), `stageConfigHeadlineFields(definition)` and
`remainingDefinitionFields(definition)`. `StageDetailBody` renders
`headlineFields(runFields) + stageConfigHeadlineFields(definition)` as the
headline and `remainingDefinitionFields(definition)` inside the collapsed
Definition section, so a promoted row is never rendered twice. Both derivations
are `remember(definition)`-keyed; the run-evidence split stays
`runStepFields`/`headlineFields`/`evidenceFields`.
- Deliberate change to account for: the Definition section (collapsed by default)
no longer repeats Model/Provider, because they are now headline facts. Everything
else in Definition is unchanged (`Type`, `Prompt`, `Output`, `Outcomes`, the other
configs, `Tools`, limits, memory, notify).
- `StageDetailSheetTest` gained
`definitionModelAndProviderArePromotedToTheHeadlineWithoutDuplication` and
`aDefinitionWithNoConfigsPromotesNothing`.
Evidence obtained in this pass (macOS, `ANDROID_HOME=/Users/alan/Library/Android/sdk`;
`gradle :app:testDebugUnitTest :app:assembleDebug` under the default Homebrew JDK 27,
lint under JDK 17 as noted):
- `gradle :app:testDebugUnitTest :app:assembleDebug` → `BUILD SUCCESSFUL`; the
test-result XMLs aggregate to **132 tests, 0 failures, 0 errors, 0 skipped**.
`app/build/outputs/apk/debug/app-debug.apk` is 17,991,256 bytes, sha256
`2252e6964cd73f1d666da24f3684bd8e0b79cf3e07e0fdc018842a4f1cab2ccf`.
- `gradle :app:lintDebug` under JDK 17 fails only on the two **pre-existing**
`NewApi` errors for `android:windowLightNavigationBar` in
`res/values/themes.xml` and `res/values-night/themes.xml` (unchanged by this
pass); under the default Homebrew JDK 27 the lint worker crashes at dispose
(`NoClassDefFoundError: org.jetbrains.uast.UastFacade`), so JDK 17 is required.
- On `emulator-5554` (narrow 1080x1920/density 480 ≈ 360dp; wide 2076x2152/density
390 ≈ 852dp; **never** the attached Pixel) against the live server
`ws://10.0.0.75:8080/connect`, driven with `adb shell input`, screenshots in
`~/.local/share/pipelines/data/artifacts/64/2/`:
- `narrow_run61_facts_collapsed.png` / `wide_facts_collapsed.png`: the headline
(Status/Outcome/Duration/Visit/Target/Model/Provider) unexpanded and all five
sections collapsed.
- `narrow_run61_artifacts_expanded.png` / `wide_facts_artifacts_expanded.png`:
Artifacts expanded to `Artifacts · 8 recorded · partial capture`, the capture
note and the thumbnail grid.
- `wide_facts_definition_expanded.png`: Definition expanded with no duplicated
Model/Provider row.
- `narrow_run60_visit_tabs_facts.png` /
`narrow_run60_graph_node_stage.png`: a multi-visit stage (`visit 1`/`visit 2`
tabs, starting on the tapped/most-recent visit) opened from a Timeline row and
from a graph node, with the promoted Model/Provider.
- `previous_behaviour_nav_timeline_pass_05.png` is the pre-pane sheet
(`android/captures/nav_timeline_pass/05_sheet_from_timeline_visits.png`) for
comparison. The run-60/4 artifact _files_ used by its gallery are corrupt (their
`.png` bytes begin with the `adb screencap` "Multiple displays" warning), so its
thumbnails correctly show the `!` decode-error placeholder; run 61's valid
artifacts render normally.
- `adb -s emulator-5554 logcat -d | grep -c 'FATAL EXCEPTION'` and
`… | grep -c 'E AndroidRuntime'` each returned 0; no run was started from the
app.
- **APK publish.** `app-debug.apk` was copied to
`~/.local/share/pipelines/data/artifacts/64/1/pipelines-debug-wip-791d3dd.apk`
(`791d3dd` = `git rev-parse --short HEAD`); `shasum -a 256` matched. `curl -I
http://10.0.0.249:8080/artifacts/64/1/pipelines-debug-wip-791d3dd.apk` (LAN
address from `ipconfig getifaddr en0`, never `localhost`/`10.0.2.2`) returned
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 17991256`; a streamed `GET | shasum -a 256` returned
`2252e6964cd73f1d666da24f3684bd8e0b79cf3e07e0fdc018842a4f1cab2ccf`, equal to the
local file.
Not verified in this pass: the reported "content lost" symptom could not be
reproduced at `791d3dd`, so there is no before/after diff of a fixed regression;
the "definition-only, never-visited stage" and blank status/outcome edge cases are
covered by the existing unit tests (`StageDetailSheetTest`, `FormatTest`) rather than
driven on the device; the narrow/wide gallery thumbnail failure for run 60's corrupt
artifacts is a data issue in that run, not re-tested against a repaired copy.
## Covered panes show a compact identity, with a minimum peek width (16 Oct 2026)
A wide-window stack no longer squeezes a full pane into each covered peek: a
covered pane now renders only its compact identity (a title and at most one
status/subtitle, centred in its strip) and its full body — tab rail, list,
gallery, scroll body — is never drawn into a sliver. `android/` only; nothing in
the Pipelines server, its Go source, the Docker/compose files or the installer was
touched, no dependency was added, no run was started from the app, and the
attached Pixel 10 Pro Fold was never installed on or driven (the debug APK was
installed with `adb -s emulator-5554 install -r`).
- **Compact covered panes.** `SlidingPaneStack`'s `pane` lambda now receives a
`covered: Boolean`; on a wide window a covered level is composed inside a box
constrained to its visible strip, and the caller renders only
`ui/components/PaneIdentity.kt` — a centred title plus at most one
status/subtitle line. The list (`PipelineListScreen`/`RunHistoryScreen`), both
detail screens and the stage pane each gained a `covered` branch that
early-returns after their data-loading effects, so nothing heavy is composed
into a sliver. The strip itself stays a separate, higher tappable sibling and
the compact identity rides with the pane's own slide.
- **A named minimum covered width, and a fold.** `MIN_COVERED_PANE_WIDTH_DP`
(`112.dp`) is the least width a covered pane's compact identity needs.
`peekStripsDp` shows at most `budget / MIN_COVERED_PANE_WIDTH_DP` covered peeks;
when a stack has more covered levels than that, the oldest levels fold into a
single edge indicator (`"<n> more"`) rather than being squeezed below the
minimum, and the number of peeks shown shrinks instead of their width. The fixed
budget (`PEEK_BUDGET_DP`, `224.dp`) and the constant active-pane width are
unchanged.
- **Unchanged behaviour.** Tapping a covered pane's peek calls the same
`onPopTo(level)`, closing everything to its right; Back/gesture/back arrow and
the narrow (no-peek) layout are untouched.
Evidence (macOS, JDK 17 from Homebrew `openjdk@17`, Gradle 8.11.1,
`ANDROID_HOME=/Users/alan/Library/Android/sdk`, `--offline`):
- `gradle :app:testDebugUnitTest` reported **134 tests, 0 failures, 0 errors**;
`gradle :app:assembleDebug` succeeded (17,992,288-byte debug APK, sha256
`3923224136be7ef9bdd8eb87111fae1f6af0211a7ba070af0e5270e324a0fc93`). The
rewritten `SlidingPaneStackTest` has 10 cases (narrow spends no peek, the wide
active pane is constant width at every depth, two covered levels each keep the
minimum, a fourth level folds the oldest into one indicator carrying its count,
the newest level still peeks, the first strip clears the gesture inset, the
budget clamps, a tiny host never goes negative, strips are monotonic and
deterministic, and widths are host-less-offset).
- On `emulator-5554` (2076x2152, density 390 ≈ 852dp wide; **never** the attached
Pixel) against the live server `ws://10.0.2.2:8080/connect`, driven with
`adb shell input` and `uiautomator dump`:
- Wide, `uiautomator dump` of the peek strips: at two levels the single strip
was `[73,165]–[546,1859]` (`[30dp, 224dp]` after the ~30dp left gesture
inset); at three levels the two strips were `[73,165]–[273,1859]` and
`[273,165]–[546,1859]` (`[30dp,112dp]` and `[112dp,224dp]`), so the active
pane still starts at `224dp` (constant width) and each covered pane now keeps
at least `112dp` for its identity.
- Narrowest wide size (`wm size 1463x2152`, density 390 = 600dp): the same
`224dp` budget, strips `[73,127]–[273,1859]` and `[273,127]–[546,1859]`; both
compact identities stayed readable and the active pane was full.
- Tapping the detail peek (`409 1000`) at three levels popped to the detail
(only `Back to pipelines` left); tapping the list peek (`173 1000`) popped to
the list (no strips). `input keyevent 4` at depth 2 returned to depth 1 (one
`Back to pipelines` strip).
- Narrow (`wm size 1080x1920`, `wm density 480`, ≈360dp): opening a pipeline
showed **0** `Back to …` strips and the detail tabs as before.
- `adb -s emulator-5554 logcat -d` contained 0 `FATAL EXCEPTION`; no run was
started from the app.
- Screenshots were written to the run's artifacts directory:
`wide-2-levels.png` (the list covered as `Pipelines · 11 on this server`),
`wide-3-levels.png` (list and detail covered, stage active) and
`wide-narrowest.png` (600dp); `wide-2-levels-after-peek.png` is the state
after the peek tap.
- **APK publish.** `app/build/outputs/apk/debug/app-debug.apk` was copied to
`…/artifacts/65/1/pipelines-debug-wip-206953e.apk` (`206953e` =
`git rev-parse --short HEAD`); `shasum -a 256` matched. `curl -I
http://10.0.0.249:8080/artifacts/65/1/pipelines-debug-wip-206953e.apk` (LAN
address from `ipconfig getifaddr en0`) returned `HTTP/1.1 200 OK`,
`Content-Type: application/vnd.android.package-archive`, `Content-Length:
17992288`; a streamed `GET | shasum -a 256` equalled the local file. At 17.2 MiB
it exceeds the server's 8 MiB per-file inventory cap, so it is served by direct
URL only.
Not verified in this pass: the four-level / folded layout on a device — the app
has exactly three pane levels (`MasterPane.List/Detail/Stage`, `MAX_PANE_DEPTH =
2`), so the fold is unreachable and its rule is covered by the pure
`SlidingPaneStackTest` cases instead; a long covered detail title wraps to three
centred lines and ellipsizes (e.g. `Pipelines maintenance - plan implem…`) rather
than being rotated.
## An app-owned run-status palette (16 Oct 2026)
Run status had the wrong hue for its two most important states because it was
mapped onto Material roles: `primary` (mint) made a **running** run read green and
`tertiary` (amber) made a **succeeded** run read yellow. `android/` only; nothing
in the Pipelines server, its Go source, the Docker/compose files or the installer
was touched, no dependency was added, no run was started from the app, and the
attached Pixel 10 Pro Fold was never installed on or driven (every `adb`/emulator
command targeted `emulator-5556`; lane A's `emulator-5554` was not used).
- **A new app-owned palette.** `ui/components/RunStatusPalette.kt` defines one
`Entry(colour, rationale)` per status, fixed (not scheme-derived) so a status
reads the same on every device, with a one-line reason each: Running/Active
blue, Succeeded green, Failed the app error red, Interrupted amber, Canceled
muted grey, Queued neutral grey, Unknown the low-key surface grey.
`runStateColor` is now a pure function over this palette (no `MaterialTheme`), so
it is asserted in a plain JVM test. Each state keeps its distinct material glyph
and text label, so status is never colour alone.
- **The graph outcome palette is unchanged.** `GraphPalette` and the terminal
`success`/`error` roles are untouched; run status and stage outcome stay
different vocabularies. The runs-list **Timeline** step chips (and their leading
glyphs) previously rendered through `runStateOf`/`StatusChip`, i.e. the run-status
mapping, so they were pointed at the graph's outcome palette instead: they now
call the shared `graphColors(scheme)` factory (extracted from `WorkflowGraph`,
which uses it too) and `outcomeColor`, so a step chip agrees with the graph.
The run header and runs-list cards keep the run-status palette.
- **Shared helper.** `ui/components/RunStatus.kt` gained `ColoredChip(label,
colour, icon, …)` — the single pill layout now used by both `StatusChip` (run
status) and the Timeline's outcome chip, instead of a second copy.
Evidence (macOS, JDK 17 from Homebrew `openjdk@17`, Gradle 8.11.1,
`ANDROID_HOME=/Users/alan/Library/Android/sdk`, `ANDROID_SDK_ROOT` set,
`--offline`):
- `gradle :app:testDebugUnitTest` reported **143 tests, 0 failures, 0 errors**
(new `RunStatusPaletteTest`: WCAG-AA contrast ≥ 4.5:1 for every status colour
against `DarkSurface 0xFF0E1513`, Succeeded green and ≠ `DarkTertiary`, Running/
Active blue and ≠ `DarkPrimary`, Failed = `DarkError`, Interrupted amber and ≠
Failed, Queued near-grey and ≠ Running, and a non-blank rationale per status).
`gradle :app:assembleDebug` succeeded (18,009,527-byte debug APK, sha256
`17f52f23e40f4ba0c524ac2929adfd6a8f39353e68ccdeedb2e029019225e350`).
- On `emulator-5556` (`FoldB_API_36`, 2208x1840, density 420) in dark mode
(`adb shell cmd uimode night yes`) against the live server
`ws://10.0.2.2:8080/connect`, driven with `adb shell input` and `uiautomator
dump`. Every capture below was written with `android/scripts/capture_png.sh -s
emulator-5556` (which names the SurfaceFlinger display id and validates the PNG
magic bytes), and a validated screenshot was pixel-sampled to read the rendered
colour back:
- **Before** (pre-change tree, `git stash` build): runs-list usage values were
Succeeded `#F2C879` (amber), Running card `#6FD3B8` (mint); a run header read
`#F2C879` (succeeded) and `#6FD3B8` (running) — the reported bug, `captures` in
`runs_list_before.png`, `run_header_before.png`, `run_header_running_before.png`.
- **After**: runs-list usage values were Succeeded `#7FE0A8` (green), Failed
`#FFB4AB` (error red), Canceled `#889391` (muted), Interrupted `#E8C06A`
(amber), Active `#7FB2F0` (blue); the running card was `#7FB2F0` and the
succeeded card `#7FE0A8` (`runs_list_after.png`). A run header read `#7FE0A8`
(succeeded) and `#7FB2F0` (running) (`run_header_after.png`,
`run_header_running_after.png`).
- **Timeline agrees with the graph**: before, a graph-only outcome still went
through the run-status mapping — an `approved` step chip sampled `#BEC9C5`
(the run-status `Unknown` grey). After, the `success` step chip sampled
`#F2C879` (the graph's tertiary terminal role) and the `approved` chip
`#C0A3F5` (`GraphPalette` index 5), both equal to the graph's `outcomeColor`
(`run_timeline_before.png`, `run_timeline_after.png`).
- `adb -s emulator-5556 logcat -d` contained 0 `FATAL EXCEPTION` / `E
AndroidRuntime` lines (the only app-matched lines were expected
`InputDispatcher … Consumer closed input channel` warnings from the
force-stop/reinstall).
- **APK publish.** `app/build/outputs/apk/debug/app-debug.apk` was copied to
`…/artifacts/69/1/pipelines-debug-wip-cd85f69.apk` (`cd85f69` = `git rev-parse
--short HEAD`); `shasum -a 256` matched. `curl -I
http://10.0.0.249:8080/artifacts/69/1/pipelines-debug-wip-cd85f69.apk` (LAN
address from `ipconfig getifaddr en0`) returned `HTTP/1.1 200 OK`,
`Content-Type: application/vnd.android.package-archive`, `Content-Length:
18009527`; a streamed `GET | shasum -a 256` equalled the local file. At 17.2 MiB
it exceeds the server's 8 MiB per-file inventory cap, so it is served by direct
URL only.
### Re-verified against the committed tree (run 72, 16 Oct 2026)
The change above is committed at `24584d8`; re-checked independently on that exact
tree (JDK 17 from Homebrew `openjdk@17`, Gradle 8.11.1, `--offline`):
- `gradle --offline :app:testDebugUnitTest --rerun` → **143 tests, 0 failures, 0
errors** (`RunStatusPaletteTest` 7/7, including the per-status WCAG-AA contrast
check). `gradle --offline :app:assembleDebug` succeeded; the APK is 18,009,527
bytes, sha256 `17f52f23e40f4ba0c524ac2929adfd6a8f39353e68ccdeedb2e029019225e350`.
- Before/after captured on `emulator-5556` (`sdk_gphone16k_arm64`, 2208x1840,
density 420, dark mode) with `android/scripts/capture_png.sh -s emulator-5556`.
The pre-change build was produced from a clean `git archive cd85f69` tree (never
a working-tree stash), and each capture was pixel-sampled to read the rendered
colour back:
- **Before**: runs-list usage Succeeded `#F2C879` (amber) and Active `#6FD3B8`
(mint); run 69 header `#F2C879`, run 72 header `#6FD3B8`; the `approved`
Timeline chip `#BEC9C5` (run-status `Unknown` grey).
- **After**: Succeeded `#7FE0A8` (green), Failed `#FFB4AB`, Canceled `#889391`,
Interrupted `#E8C06A`, Active `#7FB2F0`; run 69 header `#7FE0A8`, run 72 header
`#7FB2F0`; the `approved` Timeline chip `#C0A3F5` (graph palette index 5) while
the `success` chip stays `#F2C879` (the graph's tertiary role), so a step chip
agrees with the graph. `logcat` after a fresh launch had 0 `FATAL EXCEPTION` /
`E AndroidRuntime` lines.
- **APK publish.** `app/build/outputs/apk/debug/app-debug.apk` copied to
`…/artifacts/72/1/pipelines-debug-wip-24584d8.apk` (`24584d8` = `git rev-parse
--short HEAD`); `curl -I
http://10.0.0.249:8080/artifacts/72/1/pipelines-debug-wip-24584d8.apk` returned
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18009527`, and a streamed `GET | shasum -a 256` matched.
## Last-run facts on every pipeline row (16 Oct 2026)
`android/` only. No server field was added: the whole run history already arrives
from `list_runs` (`internal/pipeline/runs.go`, id DESC), so the join is
client-side.
- **Pure join.** `ui/screens/PipelineLastRun.kt` adds `pipelineRunBadges(runs, now)`,
which folds the history onto a `Map<Long, PipelineRunBadge>` keyed by
pipeline id with `runId`, `state` (`runStateOf`), `ranAgo` and `duration`.
Recency comes from the run timestamps, not the input order — the higher run id
breaks an exact tie (or a missing/blank `created_at`), so an unsorted or
partial response is still correct. `PipelineRunBadge.metaLine()` formats
`ago · duration · run N` and drops any fragment that is genuinely absent (a
still-running run has no `finished_at`); it never prints a blank separator.
`formatRanAgo` mirrors the `formatDuration` integer rhythm (`just now`, then
`Nm ago`/`Nh ago`/`Nd ago`) and clamps clock skew to `just now`. A pipeline with
no run is simply absent from the map and the row prints the explicit
`NO_RUNS_RECORDED`
("no runs recorded") instead of a blank line. The last-run line is withheld
until `runsState.data != null` (`runsKnown`), so a not-yet-loaded history never
makes the false "no runs recorded" claim.
- **Row.** `PipelineListScreen.kt` refreshes runs alongside pipelines, anchors
"now" once per composition (`remember`), and renders the chip + meta line in a
`Row` under the unchanged title/secondary lines; the selected-row highlight is
untouched.
- **Tests.** `test/.../PipelineLastRunTest.kt` (10 cases) covers most-recent-wins
on unsorted input, no runs, unknown pipeline id, equal timestamps, an
unparseable timestamp, an unknown status word (`RunState.Unknown`, id still
rendered), each `formatRanAgo` scale plus blank/bad input, and the
`NO_RUNS_RECORDED` wording.
Verified on this tree (macOS, JDK 17 from Homebrew `openjdk@17`, Gradle 9.7.1,
`ANDROID_HOME=/Users/alan/Library/Android/sdk`):
- `gradle :app:testDebugUnitTest` → **153 tests, 0 failures, 0 errors, 0
skipped** (`PipelineLastRunTest` 10/10).
- `gradle :app:assembleDebug --rerun-tasks --no-build-cache` succeeded →
`app-debug.apk` **17,863,337 bytes**, sha256
`b22550660c1ce9f42719eb5a32a296055d9f3df97fa0fd94bb26fa3868730506`. This is a
full rebuild of the current tree; the review's blocker was that the earlier
published `artifacts/83/1/pipelines-debug-wip-5444390.apk` (17,997,811 bytes,
sha256 `0fb07207…`) was a different revision of `PipelineListScreen.kt`, so it
has been rebuilt and republished (see below).
- Screenshots on `emulator-5556` (`FoldB_API_36`, 2208x1840, density 420, dark
mode) with `android/scripts/capture_png.sh -s emulator-5556`: the narrow window
via `adb shell wm size 1080x2340`, the wide window at the default 2208x1840
(`wm size reset`). Both show the running run omitting its duration, the failed
and canceled rows carrying `ago · duration · run N`, and pipeline id 3 "Plan,
implement, review" printing `no runs recorded`.
- **APK publish.** Copied to
`…/artifacts/83/3/pipelines-debug-wip-5444390.apk` (`5444390` = `git rev-parse
--short HEAD`). `curl -I
http://10.0.0.249:8080/artifacts/83/3/pipelines-debug-wip-5444390.apk` returned
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 17863337`, and a streamed `GET | shasum -a 256` returned the
same `b2255066…` as the local file. The same APK was installed on the emulator
and the pulled installed `base.apk` hashed to `b2255066…`, so the reviewed
source is what was actually rendered.