Files
pipelines/android/README.md
T
alan 2bc00a2a94 android: make the conversation readable — markdown, collapsed reasoning, one identity
Fix the three reading problems in the chat conversation view. Android only;
no new dependency (the declared material-icons-extended only); no server,
Go, installer or Docker file touched and no run started from the app.

- Markdown reaches the transcript. Assistant text already went through
  MarkdownText inside a private composable; name the decision as the pure
  ChatFormat.partRendering(part) (MARKDOWN/REASONING/PLAIN/HIDDEN) and have
  MessagePart consume it. Text outside the renderer's documented subset and
  unknown part kinds still render as their own text (PLAIN); blank parts
  render nothing (HIDDEN).
- Reasoning collapsed by default. ReasoningBlock is now one compact, muted
  line per part (icon, label, chevron) that expands on tap to the muted
  text. Expansion is hoisted to the conversation pane as the pure
  ReasoningExpansion set keyed per stable part key, so a part keeps its
  state across scroll/disposal and every part starts collapsed in a newly
  opened chat. A running turn's streaming reasoning stays collapsed under a
  live "Thinking…" label, signalling progress without competing with the
  answer.
- One identity in the header. ChatFormat.conversationHeader(thread) builds
  the app-bar title plus only context (labelled kind chip from the server
  tag, activity, directory, model); the app bar and the context line read
  the same value. openChatsBeside drops the active chat from the open-chat
  strip so its title is shown once; every other open chat stays one tap
  away and the session list is unchanged.

Tests: new ChatTranscriptTest (7 cases) plus the existing ChatFormatTest —
the markdown subset reaches the renderer from a ChatPart, text outside the
subset and an unknown kind still render, reasoning starts collapsed and
toggles per part, the header names the session once, and the strip offers
only the other open chats.

Checked, and none needs an update: the packaged templates carry no Android
chat surface; the repository guidelines (README, docs/) document the server
and CLI, whose behaviour is unchanged — docs/cli.md's note that Android
rendering of the tag is out of scope for the server change still holds; and
the packaged authoring skill references (internal/author/skill/references/)
describe delivery/verification generally, none of which this UI change
alters. android/README.md records the new behaviour.

Verified: `gradle :app:testDebugUnitTest :app:assembleDebug --no-daemon
--offline --rerun-tasks` → BUILD SUCCESSFUL; JUnit XMLs total 508 tests, 0
failures, 0 errors, 0 skipped. app-debug.apk sha256
0df6899429a8f5632ec568340dddb63a5617b1a04af19f52c6ebb793470a0b23.
2026-10-17 15:14:52 +01:00

5851 lines
381 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.
- A **Templates** destination (its own top-level pill between Pipelines and Runs,
with its own gallery glyph rather than the Pipelines workflow tree): a measured
gallery of cards, one per server template, each showing the template's name, its
short description and its stage count — `stage count unavailable` when the source
does not parse, never a claimed zero — with a single column on a narrow window
and as many equal-width cards as fit on a wide one, from the shared
`galleryGrid` fitting (the same rule the artifacts gallery uses) at the
`WIDE_RAIL_WIDTH_DP`/`SPACING_S` tokens, so the gallery widens by adding columns
instead of stretching cards. Tapping a card opens a detail pane that reuses the
pipeline detail's Summary / Graph / Source tabs (the stage list, the
`WorkflowGraph` and the shared `PipelineSourceView`), so the shape is readable
before choosing it; a source the server could not parse is still fully viewable
as raw markdown. A "create from this template" action submits the source as a
create-only draft pipeline (the app's equivalent of `pipelines new --template
KEY`) and never starts a run. Empty, loading and error states reuse the shared
state components.
- Workflow graph composable: content-sized stage nodes laid out in one row in
declaration order, with `#failure`/`#success` terminals sharing a lower row and
arrows entering their top borders (an `error -> #failure` route leaves its
source's bottom); labelled outcome edges (`error*` marks the implicit
fallback), loops and branches, pan/zoom, and run highlighting (under a run the
executed stage/route is a solid full-colour stroke with an arrowhead and a
filled, normal-bordered node, while a not-executed one is a dashed, arrowless
muted stroke with a hollow, dashed-bordered node and a muted label; an executed
`success`/`error` route is drawn noticeably heavier with a stronger same-hue
stroke and a larger arrowhead so pass/fail dominates; a one-line legend names
both states) plus a screen-reader
description. Edges are drawn as
axis-aligned orthogonal polylines like the TUI (`routePoints` computes the
path once per layout and stores it on `EdgeLayout.points`), and each arrowhead
points along its route's final segment rather than the from-to chord. Pinch
zoom is anchored to the gesture centroid: the pure `zoomAbout` keeps the
content point under the fingers fixed (clamped to `MIN_SCALE`/`MAX_SCALE`) and
the existing pan clamp is applied afterwards, so the content no longer slides
away from the fingers. The visual language is a modern surface, not a terminal
diagram: a stage is a rounded rectangle (the theme's `shapes.medium`) and a
terminal a pill, both filled with a tonal surface tinted with the node's
semantic hue behind a soft border (not a flat fill plus hard outline); the node
name and the outcome labels use the app's type scale (`cardTitle`/`label`, no
ad-hoc sizes, no all-caps, terminal `Success`/`Failure` in their own colour);
edges draw with round caps/joins and every right-angle bend is rounded by one
`ROUTE_CORNER_RADIUS` control offset over the unchanged stored polyline, with a
filled arrowhead proportional to its stroke and the outcome label on a rounded
tonal chip rather than raw text over the canvas; node and per-edge-track spacing
are named dp tokens.
- One shared graph-panel height (`collapsedGraphHeight`/`expandedGraphHeight`)
replaces the former 360.dp and 340.dp literals, so both detail screens render
the graph at the same size: about 58% of the window height floored at a height
that still fits a 4-stage graph with its terminal row. The graph's TopEnd
control cluster pairs "Fit graph to view" with an expand/collapse toggle that
grows the panel to about the full window height; the expanded state is stored
in `rememberSaveable` and the panel refits on resize. Because the panel lives
inside each screen's `verticalScroll` column, growing it only extends it below
the fold, so expanding also requests `BringIntoViewRequester` to scroll the
taller panel back into the visible viewport instead of leaving the graph
centred off-screen.
- Dark-first Material 3 theme with an app-owned colour scheme (no dynamic/
wallpaper colour): the dark scheme is the default and the window background and
system bars are dark so launching shows no light flash; a complete light scheme
is retained for when it is explicitly requested.
- Consistent Material 3 top app bars on Pipelines, Runs and Settings (and the
existing back/refresh/start/cancel/retry bars on the detail screens).
- Both detail screens are tabbed via one shared `ui/components/DetailTabs.kt`:
run detail exposes Summary, Graph, Input, Output, Evidence and Timeline, pipeline
detail Summary, Graph and Source, with Summary first and the default. Every tab
carries a meaningful icon alongside its label. The section index stays fixed and
visible while the selected section's panel swaps in place behind a short
`Crossfade`: selecting a section is an ordinary tab change with no lateral
motion, so there is nothing to swipe — the sections are not a left-to-right
pager. Only navigation between levels (list → detail → stage pane) slides, via
`SlidingPaneStack`. Only the selected section is composed at rest, each section
is a single `LazyColumn`, and each section's own saved state (its list scroll
position) is kept under its stable tab key through a
`rememberSaveableStateHolder`, so returning to a section never resets its
scroll. The Graph tab keeps the full-height `WorkflowGraph` panel with its Fit
and expand controls. Narrow windows show a horizontally scrolling
`PrimaryScrollableTabRow`; wide windows show an always-visible selectable rail
(icon + label, no collapse control). `selectedIndex` is the single source of
truth and a tap reports the new index through `onSelect`. The tabs carry real tab
semantics (`Role.Tab` + selected state), so selection is never conveyed by
colour alone, and the selected index is `rememberSaveable` (survives
recomposition, configuration change and process death) and clamped by
`clampTabIndex`.
- The Source tab fills the whole tab area and renders the parsed definition
instead of dumping the raw markdown: one collapsible section per stage (name ·
type) holding labelled blocks for prompt, output, tools, configs, edges
(outcomes with their resolved targets, `#success`/`#failure` named as
terminals), memory, limits and notification policy, skipping what a stage does
not have. The rows come from the same `stageDefinitionFields`/`StageFieldRow`
the stage detail sheet uses, so the two views cannot diverge. The exact source
stays available behind a "Raw" toggle and a whole-definition copy action.
- The Summary tab carries what each page header carried: for a run the
status/outcome/executing chip row, recorded + completed visits, pipeline
id/version, stage, workspace, content hash, start/finish/duration and the
failure diagnostic; for a pipeline the name, id/version, stages, content hash,
created/updated, latest version/version-created and the version list.
- Code-like content (Input, Output, Source, session transcripts, per-field and
evidence data, diagnostics) renders through one themed `ui/components/
CodeBlock.kt` card: `surfaceContainer` role, default rounded shape, a small
label header, a whole-block copy action (`LocalClipboardManager`) and monospace
at the shared size/line height, with a bounded height that scrolls internally
instead of pushing the page. `maxHeight = null` renders a block unbounded so the
surrounding page scrolls as a whole (the Source tab uses this); the default
bounded behaviour is unchanged for every other caller. Blank content renders
nothing, and no raw bordered monospace box remains.
- Inside each tab the existing `LazyListScope.collapsibleSection` (`SectionHeader`)
provides inner sections where content naturally breaks down: Output per result
field, Input per labelled part, Steps per stage group and Evidence per entry.
Each defaults to expanded and its collapsed set is `rememberSaveable`, so it
survives configuration changes; the sections are items of the tab's single
`LazyColumn`, so no scrollable nests inside a same-direction scrollable.
- Foldable-responsive layout driven by window size (`ui/WindowSize.kt`,
`isWideLayout(widthDp)` at a 600dp breakpoint, read from
`LocalConfiguration.current.screenWidthDp`): both window widths use one
adaptive sliding pane stack (`ui/components/SlidingPaneStack.kt`) — pane 0 is
the pipeline (or run) list, pane 1 the selected detail and pane 2 the selected
stage/graph node. On a **narrow** window there is no stack and no peek: every
opened pane is a full-window screen that slides in over the last, and Back,
the back gesture or the pane's own back control returns one level with nothing
left over on the left. On a **wide** window the panes stack, but the space the
covered panes reserve is one fixed budget shared between them
(`PEEK_BUDGET_DP`), so the active (topmost) pane's left edge is always exactly
the budget and its width never shrinks as levels are added; the leftmost strip
is widened first so it stays tappable after the gesture inset, and the rest of
the budget is split evenly. Tapping a covered pane's peek closes every pane to
its right. There is no collapse control, no collapsed strip and no master-pane
width constant any more. The section index presentation does follow
the window width: a narrow window shows the tab row across the top, a wide
window the always-visible side rail, with the text column capped at a
comfortable width and the graph using the extra width. No material3-adaptive
dependency is added.
- Both detail screens' sections are still collapsible via the shared
`SectionHeader`: tapping a header toggles it, an animated chevron rotates with
the state, the header sticks to the top of the list while its content scrolls
under an opaque background, and the state is exposed to accessibility
(`"Steps, expanded"`). Expanded state is `rememberSaveable`, per section and
per screen, defaulting to expanded. Real lists (versions, steps, session
evidence) are items of the one outer list, so nothing nests a scrollable.
- The stage pane (opened from a Timeline row, a run graph node or a run's stage
list) leads with the run's results, not the stage's definition: the stage's
status, outcome, duration and the selected visit's target, then the visit's
artifacts gallery (first), output and input, then the remaining run evidence.
The stage's own definition — type, prompt, output contract, outcomes, model,
provider, configs, tools, limits, memory and notify — moves into one collapsed
`Stage definition` section at the bottom. A pipeline stage pane has no run
context, so its definition section renders expanded as its only content.
Nothing is removed, and the visit tabs still switch the selected visit.
- Steps render as a timeline in run detail: a leading status glyph connected to
the next step by an outcome-coloured line (kept aligned with the step title),
the stage with its sequence and an outcome chip. A step's metadata is a set of
aligned label/value rows (`KeyValueRow`) — paired side by side in two columns on
a wide window and stacked in one column on a narrow one — with a single
consistent vertical rhythm (one bottom gap per step, no doubled gap when a step
has no expandable detail) and full-width monospace evidence cards. Every
retained field stays: status, outcome, duration, visit/maxVisits/limitReached/
model target, target, session id, agent active, diagnostic and, behind the
collapsed-by-default detail, input, output, transcript, file changes (including
binary/truncated and skipped) and notification receipts.
- The runs list is grouped by day (`Today`/`Yesterday`/date, newest first) under
sticky headers, with the usage aggregates as a metrics block (total, average
via `formatDuration`, and colour-coded succeeded/failed/canceled/interrupted/
active counts). Each card shows the pipeline name with a version chip, a
colour-coded status chip with a distinct icon per state
(running/queued/succeeded/failed/canceled/interrupted/active/unknown), a meta
row (run id, start time, duration) and the diagnostic only when non-blank,
clamped to two lines. The raw `resultPreview` is no longer printed, and
progress is shown honestly (completed visits + current stage, with an
indeterminate indicator while executing; no invented total).
- A run still in progress shows the time it has taken so far instead of a
finished duration, everywhere a run's time appears: the runs list meta row,
the pipeline list's last-run line and the run detail summary's Duration row. A
running value is live — recomputed once a second from the server's own
`created_at` (never from when the app loaded, so it stays correct after a
reconnect), using the shared `runDurationText` and a single ticking clock per
screen (`ui/components/LiveTime.kt`) that pauses while the app is backgrounded
and while no shown run is executing. Once the run finishes it keeps its stored
total duration; a missing start omits the value and a future start (clock skew)
reads as `0s` (`FormatTest`, `PipelineLastRunTest`).
- One centralised type scale (`ui/theme/Typography.kt`, passed to
`MaterialTheme` and exposed as named roles) defines the screen/app-bar title,
section header, card title, subtitle/meta, body and monospace data, applied on
the list and both detail screens.
- Run history with server `usage` aggregates, and run details with steps
(status/outcome/diagnostic/session/transcript/file changes/notifications/
control evidence). Session evidence is scoped to the selected run and each
record is rendered (sequence/session id/backend/directory/data/diagnostic) on
demand via `get_run_evidence`; it is never part of the 1s poll.
- A shared connection banner above every screen surfaces a distinct
Idle/Connecting/Disconnected state with a Reconnect action (and stays hidden
while connected), so a dropped connection is not just a generic request error.
- Start run (confirmation dialog; sends `PipelineID`, `Version`, a reused
`request_key` ≤128 chars, the configured absolute workspace and `input.prompt`)
and cancel run (confirmation; sends the `RunID`, then refreshes). Retry is
offered only for terminal failed runs.
- A run being polled at a fixed 1s interval is stopped as soon as it is no
longer executing.
## Architecture
```
data/protocol kotlinx.serialization models mirroring internal/protocol/*
(Message, Graph/Stage, RunDetail/RunStep, UsageStats, …) plus
GraphSemantics reproducing internal/tui/graph.go rules.
data/transport ServerUrl validation (mirrors internal/client/config.go) and
PipelinesClient — one reused WebSocket, serialized requests,
client ids matched against replies, unsolicited envelopes
dropped, bounded reconnect backoff.
data SettingsRepository (non-secret prefs) and PipelinesRepository
(typed request builders + per-session graph/detail cache).
ui Compose Material 3 screens, one AppViewModel, navigation.
```
## Verification status
Verified on macOS with the host toolchain (JDK 17 from Android Studio,
`ANDROID_HOME=/Users/alan/Library/Android/sdk`, Gradle 8.11.1 `--offline`):
- `:app:compileDebugKotlin`, `:app:assembleDebug` and `:app:testDebugUnitTest`
all succeed; **53 unit tests, 0 failures** (protocol model, graph semantics,
server URL, workflow-graph layout including the terminal row, bottom exits,
back edges, orthogonal routing/axis alignment, arrowhead direction, the
shared panel height and the new `zoomAbout` anchor/clamp cases, plus duration
formatting, run-state mapping and run day-grouping). Re-run with
`--rerun-tasks` to confirm.
- The debug APK was installed and driven on the `Pixel_Fold_API_36` emulator
(Android 16, `adb shell cmd uimode night yes`) against a live server at
`ws://10.0.2.2:8080/connect` with workspace `/Users/alan/repos/pipelines`.
Settings, pipeline list (all 9 pipelines), pipeline detail, the workflow graph,
run history and run detail were captured to `captures/` and
`captures/style_pass/` (both git-ignored) and reviewed.
- `adb logcat` for the app package contained no `FATAL EXCEPTION`, Compose or
other runtime exception during the sweep.
- The orthogonal-edge / resizable-panel pass was verified the same way: a
baseline APK was built from the pre-change tree and installed, then the new
build was installed and driven to the 4-stage pipeline-detail graph and a
run-detail graph with the executed route highlighted. `captures/graph_pass/`
(git-ignored) holds `pipeline_detail_before/after` and `run_detail_before/after`
pairs plus a panned state and the expanded panel after tapping the toggle
(`pipeline_detail_expanded_after`, `run_detail_panned_after`,
`run_detail_expanded_after`). A review of that pass found the expanded panel
scrolled below the fold (blank) and the PNGs prefixed by an adb stderr warning,
so the expand now scrolls the panel into view and the after-captures were
re-taken with a display id (`adb exec-out screencap -p -d <display-id>`) so no
warning leaks into the files. `adb logcat` showed no `FATAL EXCEPTION` and no
app/Compose exception during the sweep.
Known limitations of that run: pinch-zoom could not be driven through `adb`
(single-touch pan only) and one portrait Fold viewport was used. A follow-up pass
fitted the graph to its viewport on first layout, clamped panning so the content
cannot leave the view, added a "Fit graph to view" action, connected on launch
when a server URL is already saved, and made the completed/recorded visit wording
and the outcome-label contrast consistent. The fitted graph still sits slightly
above the box's vertical centre, because the layout box includes padding that is
not drawn. A later style pass made the theme dark-first (app-owned scheme; the
launch window/bar colours match it) and moved the `#failure`/`#success` terminals
to a lower row beneath the stage row; before/after captures for the theme, graph
and app bar/style are under `captures/style_pass/` (`*_before.png` are the
pre-change baseline referenced by the task, `*_after.png` are the new build).
The Runs-area pass (centroid zoom, collapsible sticky sections, runs list, steps
timeline, type hierarchy) was verified the same way on the `Pixel_Fold_API_36`
emulator (dark mode, `adb shell cmd uimode night yes`) against the live server:
the debug APK was installed, the list/detail/step flows were driven with
`adb shell input` and `uiautomator dump`, and captures were written to
`captures/runs_pass/` (git-ignored): `runs_list_top`,
`runs_list_scrolled_sticky` (a `13 Oct 2026` header pinned under the app bar),
`runs_list_states`, `runs_card_interrupted`, `run_detail_top`,
`run_detail_graph_collapsed`, `run_detail_steps`, `run_detail_step_expanded`,
`run_detail_sticky_section` (a `Steps, expanded` header pinned mid-list),
`pipeline_detail_sections`, `pipeline_detail_section_collapsed`,
`pipeline_graph_panned` and `pipeline_graph_fit`. `adb logcat` for the app
package contained no `FATAL EXCEPTION` or Compose/other runtime exception during
the sweep. As before, `adb` cannot synthesise a two-finger pinch, so the
centroid-anchored zoom is verified primarily by the `zoomAbout` unit tests and
the on-device graph was exercised with pan + "Fit graph to view" only.
The tabs / code-block / foldable pass was verified on the same
`Pixel_Fold_API_36` emulator (dark mode, `adb shell cmd uimode night yes`) against
the live server: `:app:testDebugUnitTest` reported **60 tests, 0 failures**
(including new `WindowSizeTest` for `isWideLayout` at 400/600/800 and
`DetailTabsTest` for the tab lists and `clampTabIndex`) and `:app:assembleDebug`
succeeded. The debug APK was installed and driven; captures were written to
`captures/tabs_pass/` (git-ignored): every run-detail tab (`05_run_summary`,
`06_run_graph`, `07_run_input`, `08_run_output`, `10_run_evidence`,
`11_run_steps`), every pipeline-detail tab (`01_pipeline_summary`,
`02_pipeline_graph`, `03_pipeline_source`), a long Input/Output block showing the
themed card scrolling internally (`07_run_input`/`08_run_output`, whose block
`ScrollView` measures the 320dp cap), a collapsed inner section
(`09_run_output_collapsed`, `"input, collapsed"`), a step's expanded evidence code
blocks (`12_run_step_expanded`) and the wide two-pane layouts with the vertical
tab rail (`13_wide_runs_split`, `14_wide_run_summary`, `15_wide_pipelines_split`,
`16_wide_pipeline_summary`, `17_wide_pipeline_graph`). Tab-selection persistence
across a configuration change was exercised by switching `wm density` 390→401
with the run detail open; the selected tab stayed selected
(`18_before_config`, `18_after_config`). `adb logcat` for the app package
contained no `FATAL EXCEPTION` and no Compose/other runtime exception.
The space-usage pass (collapsible icon rail, roomier Steps, rendered Source tab)
was verified on the same `Pixel_Fold_API_36` emulator (dark mode after
`adb shell cmd uimode night yes`) against the live server at
`ws://10.0.2.2:8080/connect`:
- `:app:testDebugUnitTest` reported **76 tests, 0 failures** (up from 60:
new `StageDetailSheetTest` for the stage/step field derivation and
`StepMetaTest` for the step metadata pairing + details predicate, plus the
icon/rail-width assertions in `DetailTabsTest` and the file-change/notification
formatting in `FormatTest`). `:app:assembleDebug` and `:app:installDebug`
succeeded; the install reported `Installed on 1 device` (the emulator — no
physical device was attached at install time).
- Captures were written with `adb -s emulator-5554 shell screencap -p
/sdcard/shot.png` followed by `adb -s emulator-5554 pull` (never
`exec-out … >`), to `captures/space_pass/` (git-ignored):
`narrow_pipeline_top_tabs` (narrow window, tabs across the top),
`source_tab_narrow` (rendered definition) and `source_tab_raw_narrow` (the
`Raw` toggle revealing the exact markdown), `wide_source_rail_expanded`
(icon+label rail, Source tab) and `wide_source_rail_collapsed` (icon-only rail,
content visibly wider), `wide_run_steps_expanded` and
`wide_run_steps_expanded_rail_collapsed` (a step with the two-column metadata
grid — Status/Outcome, Duration/Visit, Target/Session — and full-width Input/
Output/File-changes/Transcript cards), plus `wide_graph_stage_sheet` (tapping a
stage on the Graph tab still opens the refactored `StageDetailSheet`). No
clipping, even step spacing and a height-filling Source tab were confirmed by
eye.
- Rail-collapse persistence across a configuration change was exercised by
collapsing the rail on a detail screen and switching `wm density` 390→401: the
activity recreated and the collapsed strip stayed collapsed (`Expand tabs` was
still the control's description after the change; capture
`wide_detail_rail_collapsed_config_change`). The saved tab index is clamped by
`clampTabIndex` (unit-tested), so a stale index never indexes out of bounds.
- The wide layout was exercised by resizing the emulated display
(`adb shell wm size 2000x3400`, ≈820dp at density 390) and reset afterwards
(`wm size reset`); the attached Pixel 10 Pro Fold was never used and no run was
started from the app.
- `adb -s emulator-5554 logcat -d` contained 0 `FATAL EXCEPTION` lines and 0
`E AndroidRuntime` lines. The emulator was stopped with `adb emu kill`; no
`qemu-system-aarch64-headless` process survived.
Because `adb` cannot physically fold the phone, the wide two-pane/rail layout was
exercised on the emulator by resizing the emulated display (`adb shell wm size
2000x3400`, ≈820dp at density 390) and the narrow single-pane layout at the
default width (1080px ≈ 443dp); the attached Pixel 10 Pro Fold was not used to
drive the app. Note that `:app:installDebug` installs to *every* connected
device: that Gradle task therefore also (re)installed the debug APK on the
attached Pixel 10 Pro Fold; all device-driving commands targeted the emulator
serial (`adb -s emulator-5554`) explicitly. The emulator was stopped with
`adb emu kill` plus `kill -9` of the surviving `qemu-system-aarch64-headless`.
## Distinct graph colours, Timeline + visit tabs, real list pane, floating pill
Four UI changes were verified on the same `Pixel_Fold_API_36` emulator (dark mode
after `adb shell cmd uimode night yes`) against the live server at
`ws://10.0.2.2:8080/connect`. Nothing in the Pipelines server, its Go source,
Docker/compose files or the installer was touched, no run was started from the
app, and the attached Pixel 10 Pro Fold was never driven (the debug APK was
installed with `adb -s emulator-5554 install -r`, not `:app:installDebug`, so the
physical device was not re-installed by this pass either).
- **Graph colours.** `GraphPalette` is a curated, fixed palette plus a pure
deterministic outcome→index mapping (no `hashCode() % 4`). `error` stays the
theme error role and `success` the theme tertiary (positive); every other
outcome uses one palette colour for both its edge stroke and its label text.
Node fills differ by kind (`GraphNodeKind`: terminal success, terminal failure,
model, ntfy, other/custom); a selected stage inverts (light fill / dark text)
plus a 4px border, and executed-vs-dimmed alpha still applies on top. WCAG
contrast is *measured*: `GraphPaletteTest` checks the helper against known
reference ratios (white/black 21, `#777`/white 4.48) and asserts every palette
colour is ≥ 4.5:1 against `DarkSurface 0xFF0E1513` (measured values range from
8.63:1, `approved`, to 13.78:1, `fast`; `success` 11.73:1 and `error` 10.89:1 as
the dark scheme supplies them).
- **Timeline + visit tabs.** The run-detail `Steps` tab is renamed `Timeline`
(key kept `steps`); it renders one compact line per recorded visit (stage,
visit number, outcome chip, duration and a brief diagnostic/target description)
and nothing else — the heavy evidence moved entirely into the shared
`StageDetailSheet`. The sheet now takes a stage's ordered `runSteps` plus an
`initialVisitIndex` and shows a `visit 1..N` tab row only when there is more
than one visit; the timeline opens on the tapped visit and the graph on the
most recent. `runStepFields` gained the step Input/Output blocks, so the sheet
still carries status, outcome, duration, visit/max/limit, model target, target,
session, agent, diagnostic, transcript, input, output, file changes,
notifications and the stage definition.
- **Real list pane.** Pipelines and runs now share one `ListRow` (a single flat
`Surface`, thin `HorizontalDivider`, leading element + title + secondary line,
no per-row elevation) instead of a card per item. The selected row uses the
same tonal `secondaryContainer`/`onSecondaryContainer` treatment as the tab
rail and destinations, exposed as `selectable` selected state; opening a row
selects it and Back clears it. The wide list pane collapses to a 56dp strip
(`rememberSaveable`), with the freed width going to the detail.
- **Floating destination pill.** The bottom `NavigationBar` is replaced by a
floating rounded `Surface` at the bottom right holding the three destinations
as 48dp icon targets, inset by the Scaffold's system-bar padding plus 16dp;
selected state is a tonal circle plus `Role.Tab` selected semantics (not colour
alone). The same pill is used on **both** window widths (no compact strip);
the app reserves 88dp at the bottom so no scrollable content is hidden behind
it.
- **Icons.** Icons are taken from `material-icons-extended` (already declared in
`app/build.gradle.kts`/`libs.versions.toml`, BOM-managed — no new dependency
and no non-offline Gradle invocation was needed; the artifact was already in
the cache). Mapping: Pipelines → `AccountTree`, Runs → `History`, Settings →
`Settings`; Graph tab → `Hub`, Timeline → `AutoMirrored.List`, Input →
`AutoMirrored.Input`, Output → `AutoMirrored.Send`, Evidence →
`AutoMirrored.FactCheck`, Source → `Code`; run statuses → Running
`AutoMirrored.DirectionsRun`, Queued `Schedule`, Succeeded `CheckCircle`,
Failed `Error`, Canceled `Cancel`, Interrupted `PauseCircle`, Active `Bolt`,
Unknown `AutoMirrored.HelpOutline`. The debug APK is ~17 MB; note that
`app/build.gradle.kts` sets `release { isMinifyEnabled = false }`, so R8 does
**not** strip unused extended icons in the current release config (that
stripping only applies to a minified build).
- `:app:testDebugUnitTest` reported **93 tests, 0 failures** (new
`GraphPaletteTest`, `TimelineTest`, `PipelinesNavTest`; extended
`StageDetailSheetTest` and `DetailTabsTest`; `StepMetaTest` was removed with the
inline metadata grid it covered). `:app:assembleDebug` succeeded.
- Captures were written with `adb -s emulator-5554 shell screencap -p
/sdcard/shot.png` followed by `adb -s emulator-5554 pull` (never
`exec-out … >`), to `captures/nav_timeline_pass/` (git-ignored):
`01_launch`, `02_runs_narrow` (narrow lists + pill), `04_timeline` (the concise
Timeline tab), `05_sheet_from_timeline_visits` (sheet from the timeline opening
on the tapped visit 1, with visit tabs), `05b_sheet_single_visit_no_tabs` (a
single-visit stage shows no tab row), `06_sheet_run_section` (Input/Output in
the sheet), `07_run_graph` (executed route highlighted), `08_sheet_from_graph`
(same stage opened from the graph, on the most recent visit 2),
`09_pipeline_4stage_graph` + `_2x`, `10_pipeline_1stage_graph` + `_2x`,
`11_wide_pane_expanded`, `12_wide_pane_selected`, `13_wide_pane_collapsed`,
`14_wide_runs_pane`, `15_wide_run_detail`, and the icon close crops
`16_pill_wide_2x`, `17_tabs_wide_2x`, `18_runstatus_icons_2x`,
`18b_failed_status_2x`, `19_pill_narrow_2x`.
- `adb -s emulator-5554 logcat -d` contained 0 `FATAL EXCEPTION` lines and no
Compose runtime exception. The wide layout was exercised with
`adb shell wm size 2000x3400` (≈820dp at density 390); the emulator was stopped
with `adb emu kill` plus `kill -9` of any surviving
`qemu-system-aarch64-headless`.
## Per-visit artifacts, collapsed defaults, single top inset, APK publish (15 Oct 2026)
Four changes were implemented in `android/` only. Nothing in the Pipelines
server, its Go source, Docker/compose files or the installer was touched, no run
was started from the app, and the 8 MiB per-file artifact cap
(`internal/server/artifacts.go` `maxArtifactFileBytes`) was left unchanged.
- **Artifacts.** `RunStep` now models the server's `artifacts`
(`StageArtifact{name, size_bytes, content_type, url}`), `artifacts_skipped` and
`artifacts_truncated` with the exact `internal/protocol/runs.go` wire names.
`ui/graph/Artifacts.kt` renders one row per file (name, `humanBytes` size,
content type) with an open (`ACTION_VIEW`) and a copy-link action, an inline
image thumbnail (OkHttp + `BitmapFactory` with `inSampleSize` off the main
thread, bytes cached once per URL) and a full-size view on tap; other types get
a type icon. URLs are resolved by `ServerUrl.resolveArtifactUrl` against the
configured server URL (ws→http/wss→https, `/connect` dropped), never a
hardcoded host; with no URL configured the actions are disabled and a hint is
shown. Empty/partial states reuse the TUI strings from
`internal/tui/file_changes.go`. The Timeline rows carry a subtle `AttachFile`
indicator (`hasArtifacts`) with a per-visit `contentDescription`.
- **Collapsed defaults + self-describing titles.** `SectionExpansionState` now
persists the set of *expanded* keys (default empty), so every inner section in
the run detail (input/output/evidence) and pipeline detail (Versions, Source)
starts collapsed while operator choices still survive configuration changes.
Evidence section titles are built by `evidenceSectionTitle`, e.g.
`Evidence - step 4, ui_reviewer visit 1, opencode`, correlating
`SessionEvidence.sequence` with the run's steps once per data change; a blank
field key already falls back to its prefix and never yields an empty title.
- **Top inset.** The outer `Scaffold` in `PipelinesApp` now uses
`contentWindowInsets = WindowInsets(0, 0, 0, 0)` so the inner Material 3 app
bars own the status-bar inset exactly once (removing the duplicate top band);
the floating pill clears the navigation bar via
`windowInsetsPadding(WindowInsets.navigationBars)`. While the connection banner
is visible it owns the status-bar inset (padding inside its `Surface`) and the
`NavHost` below consumes `statusBars` so the app bar is not double-padded.
- **APK publish.** `:app:assembleDebug` produced
`app/build/outputs/apk/debug/app-debug.apk` (18,181,943 bytes, sha256
`41c9df314da40bb19df7e3d90f27a83339a275768cefee537c4ba796efe01eab`, rebuilt
after the follow-up fixes below), copied to
`~/.local/share/pipelines/data/artifacts/58/1/pipelines-debug-d00bd37.apk`
(`d00bd37` = short SHA of the last commit touching `android/`) with a matching
`shasum -a 256`. At 17.3 MiB it exceeds the 8 MiB per-file inventory cap
(`internal/server/artifacts.go` `maxArtifactFileBytes = 8 << 20`), so it is
served by direct URL but deliberately absent from the step inventory.
### Follow-up fixes (code review of the first pass)
- `ui/graph/Artifacts.kt` hoists its derivations with `remember(step)` /
`remember(artifact.url, configuredServerUrl)` / `remember(artifact)` so the
summary text, the partial-capture notes, the resolved URL, the image test and
the meta line are computed once per data change, never per recomposition.
- `ArtifactBytesCache` is a byte-bounded `LruCache` (16 MiB) rather than an
unbounded map, so a long session cannot retain every fetched artifact.
- `artifactCaptureNotes` returns no notes for an empty artifact list, matching
`internal/tui/file_changes.go` `artifactLines` (which returns nothing when the
list is empty); the empty-state summary is unchanged.
- The field-section title fallback is the pure `fieldSectionTitle`, covered by
`TimelineTest#fieldSectionTitleFallsBackToPrefixAndIsNeverEmpty`.
Evidence actually obtained in this pass (macOS, JDK 17 from Homebrew
`openjdk@17`, Gradle 8.11.1 from the wrapper cache,
`ANDROID_HOME=/Users/alan/Library/Android/sdk`):
- `:app:testDebugUnitTest` reported **103 tests, 0 failures** (new
`ProtocolModelTest#runStepArtifactsParseWithExactWireNamesOrAbsent`,
`FormatTest` cases for `humanBytes`/`artifactMetaLine`/`artifactsSummary`/
`artifactCaptureNotes`, `ServerUrlTest#resolvesArtifactUrlAgainstTheConfiguredServerUrl`
and `resolveArtifactUrlReturnsNullWhenUnconfiguredOrBlank`,
`DetailTabsTest#sectionsStartCollapsedAndToggleIsRemembered`, and `TimelineTest`
cases for `hasArtifacts`/`evidenceSectionTitle`/`fieldSectionTitle`).
- `:app:assembleDebug` succeeded (18,181,943-byte debug APK).
- `:app:lintDebug` still reports the two pre-existing `NewApi` errors for
`android:windowLightNavigationBar` (minSdk 26) in `res/values/themes.xml` and
`res/values-night/themes.xml`; those files were not modified by this change.
Verified against the live server (running as
`pipelines-server -addr 0.0.0.0:8080`, the app configured
`ws://10.0.2.2:8080/connect`; LAN address `10.0.0.249` from `ipconfig getifaddr en0`):
- The published APK is served at
`http://10.0.0.249:8080/artifacts/58/1/pipelines-debug-d00bd37.apk` (LAN), not a
hardcoded `localhost`/`10.0.2.2` host. `curl -I` returned `HTTP/1.1 200 OK`,
`Content-Type: application/vnd.android.package-archive`, `Content-Length:
18181943`; a streamed `GET` piped to `shasum -a 256` returned
`41c9df314da40bb19df7e3d90f27a83339a275768cefee537c4ba796efe01eab`, equal to the
local `app-debug.apk`.
- Run 55 step 4's real artifacts are served:
`curl -I http://10.0.0.249:8080/artifacts/55/4/graph_crop_error_rejected.png`
→ 200, `image/png`, 52,168 bytes and
`.../swatch_error_vs_rejected.png` → 200, `image/png`, 5,008 bytes.
- The server has no HTTP inventory endpoint (only `GET /artifacts/…`,
`GET /healthz`, `GET /connect`); the step inventory is delivered over the
websocket and clips entries larger than `maxArtifactFileBytes` (8 MiB), so the
17.3 MiB APK is intentionally absent from it.
Not verified in this pass — no device was attached (`adb devices` listed no
devices, and no emulator was running): the on-device/emulator narrow/wide
before/after screenshots for the top inset and the collapsed sections, the
`logcat` sweep and the install on the Pixel 10 Pro Fold. The previous pass's
emulator screenshots for the artifacts sheet (narrow/wide run detail) are in
`~/.local/share/pipelines/data/artifacts/58/3/`.
## Sliding master/detail, right-opening sections, no collapse (15 Oct 2026)
> **Superseded** by the pane-stack pass below (same day): the shared host is now
> `ui/components/SlidingPaneStack.kt` (three levels), Back no longer steps the
> section index, and the stage detail is a pane — there is no
> `SlidingMasterDetail.kt`, `RightSlidingPanel` or `ModalBottomSheet` in the
> tree. The bullets and evidence here record what that pass did at the time.
The collapse-based master/detail interaction was replaced by a sliding one, in
`android/` only. No Pipelines server/Go/Docker/installer file was touched, no run
was started from the app, and colours, the graph and the information shown are
unchanged — only the navigation model and its geometry.
- **Removed, not repaired.** `CollapsedListPane`, the `onTogglePane` parameter
and the "Collapse list pane" `IconButton` on both list top bars, `LIST_PANE_WIDTH`
(`360.dp`) and `COLLAPSED_LIST_PANE_WIDTH` (`56.dp`), and the observed-side rail
collapse (`RailToggle`, `railWidthDp`, `COLLAPSED_RAIL_WIDTH_DP`,
`WIDE_RAIL_WIDTH_DP` collapse branch, "Collapse tabs") are all gone; the wide
rail is always visible as the section index. `ui/CollapseRemovalTest.kt` scans
`src/main/java` for those identifiers and fails if any return. The old
full-screen `pipeline/{id}/{version}` and `run/{id}` routes were removed, so
`destinationSelected` is a plain route equality.
- **One shared host, one slide.** `ui/components/SlidingMasterDetail.kt` is used
by both the Pipelines and Runs destinations at both window widths: the list
fills the window and the detail overlays it, sliding in from the right via a
single `animateDpAsState(spring())` until a peek strip stays visible; a rapid
run of taps only retargets that one animator, so the pane always settles fully
open or fully closed (never half-slid). The detail width is `measuredWidth -
peek` (never hardcoded) and the list behind is hidden from accessibility and
made non-interactive while the detail is open, so TalkBack focus follows the
visible pane and a tap can never select a row through the peek.
- **The peek geometry is derived, with one named token.** `PEEK_WIDTH_DP`
(`56.dp`) is the only new dimension literal; the actual peek is
`peekWidthDp(minimumInteractive, startInset) = maxOf(PEEK_WIDTH_DP,
minimumInteractive + startInset)`, so the tappable strip left after the left
system-gesture inset is still at least `LocalMinimumInteractiveComponentSize`
(48dp). The strip is positioned clear of the status/nav bars and the gesture
area by offsetting/­sizing it with `WindowInsets.systemBars ∪
WindowInsets.systemGestures` (read once per layout), and it carries the content
description "Back to list". No other numeric literals were added (the animation
uses the default `spring()` with no literal).
- **Sections open to the right.** `DetailTabs` keeps the index fixed in place and
moves the section bodies into a `HorizontalPager` (compose-foundation, already
in the BOM): a tap or a swipe slides the section in, later sections from the
right and earlier ones from the left. Back (`ui/PaneState.kt` `backStep`) is one
level — section > 0 → previous section, section 0 → list, list → app exit — and
the peek tap, the detail's back arrow and the system Back button/gesture all run
that same step. `PredictiveBackHandler` handles the gesture;
`android:enableOnBackInvokedCallback="true"` was added to the manifest.
- **Saved state.** `PaneSelection` (pane, item id/version, section index) is all
primitives with a `Saver`, so the open pane and selected section survive
rotation, configuration change and process death. `rememberPagerState` also
saves the pager page.
- **Secondary surface.** The wide stage-detail overlay reuses the same
right-slide (`RightSlidingPanel`); on a narrow window it deliberately keeps its
`ModalBottomSheet` (a right panel on a phone-width window would crowd the
content, and the sheet is the platform-appropriate narrow surface). The overlay
is hosted at the screen level, a sibling of the tabs, so it covers the
whole detail pane rather than being nested inside a pager page (a pager-nested
copy sized to zero). The pure helpers in `StageDetailSheet.kt` are unchanged, so
no information changed.
Evidence obtained in this pass (macOS, JDK 17 from Homebrew `openjdk@17`, Gradle
8.11.1 from the wrapper cache, `ANDROID_HOME=/Users/alan/Library/Android/sdk`):
- `:app:testDebugUnitTest` reported **112 tests, 0 failures** (new `PaneStateTest`
— pane open, `backStep` at section > 0 / section 0 / list, section ordering and
slide direction, `Saver` round trip and primitive payload; new
`CollapseRemovalTest`; new `SlidingMasterDetailTest` for `peekWidthDp`;
`DetailTabsTest` updated and `PipelinesNavTest` updated for the removed routes).
- `:app:assembleDebug` succeeded. `:app:lintDebug` still reports only the two
pre-existing `NewApi` errors for `android:windowLightNavigationBar` (minSdk 26)
in `res/values/themes.xml` and `res/values-night/themes.xml`; those files were
not modified.
- `grep` over `app/src/main` for the banned collapse identifiers returned nothing.
- The debug APK was installed and driven on the attached Pixel 10 Pro Fold
(`adb -s 58281FDCG000JF`, inner display 2076x2152, density 330 ≈ 1006dp wide)
against a live server (`ws://10.0.0.249:8080/connect`):
- Tapping a pipeline row slid the detail in; `uiautomator dump` showed the
"Back to list" strip at `[61,185][160,1904]` (48dp wide, offset past the ~30dp
left gesture inset and below the status bar) with the list rows absent from
the accessibility tree; tapping the strip's centre closed the detail and
restored all nine rows. A tap in the gesture area (`x = 30 < 61`) selected no
row (the list is blocked).
- Tapping the Graph rail tab (and the narrow top tab row) changed the section
while the rail/tab row and the strip stayed in place; the selected rail node
exposed `selected="true"`.
- `adb shell input swipe 5 1000 900 1000 250` (predictive-back gesture) closed
the detail at section 0, and from Source (section 2) stepped back to Graph
(section 1) — one level.
- A live `wm density` change 330 → 300 → 330 kept the pane open and the section
selected; the narrow layout (`wm size 1080x2340`, ≈524dp) showed the full-width
list, the top tab row index and a 48dp strip, and both the section tab and the
strip back worked there.
- `adb logcat` for the package contained no `FATAL EXCEPTION` or
`AndroidRuntime` error during the sweep, and no run was started from the app.
- `:app:testDebugUnitTest` and the APK build were re-run after the final code
change; the beats above are the final-build run.
- The wide sequence was captured to `captures/` (git-ignored) and mirrored to
the run artifacts: `slide-W1-list`, `slide-W2-detail-peek` (detail slid in,
48dp strip on the left), `slide-W3-section` (Graph tab selected, index still
in place), `slide-W4-back-section` (strip tapped once, back to Summary) and
`slide-W5-closed-list` (strip tapped again, list restored, byte-identical to
`slide-W1-list`); the narrow window (`wm size 1080x2340`, ≈524dp) has the same
set `slide-N1`…`slide-N5` (top tab row, `N3` graph, `N4` back to Summary,
`N5` closed, identical to `N1`).
- The wide stage-detail overlay was driven from both entry points: tapping a
timeline row (`W8-timeline`, `W7-stage-overlay`: the panel slid in with the
"Close stage details" strip at `[221,477][320,1838]`, the `planner` heading and
the `Definition` section, dismissed by tapping the strip) and tapping a graph
node (`W9-graph-stage-overlay`).
- **APK publish.** `app/build/outputs/apk/debug/app-debug.apk` (18,184,868 bytes,
sha256 `7942795c1d979a66e4759a0c3e3f0399d60e256b29ba4a7266dfc52142245ac8`) was
copied to
`~/.local/share/pipelines/data/artifacts/59/2/pipelines-debug-059c85a.apk`
(`059c85a` = `git log -1 --format=%h -- android/`). `curl -I
http://10.0.0.249:8080/artifacts/59/2/pipelines-debug-059c85a.apk` (LAN address
from `python3 scripts/lan-address.py`, never `localhost`/`10.0.2.2`) returned
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18184868`; a streamed `GET | shasum -a 256` returned
`7942795c1d979a66e4759a0c3e3f0399d60e256b29ba4a7266dfc52142245ac8`, equal to the
local file. At 17.3 MiB it exceeds the 8 MiB per-file inventory cap
(`internal/server/artifacts.go`), so it is served by direct URL only.
Not verified in this pass: `onOpenRun` from a pipeline detail to a freshly
started run cannot be exercised without starting a run, so that path is kept
compiling and functional but untested; the predictive-back gesture's frame-by-frame
preview is not driven through `adb`, so its behaviour (one level back) is
verified but not its animation; a real hardware fold to the narrow cover display
was not exercised (narrow was produced with `wm size`); the emulator
(`emulator-5554`) was not used, the physical Pixel was.
## 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)
> **Superseded** by "The covered edge is measured, not budgeted" below: the fixed
> `PEEK_BUDGET_DP` (`224.dp`) is gone. The covered region is now measured from the
> compact identity a covered edge has to show, so the active pane is no longer
> charged a fixed `224dp` whatever the window width is.
The pane stack was made adaptive to the window width and its peek space changed
from one peek per level to a single fixed budget shared between the covered
panes. `android/` only; nothing in the Pipelines server, its Go source, the
Docker/compose files, the installer or the dependency blocks was touched, no run
was started from the app, and the attached Pixel 10 Pro Fold was never installed
on or driven (the debug APK was installed with `adb -s emulator-5554 install -r`).
- **Narrow windows: no stack, no peek.** `SlidingPaneStack` gained a `wide`
parameter (the callers pass the existing `isWideLayout` value). On a narrow
window the peek budget is `0.dp`, so every pane's open offset is `0` and each
pane is a full-window screen; a covered pane is fully hidden, there is no strip
and nothing is left over on the left. Tapping a list row or a stage/graph node
opens the pane with the existing `spring()` slide from the right edge; Back,
the predictive-back gesture and the pane's own top-bar back control all run the
same one-level `backStep`.
- **Wide windows: one fixed peek budget.** The total space the covered panes
reserve is `PEEK_BUDGET_DP` (`224.dp`, a named token), never `peek * level`, so
the stack consumes the same width however deep it gets. `paneOpenOffsetsDp`
places the active pane at exactly the budget — its width is therefore
`hostWidth - budget` at every depth, constant as levels are added — and shares
the budget between the covered panes, widening the leftmost strip first so that
after the left gesture inset (`systemBars ∪ systemGestures`) its tappable part
is still at least `PEEK_WIDTH_DP` (`56.dp`) and the platform minimum
interactive size, then splitting the rest evenly. At two levels the one covered
pane takes the whole budget; at three the budget is split in two; at four (four
panes, three covered) it is split in three.
- **Named tokens, no literals.** `PEEK_WIDTH_DP` (`56.dp`), `PEEK_BUDGET_DP`
(`224.dp`) and `MIN_ACTIVE_PANE_WIDTH_DP` (`320.dp`) live beside the stack;
`peekBudgetDp` clamps the budget so the active pane never collapses on a small
host (`hostWidth - MIN_ACTIVE_PANE_WIDTH_DP`), and `paneWidthDp` is never
negative. Everything else is derived from the measured width and the insets.
- Both models keep the other pane rules: opening and closing are exact mirrors
(the same offsets and `spring()` retarget in reverse), panes are opaque, the
peek strips are inset inside the status/nav bars and the gesture area, and a
section inside a detail is a selection on its own tab row, never a navigation
level.
Evidence obtained in this pass (macOS, JDK 17 from Homebrew `openjdk@17`, Gradle
8.11.1 from the wrapper cache, `ANDROID_HOME=/Users/alan/Library/Android/sdk`,
`--offline`):
- `gradle :app:testDebugUnitTest` reported **130 tests, 0 failures, 0 errors**
(the rewritten `SlidingPaneStackTest` has 8 cases: narrow spends no peek at any
depth, the wide active pane's width is constant across depths, four levels share
the one fixed budget with every strip at least the named minimum, the first
strip clears the gesture inset, the budget clamps so the active pane never
collapses, a tiny host never yields negative geometry, offsets are monotonic and
deterministic, and widths are host-less-offset and never negative).
- `gradle :app:assembleDebug` succeeded (17,990,397-byte debug APK, sha256
`b7ba9d600031f09472b06fff4c06cd50ec93b995cf7b1f7bf8a2115846a8e602`).
- On `emulator-5554` (2076x2152, density 390 ≈ 852dp wide; **never** the attached
Pixel) against the live server `ws://10.0.0.75:8080/connect`, driven with
`adb shell input` and `uiautomator dump`:
- Wide, `uiautomator dump` of the peek strips: at two levels the single strip
was `[73,165]–[546,1859]`, i.e. `[30dp, 224dp]` — the whole budget after the
~30dp left gesture inset; at three levels the two strips were `[73,165]–[273,
1859]` and `[273,165]–[546,1859]`, i.e. `[30dp,112dp]` and `[112dp,224dp]`.
The active pane therefore starts at `224dp` at both depths — its width is
constant — and the two covered strips sum to the same `224dp` budget.
- Narrow (`wm size 1080x1920`, `wm density 480`, ≈360dp): the list, the detail
and the stage pane each filled the window (`uiautomator dump` listed **no**
`Back to …` strips at any depth), a row tap opened the detail (`Summary` tab
present) and the predictive-back swipe `input swipe 5 1000 900 1000 250`
returned to the list.
- `adb -s emulator-5554 logcat -d` contained 0 `FATAL EXCEPTION` and 0
`E AndroidRuntime` lines after a clean sweep; no run was started from the app.
- Screenshots and recordings were written to the run's artifacts directory:
`wide-1-level-list.png`, `wide-2-levels-detail.png`, `wide-3-levels-stage.png`,
`narrow-1-level-list.png`, `narrow-2-levels-detail.png`,
`narrow-3-levels-stage.png`, `wide-open-close.mp4` (opening two and three
levels then closing) and `narrow-open-close.mp4` (opening and closing the
detail). The four-level layout (four panes, three covered) is not reachable in
the app, which has exactly three pane levels (`MasterPane.List/Detail/Stage`);
the shared budget at four levels is covered exactly by the
`SlidingPaneStackTest` geometry cases instead.
- **APK publish.** `app/build/outputs/apk/debug/app-debug.apk` was copied to
`…/artifacts/61/1/pipelines-debug-wip-5314542.apk` (`5314542` =
`git rev-parse --short HEAD`); `shasum -a 256` matched. `curl -I
http://10.0.0.75:8080/artifacts/61/1/pipelines-debug-wip-5314542.apk` returned
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 17990397`; a streamed `GET | shasum -a 256` equalled the local
file. At 17.2 MiB it exceeds the server's 8 MiB per-file inventory cap, so it is
served by direct URL only.
Not verified in this pass: the four-level layout on a device (unreachable — the
app has three pane levels); the predictive-back animation frames (adb cannot drive
a two-finger pinch and the frame-by-frame preview is not captured); the wide
recording's final close-detail frame lands at the end of the clip. The narrow
layout was produced with `wm size`/`wm density` (a real hardware fold was not
exercised).
## Sections change in place, not sideways (15 Oct 2026)
Selecting a section in a run or pipeline detail now swaps the section body in
place instead of sliding it in from the side. `android/` only; nothing in the
Pipelines server, its Go source, the Docker/compose files or the installer was
touched, no run was started from the app, no dependency was added, and the
attached Pixel 10 Pro Fold was not installed on or driven (every device command
targeted `emulator-5554`).
- **In-place swap instead of a pager.** `ui/components/DetailTabs.kt` no longer
uses a `HorizontalPager` for the section bodies. The selected section
cross-fades in place behind a `Crossfade` (`SECTION_SWAP_MILLIS = 180`), so a tap
on the rail/tab row is an ordinary tab change with no lateral motion and nothing
to swipe. `Crossfade` comes from `androidx.compose.animation:animation`, already
on the compile classpath transitively via `androidx.compose.foundation` (no new
dependency was declared; `gradle/libs.versions.toml` and the dependency blocks
are unchanged). Only the selected section is composed at rest.
- **Level navigation still slides.** The `SlidingPaneStack` (list → detail → stage
pane) is untouched, so navigation between levels keeps its `spring()` slide; only
the section selector inside a detail changed.
- **The rail's selected state is kept.** The narrow `PrimaryScrollableTabRow` and
the wide selectable rail are unchanged; selection is still `Role.Tab` + selected
semantics plus the tonal container, never colour alone.
- **A section's scroll position is not reset on return.** Each section's saved
state (its `LazyColumn` scroll) is kept under its stable tab key with
`rememberSaveableStateHolder().SaveableStateProvider(tab.key)`, so leaving and
returning to a section restores where the operator left off (this matches the
previous pager's per-page saved state).
- The two call sites' stale "pager composes only the visible section" comments were
updated; no other behaviour changed.
Evidence obtained in this pass (macOS, JDK 17 from Homebrew `openjdk@17`, Gradle
8.11.1 from the wrapper cache, `ANDROID_HOME=/Users/alan/Library/Android/sdk`,
`--offline`):
- `gradle :app:testDebugUnitTest :app:assembleDebug` → `BUILD SUCCESSFUL in 2s`;
the test-result XMLs aggregate to **130 tests, 0 failures, 0 errors, 0 skipped**
(the existing `DetailTabsTest` still covers the tab lists and `clampTabIndex`).
- `app/build/outputs/apk/debug/app-debug.apk` is 17,990,397 bytes, sha256
`ef467eaafd9cd7662167c17229a39281683aed6c890c48c9fabf0a1e3ed04172`.
- On `emulator-5554` (2076x2152, density 390 ≈ 852dp wide; **never** the attached
Pixel) against the live server `ws://10.0.0.75:8080/connect` (run 58, seven
completed visits), driven with `adb shell input`:
- A 13s `screenrecord` of tapping Summary → Graph → Input → Output → Evidence →
Timeline (`after-section-swap.mp4`), with stills of each section
(`after-run-summary/graph/evidence/timeline.png`): the rail's selected state
moves and the body changes, and an extracted mid-transition frame
(`frame-3.65.png`) shows the outgoing and incoming panels overlapping **at the
same x** — a cross-fade, not a slide.
- The same sequence on the pre-change build (built from `HEAD` in a throwaway
`git worktree`, installed as a baseline) recorded as `before-section-slide.mp4`
and frame `before-frame-2.05.png`: the outgoing panel is visibly shifted left
with the incoming panel entering from the right — the old lateral slide, by
contrast.
- Scroll preservation: Summary was scrolled down, Graph selected, then Summary
re-selected; `scroll-summary-returned.png` matches `scroll-summary-scrolled.png`
(Finished/Duration/Artifacts still on screen), not the top.
- `adb -s emulator-5554 logcat -d` contained 0 `FATAL EXCEPTION` and 0
`E AndroidRuntime` lines; no run was started from the app.
- **APK publish.** `app-debug.apk` was copied to
`~/.local/share/pipelines/data/artifacts/62/1/pipelines-debug-wip-0b373d0.apk`
(`0b373d0` = `git rev-parse --short HEAD`); `shasum -a 256` matched. `curl -I
http://10.0.0.249:8080/artifacts/62/1/pipelines-debug-wip-0b373d0.apk` (LAN
address from `ipconfig getifaddr en0`, never `localhost`/`10.0.2.2`) returned
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 17990397`; a streamed `GET | shasum -a 256` returned
`ef467eaafd9cd7662167c17229a39281683aed6c890c48c9fabf0a1e3ed04172`, equal to the
local file. At 17.3 MiB it exceeds the server's 8 MiB per-file inventory cap, so
it is served by direct URL only.
Not verified in this pass: the cross-fade's exact duration/frames beyond the single
extracted frame and the 180 ms spec; a real hardware fold (the wide layout is the
emulator's default 852dp); the narrow top-tab-row presentation (the emulator was
driven wide only) — the narrow selector code is unchanged and shared, so this is a
presentation difference the existing `WindowSizeTest`/`DetailTabsTest` still cover
where they can. The `after-section-swap.mp4` frame is the only mid-transition
sample taken; `before-frame-2.05.png` is the only baseline mid-slide sample.
## Run stage pane: surface Model/Provider in the headline (16 Oct 2026)
The report was "the adaptive-panes change lost the stage screen's content: only the
title, the model chip and one collapsed Definition remain". That symptom is the
**definition-only** branch of `StageDetailBody` (`selectedStep == null`, i.e. no
recorded visits). It is what a *pipeline* stage pane (`PipelineStagePane`, level 2
of the Pipelines destination) legitimately shows, and it is exactly what the run-61
artifacts (`~/.local/share/pipelines/data/artifacts/61/1/wide-3-levels-stage.png`,
`narrow-3-levels-stage.png`) capture — those screenshots are the Pipelines
destination, not the Runs one, so they are the expected definition-only look and not
the regression. Re-driving the current build from the Runs destination does **not**
reproduce the loss: from a Timeline row (`implementer · visit 2`, run 60) and from a
graph node the pane showed Status/Outcome/Duration/Visit/Target, the visit tab row
(visit 2 selected), and Definition/Input/Output/Artifacts/This run collapsed with
their content on expansion. No regression was present at `791d3dd`.
The one real gap against the requested headline facts was that the stage's recorded
`Model`/`Provider` configs lived only inside the collapsed Definition section (they
were always visible in the pre-pane sheet). They are now promoted to the
always-visible headline, without duplication:
- `ui/graph/StageDetailPane.kt` gained the pure `STAGE_CONFIG_HEADLINE_LABELS`
(`{"Model", "Provider"}`), `stageConfigHeadlineFields(definition)` and
`remainingDefinitionFields(definition)`. `StageDetailBody` renders
`headlineFields(runFields) + stageConfigHeadlineFields(definition)` as the
headline and `remainingDefinitionFields(definition)` inside the collapsed
Definition section, so a promoted row is never rendered twice. Both derivations
are `remember(definition)`-keyed; the run-evidence split stays
`runStepFields`/`headlineFields`/`evidenceFields`.
- Deliberate change to account for: the Definition section (collapsed by default)
no longer repeats Model/Provider, because they are now headline facts. Everything
else in Definition is unchanged (`Type`, `Prompt`, `Output`, `Outcomes`, the other
configs, `Tools`, limits, memory, notify).
- `StageDetailSheetTest` gained
`definitionModelAndProviderArePromotedToTheHeadlineWithoutDuplication` and
`aDefinitionWithNoConfigsPromotesNothing`.
Evidence obtained in this pass (macOS, `ANDROID_HOME=/Users/alan/Library/Android/sdk`;
`gradle :app:testDebugUnitTest :app:assembleDebug` under the default Homebrew JDK 27,
lint under JDK 17 as noted):
- `gradle :app:testDebugUnitTest :app:assembleDebug` → `BUILD SUCCESSFUL`; the
test-result XMLs aggregate to **132 tests, 0 failures, 0 errors, 0 skipped**.
`app/build/outputs/apk/debug/app-debug.apk` is 17,991,256 bytes, sha256
`2252e6964cd73f1d666da24f3684bd8e0b79cf3e07e0fdc018842a4f1cab2ccf`.
- `gradle :app:lintDebug` under JDK 17 fails only on the two **pre-existing**
`NewApi` errors for `android:windowLightNavigationBar` in
`res/values/themes.xml` and `res/values-night/themes.xml` (unchanged by this
pass); under the default Homebrew JDK 27 the lint worker crashes at dispose
(`NoClassDefFoundError: org.jetbrains.uast.UastFacade`), so JDK 17 is required.
- On `emulator-5554` (narrow 1080x1920/density 480 ≈ 360dp; wide 2076x2152/density
390 ≈ 852dp; **never** the attached Pixel) against the live server
`ws://10.0.0.75:8080/connect`, driven with `adb shell input`, screenshots in
`~/.local/share/pipelines/data/artifacts/64/2/`:
- `narrow_run61_facts_collapsed.png` / `wide_facts_collapsed.png`: the headline
(Status/Outcome/Duration/Visit/Target/Model/Provider) unexpanded and all five
sections collapsed.
- `narrow_run61_artifacts_expanded.png` / `wide_facts_artifacts_expanded.png`:
Artifacts expanded to `Artifacts · 8 recorded · partial capture`, the capture
note and the thumbnail grid.
- `wide_facts_definition_expanded.png`: Definition expanded with no duplicated
Model/Provider row.
- `narrow_run60_visit_tabs_facts.png` /
`narrow_run60_graph_node_stage.png`: a multi-visit stage (`visit 1`/`visit 2`
tabs, starting on the tapped/most-recent visit) opened from a Timeline row and
from a graph node, with the promoted Model/Provider.
- `previous_behaviour_nav_timeline_pass_05.png` is the pre-pane sheet
(`android/captures/nav_timeline_pass/05_sheet_from_timeline_visits.png`) for
comparison. The run-60/4 artifact _files_ used by its gallery are corrupt (their
`.png` bytes begin with the `adb screencap` "Multiple displays" warning), so its
thumbnails correctly show the `!` decode-error placeholder; run 61's valid
artifacts render normally.
- `adb -s emulator-5554 logcat -d | grep -c 'FATAL EXCEPTION'` and
`… | grep -c 'E AndroidRuntime'` each returned 0; no run was started from the
app.
- **APK publish.** `app-debug.apk` was copied to
`~/.local/share/pipelines/data/artifacts/64/1/pipelines-debug-wip-791d3dd.apk`
(`791d3dd` = `git rev-parse --short HEAD`); `shasum -a 256` matched. `curl -I
http://10.0.0.249:8080/artifacts/64/1/pipelines-debug-wip-791d3dd.apk` (LAN
address from `ipconfig getifaddr en0`, never `localhost`/`10.0.2.2`) returned
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 17991256`; a streamed `GET | shasum -a 256` returned
`2252e6964cd73f1d666da24f3684bd8e0b79cf3e07e0fdc018842a4f1cab2ccf`, equal to the
local file.
Not verified in this pass: the reported "content lost" symptom could not be
reproduced at `791d3dd`, so there is no before/after diff of a fixed regression;
the "definition-only, never-visited stage" and blank status/outcome edge cases are
covered by the existing unit tests (`StageDetailSheetTest`, `FormatTest`) rather than
driven on the device; the narrow/wide gallery thumbnail failure for run 60's corrupt
artifacts is a data issue in that run, not re-tested against a repaired copy.
## Covered panes show a compact identity, with a minimum peek width (16 Oct 2026)
> **Superseded** by "The covered edge is measured, not budgeted" below: the
> `MIN_COVERED_PANE_WIDTH_DP`/`PEEK_WIDTH_DP` split of a fixed budget no longer
> decides the layout. A covered edge is now as wide as the identity it has to
> show; the two tokens only bound which statistics that identity shows.
A wide-window stack no longer squeezes a full pane into each covered peek: a
covered pane now renders only its compact identity (a title and at most one
status/subtitle, centred in its strip) and its full body — tab rail, list,
gallery, scroll body — is never drawn into a sliver. `android/` only; nothing in
the Pipelines server, its Go source, the Docker/compose files or the installer was
touched, no dependency was added, no run was started from the app, and the
attached Pixel 10 Pro Fold was never installed on or driven (the debug APK was
installed with `adb -s emulator-5554 install -r`).
- **Compact covered panes.** `SlidingPaneStack`'s `pane` lambda now receives a
`covered: Boolean`; on a wide window a covered level is composed inside a box
constrained to its visible strip, and the caller renders only
`ui/components/PaneIdentity.kt` — a centred title plus at most one
status/subtitle line. The list (`PipelineListScreen`/`RunHistoryScreen`), both
detail screens and the stage pane each gained a `covered` branch that
early-returns after their data-loading effects, so nothing heavy is composed
into a sliver. The strip itself stays a separate, higher tappable sibling and
the compact identity rides with the pane's own slide.
- **A named minimum covered width, and a fold.** `MIN_COVERED_PANE_WIDTH_DP`
(`112.dp`) is the least width a covered pane's compact identity needs.
`peekStripsDp` shows at most `budget / MIN_COVERED_PANE_WIDTH_DP` covered peeks;
when a stack has more covered levels than that, the oldest levels fold into a
single edge indicator (`"<n> more"`) rather than being squeezed below the
minimum, and the number of peeks shown shrinks instead of their width. The fixed
budget (`PEEK_BUDGET_DP`, `224.dp`) and the constant active-pane width are
unchanged.
- **Unchanged behaviour.** Tapping a covered pane's peek calls the same
`onPopTo(level)`, closing everything to its right; Back/gesture/back arrow and
the narrow (no-peek) layout are untouched.
Evidence (macOS, JDK 17 from Homebrew `openjdk@17`, Gradle 8.11.1,
`ANDROID_HOME=/Users/alan/Library/Android/sdk`, `--offline`):
- `gradle :app:testDebugUnitTest` reported **134 tests, 0 failures, 0 errors**;
`gradle :app:assembleDebug` succeeded (17,992,288-byte debug APK, sha256
`3923224136be7ef9bdd8eb87111fae1f6af0211a7ba070af0e5270e324a0fc93`). The
rewritten `SlidingPaneStackTest` has 10 cases (narrow spends no peek, the wide
active pane is constant width at every depth, two covered levels each keep the
minimum, a fourth level folds the oldest into one indicator carrying its count,
the newest level still peeks, the first strip clears the gesture inset, the
budget clamps, a tiny host never goes negative, strips are monotonic and
deterministic, and widths are host-less-offset).
- On `emulator-5554` (2076x2152, density 390 ≈ 852dp wide; **never** the attached
Pixel) against the live server `ws://10.0.2.2:8080/connect`, driven with
`adb shell input` and `uiautomator dump`:
- Wide, `uiautomator dump` of the peek strips: at two levels the single strip
was `[73,165]–[546,1859]` (`[30dp, 224dp]` after the ~30dp left gesture
inset); at three levels the two strips were `[73,165]–[273,1859]` and
`[273,165]–[546,1859]` (`[30dp,112dp]` and `[112dp,224dp]`), so the active
pane still starts at `224dp` (constant width) and each covered pane now keeps
at least `112dp` for its identity.
- Narrowest wide size (`wm size 1463x2152`, density 390 = 600dp): the same
`224dp` budget, strips `[73,127]–[273,1859]` and `[273,127]–[546,1859]`; both
compact identities stayed readable and the active pane was full.
- Tapping the detail peek (`409 1000`) at three levels popped to the detail
(only `Back to pipelines` left); tapping the list peek (`173 1000`) popped to
the list (no strips). `input keyevent 4` at depth 2 returned to depth 1 (one
`Back to pipelines` strip).
- Narrow (`wm size 1080x1920`, `wm density 480`, ≈360dp): opening a pipeline
showed **0** `Back to …` strips and the detail tabs as before.
- `adb -s emulator-5554 logcat -d` contained 0 `FATAL EXCEPTION`; no run was
started from the app.
- Screenshots were written to the run's artifacts directory:
`wide-2-levels.png` (the list covered as `Pipelines · 11 on this server`),
`wide-3-levels.png` (list and detail covered, stage active) and
`wide-narrowest.png` (600dp); `wide-2-levels-after-peek.png` is the state
after the peek tap.
- **APK publish.** `app/build/outputs/apk/debug/app-debug.apk` was copied to
`…/artifacts/65/1/pipelines-debug-wip-206953e.apk` (`206953e` =
`git rev-parse --short HEAD`); `shasum -a 256` matched. `curl -I
http://10.0.0.249:8080/artifacts/65/1/pipelines-debug-wip-206953e.apk` (LAN
address from `ipconfig getifaddr en0`) returned `HTTP/1.1 200 OK`,
`Content-Type: application/vnd.android.package-archive`, `Content-Length:
17992288`; a streamed `GET | shasum -a 256` equalled the local file. At 17.2 MiB
it exceeds the server's 8 MiB per-file inventory cap, so it is served by direct
URL only.
Not verified in this pass: the four-level / folded layout on a device — the app
has exactly three pane levels (`MasterPane.List/Detail/Stage`, `MAX_PANE_DEPTH =
2`), so the fold is unreachable and its rule is covered by the pure
`SlidingPaneStackTest` cases instead; a long covered detail title wraps to three
centred lines and ellipsizes (e.g. `Pipelines maintenance - plan implem…`) rather
than being rotated.
## Covered panes carry a compact statistics block (16 Oct 2026)
A covered pane's compact identity is no longer a bare title/subtitle: it now
shows a small vertical block of labelled statistics, aggregated client-side from
the run history the app already receives, degrading with the strip's width.
`android/` only; nothing in the Pipelines server, its Go source, the
Docker/compose files or the installer was touched, no dependency was added (the
declared `material-icons-extended` is unchanged), no run was started from the app
and no server field was added.
- **Pipeline statistics.** When the covered pane is a pipeline
(`PipelineDetailScreen`, and `RunDetailScreen` through its run's pipeline) the
block shows the run counts (`runs`/`succeeded`/`failed`/`active`), the last
run's status and how long ago it started, and the average duration over the
runs that finished. `ui/screens/PaneStats.kt` folds the history in one pass; the
counts mirror the server's own vocabulary (`active` = queued/running, per
`internal/pipeline/stats.go`) and a still-running run never drags the average.
A run pane whose run (and so whose pipeline) has not loaded yet stays
title-only: an absent pipeline id is "not known yet", never the whole history,
so it can never show the server-wide summary as if it were the run's pipeline.
- **List statistics.** When the covered pane is a list, `PipelineListScreen` and
`RunHistoryScreen` show the whole history's counts by status and the single most
recent run; a runs list scoped to one pipeline shows that pipeline's own
numbers.
- **Width degradation.** `PaneIdentity` measures its own strip and shows the title
only below one peek width, the run counts up to
`MIN_COVERED_PANE_WIDTH_DP + PEEK_WIDTH_DP`, and the full block above it, so a
thin peek drops whole labelled statistics instead of clipping a number or
printing an unlabelled figure. Each statistic is a label above its own value, so
the number never shares a line with a label that could clip it. The boundaries
reuse the named geometry tokens and the decision is the pure
`paneStatTier`/`visiblePaneStats` pair.
- **One recency rule.** The "most recent run" comparison is the shared
`isMoreRecent` helper, used by the single-pass `latestRunByPipeline` join and by
the covered summary's own fold, so the pipeline row's last-run badge, the "most
recent run" sort and the covered summary all agree on which run is the latest
without grouping the history into intermediate lists.
- **Two aggregation entry points.** `ui/screens/PaneStats.kt` exposes
`pipelineStatLines(runs, pipelineId, now)` for the pipeline-scoped panes and
`listStatLines(runs, now)` for the list panes, so "which statistics, from which
history, or none until it has loaded" lives in one place instead of at each
call site and a null pipeline id can never be mistaken for the whole history.
The fold is a single pass (`RunTally.add` tracks the counts, the finished-run
duration total and the most recent run together), so a scoped pipeline summary
never allocates a filtered list or walks the history twice.
Evidence (macOS, JDK 17 from Homebrew `openjdk@17`, the cached Gradle 8.11.1
distribution, `ANDROID_HOME=~/Library/Android/sdk`, `--offline`):
- `:app:testDebugUnitTest :app:assembleDebug --offline --console=plain` →
`BUILD SUCCESSFUL in 2s` (41 actionable tasks: 8 executed, 33 up-to-date). The
result XMLs total **279 tests, 0 failures, 0 errors, 0 skipped** across 32
files; `app/build/outputs/apk/debug/app-debug.apk` is 18,204,486 bytes, sha256
`196c9d6f4acbcc75769fd52ecadac66378bad78994056895f26ff65da077718c`. The
`PaneStatsTest` (15 cases) covers the per-pipeline counts, queued as active, the
last run's state/age, the average over finished runs, zero-duration runs, a
pipeline with no runs, an unknown pipeline id, the whole-history list fold and
the labelled lines, and that an absent/unknown pipeline id yields no lines
rather than the list summary; the `PaneIdentityTest` (5 cases) pins the width
tiers, that the counts tier drops only the detail lines, and that every shown
statistic keeps its label and value.
- **APK publish.** `app-debug.apk` was copied to
`~/.local/share/pipelines/data/artifacts/142/3/pipelines-debug-wip-c700b28.apk`
(`c700b28` = `git rev-parse --short HEAD`; the tree is uncommitted WIP on top of
it); `shasum -a 256` matched the built file (`196c9d6f…`). `curl -I
http://10.0.0.249:8080/artifacts/142/3/pipelines-debug-wip-c700b28.apk` returned
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18204486`.
- **Device evidence (emulator-5554).** The debug APK was installed with
`adb -s emulator-5554 install -r` (never the attached Pixel, never
`emulator-5556`) against the live LAN server, and the wide and narrow layouts
were captured with `adb -s emulator-5554 shell screencap -p /sdcard/cap.png`
then `adb -s emulator-5554 pull`. Captures are in the same artifacts directory:
`wide-1-level-runs-list.png`, `wide-2-levels-covered-list-stats.png`,
`wide-3-levels-covered-stats.png` (plus `…pane0…`/`…pane1…` crops) and
`narrow-runs-list.png`. OCR of the covered strips confirms the block: at two
levels the covered runs list reads `Runs / runs 145 / succeeded 90 / failed 39 /
active 6 / last running - 4m ago` (Full tier); at three levels its two covered
strips (82 dp and 112 dp wide) drop the `last` line and keep only the labelled
counts, and the covered run strip reads the run's own pipeline id 11 numbers
(`runs 60 / succeeded 37 / failed 14 / active 5`) — clearly not the server-wide
145, so an unknown pipeline can no longer borrow the list summary. Four levels
remain unreachable: `MAX_PANE_DEPTH = 2` gives exactly three pane levels, so the
three-covered degradation is captured instead.
- **Device-instruction conflict.** The run's Constraints said use `emulator-5554`
exclusively and never the operator's physical device; an appended paragraph said
to use the attached Pixel and never an emulator. There is no path that satisfies
both, and installing this WIP build on the operator's own phone is forbidden by
the task, so the emulator named in the Constraints was used (with the
`device.lock` held) and the Pixel and `emulator-5556` were never touched. While
capturing, another lane repeatedly overwrote the installed APK on
`emulator-5554` (the installed hash reverted from this build to
`2adaf03e…`/`5912d38f…` at 16:18 and 16:20 until reinstalled), which is why the
APK hash was re-checked immediately before the captures that are reported here.
## Run stage pane leads with the run's results (16 Oct 2026)
A stage opened from a run no longer leads with its own definition. The pane now
shows the run's result first — the stage's status, outcome, duration, visit and
target, then the visit's results — and the stage's own definition is one
collapsed `Stage definition` section at the bottom. `android/` only; nothing in
the Pipelines server, its Go source, the Docker/compose files or the installer was
touched, no dependency was added, no run was started from the app, and the
attached Pixel was never installed on or driven (the debug APK was installed with
`adb -s emulator-5554 install -r`).
- **Results first.** `ui/graph/StageDetailPane.kt` renders `headlineFields`
(Status, Outcome, Duration, Visit, Target, Model target — the run-side facts)
immediately, then the run-side result sections in
`STAGE_RESULT_SECTIONS` order: `Artifacts` (the per-visit gallery, first, per the
operator's earlier "artifacts at the top" preference), `Output`, `Input`, then
the remaining evidence under `This run`. Each is collapsed by default via the
unchanged `SectionHeader`/`rememberSectionExpansion`, and a new private
`StageSection` renders them all through one header+content helper.
- **One collapsed definition.** The previous Model/Provider headline promotion is
reverted: `STAGE_CONFIG_HEADLINE_LABELS`, `stageConfigHeadlineFields` and
`remainingDefinitionFields` are gone, and the full `stageDefinitionFields`
(type, prompt, output contract, outcomes, model, provider, configs, tools,
limits, memory, notify) renders in the single `Stage definition` section
(`STAGE_DEFINITION_KEY`/`STAGE_DEFINITION_TITLE`). Nothing visible before is
removed — Model/Provider are reachable by expanding the section.
- **Run vs. definition-only.** `StageDetailPane` gained `runContext` (default
false); `RunStagePane` passes `true` (Timeline, run graph and run stage list all
go through it), `PipelineStagePane` leaves it `false`. The pure
`definitionStartsExpanded(runContext)` seeds the section's default: collapsed in
a run pane, expanded in a pipeline stage pane, where the definition is the only
content. `rememberSectionExpansion` gained an `initiallyExpanded` set (part of
the save key) for that seed.
- **Visit tabs unchanged.** The visit tab row (`showVisitTabs`, `clampVisitIndex`)
still switches the selected visit above the results.
Evidence (macOS, JDK 17 from Homebrew `openjdk@17`, cached Gradle 8.11.1,
`ANDROID_HOME=/Users/alan/Library/Android/sdk`, `--offline`):
- `gradle :app:testDebugUnitTest :app:assembleDebug` → `BUILD SUCCESSFUL`; the
test-result XMLs aggregate to **137 tests, 0 failures, 0 errors, 0 skipped**.
`StageDetailSheetTest` dropped the two promotion tests and gained
`theRunHeadlineIsRunSideOnlyAndTheDefinitionKeepsModelAndProvider`,
`theDefinitionStartsExpandedOnlyWithoutARunContext` and
`theRunResultSectionsLeadWithTheArtifactsGallery` (12 cases, 0 failures).
`app/build/outputs/apk/debug/app-debug.apk` is 18,011,770 bytes, sha256
`1ba2119ad2e2c34b0928460036bdda7b02e2b4d819be2c68d225dd9b072611b8`.
- `gradle :app:lintDebug` under JDK 17 fails only on the two **pre-existing**
`NewApi` errors for `android:windowLightNavigationBar` in `res/values/themes.xml`
and `res/values-night/themes.xml` (unchanged by this pass).
- On `emulator-5554` (narrow `wm size 1080x1920` / `wm density 480` ≈ 360dp; wide
`wm size reset` / `wm density reset` = 2076x2152 / 390 ≈ 852dp; **never** the
attached Pixel) against the live server `ws://10.0.2.2:8080/connect`, driven
with `adb shell input` and `uiautomator dump`; run 60's `implementer` (two
visits) and pipeline 11 v1's `implementer`:
- `narrow_timeline_top.png` / `narrow_timeline_sections.png` and
`wide_timeline_stage.png`: the `implementer` pane opened from the Timeline row
`implementer · visit 2` — title, `model` chip, `visit 1`/`visit 2` tabs,
Status/Outcome/Duration/Visit/Target, then `Artifacts`, `Output`, `Input`,
`This run`, `Stage definition` (all collapsed) in that order.
- `narrow_graph_top.png` / `narrow_graph_sections.png` and
`wide_graph_stage.png`: the same pane opened by tapping the `implementer` graph
node (starts on visit 2), identical ordering.
- `wide_pipeline_stage_definition.png`: pipeline 11 v1's `implementer` opened
from the pipeline graph — no visit tabs and no run sections, `Stage definition`
**expanded** with Type/Prompt/Output, because a pipeline stage has no run.
- `narrow_run_definition_model_provider.png`: the run pane's `Stage definition`
expanded to Type `model`, Prompt, Outcomes, Model `deepseek-v4.1-flash`,
Provider `opencode-go`, Retries, Timeout, Tools, Memory — nothing removed.
- `narrow_run_artifacts_gallery.png`: the `Artifacts` section (the first
result): `Artifacts · 47 recorded · partial capture` and the thumbnail grid.
(Run 60's own artifact files are the corrupt `adb screencap` captures noted in
the run-64 pass, so they render the honest `!` failure mark, not a blank tile.)
- Every capture was written and validated with
`android/scripts/capture_png.sh -s emulator-5554 …` (`--check` re-validated all
eight). `adb -s emulator-5554 logcat -d` contained **0** `FATAL EXCEPTION`,
**0** `E AndroidRuntime` and no `E`-level `net.awan.pipelines` line; no run was
started from the app. Screenshots and the raw `uiautomator` dumps are in
`~/.local/share/pipelines/data/artifacts/68/2/`.
- **APK publish.** `app/build/outputs/apk/debug/app-debug.apk` was copied to
`~/.local/share/pipelines/data/artifacts/68/1/pipelines-debug-wip-cd85f69.apk`
(`cd85f69` = `git rev-parse --short HEAD`; the working tree is uncommitted WIP on
top of it); `shasum -a 256` matched. `curl -I
http://10.0.0.249:8080/artifacts/68/1/pipelines-debug-wip-cd85f69.apk` (LAN
address from `ipconfig getifaddr en0`) returned `HTTP/1.1 200 OK`,
`Content-Type: application/vnd.android.package-archive`, `Content-Length:
18011770`; a streamed `GET | shasum -a 256` returned
`1ba2119ad2e2c34b0928460036bdda7b02e2b4d819be2c68d225dd9b072611b8`, equal to the
local file. At 17.2 MiB it exceeds the server's 8 MiB per-file inventory cap, so
it is served by direct URL only.
Not verified in this pass: a run stage that was never visited (no recorded step)
still belongs to a run, so its definition is collapsed; the pane then leads with
only the title/type and the collapsed section, which the pure
`definitionStartsExpanded` rule covers but was not driven on the device. A
terminal node opened from a run graph likewise collapses its single
`Incoming routes` definition-and-only section. The wide layout was exercised
headless on the fold AVD, not on physical hardware.
## The stage pane is an opaque container (16 Oct 2026)
The stage detail pane already painted an opaque `Scaffold`, but that was the app
`background` role, identical to the peek strips it slides over, so it read as
"no background" and its rows ran together with the covered pane's compact
identity. The pane is now a raised sheet.
- `StageDetailPane` gives the pane the theme's `surfaceContainer` role through a
single `paneContainerColor()` used by all of the pane's own surfaces: the
`Scaffold` container, the `TopAppBar`, the visit `PrimaryScrollableTabRow` and
every section header (`StageSection` passes it to the shared `SectionHeader`,
which gained a `containerColor` parameter defaulting to the previous
`background`). The pane therefore fully covers the area it occupies — including
under a section header — as one tone, and sits a clear step above the
`background` peeks and above the content it covers on a narrow window. The
covered pane's peek is unchanged and still expected.
- `CodeBlock` and the artifacts `ArtifactRow` moved from `surfaceContainer` to
`surfaceContainerHigh` (the full-size artifact dialog to
`surfaceContainerHighest`), so a card stays a visible card on both the app
background and a pane's `surfaceContainer` sheet. No geometry, insets or
dependencies changed; all colour roles come from the existing theme.
Evidence on `emulator-5554` (fold AVD; narrow `wm size 1080x1920`, wide
`wm size reset` = 2076x2152 / 390dpi ≈ 852dp; **never** the attached Pixel)
against the live server, driven with `adb shell input` and `uiautomator dump`,
using `android/scripts/capture_png.sh -s emulator-5554` (every image validated):
- **`gradle :app:assembleDebug`** → `BUILD SUCCESSFUL`; `app/build/outputs/apk/debug/app-debug.apk`
is 18,012,281 bytes.
- **`gradle :app:testDebugUnitTest`** → `BUILD SUCCESSFUL`; the 18 test-result XMLs
aggregate to **137 tests, 0 failures, 0 errors, 0 skipped**.
- `pane-opaque-wide-over-graph.png` / `pane-opaque-wide-over-timeline.png`: on the
wide window the `implementer` pane opened over run 69's Graph tab and over its
Timeline tab is a solid `surfaceContainer` sheet starting at the fixed peek
budget, clearly lighter than the `Runs`/run peeks to its left.
- `pane-opaque-narrow-over-graph.png` / `pane-opaque-narrow-over-timeline.png`:
on the narrow window the same pane opened over the run graph and the Timeline
fills the window as one opaque sheet with no bleed-through.
- `pane-opaque-narrow-over-running-graph.png`: the pane opened over run 70's
**running** graph (visit tabs, `Status running`) is equally opaque and readable
while the run polled.
- `pane-opaque-wide-definition-expanded.png` /
`pane-opaque-narrow-definition-expanded.png`: with a section expanded, the
`Prompt`/`Transcript` code cards are clearly a step lighter than the pane, so
the container change did not flatten the card hierarchy.
- **APK publish.** The debug APK was copied to
`~/.local/share/pipelines/data/artifacts/71/1/pipelines-debug-wip-cfd5887.apk`
(`cfd5887` = `git rev-parse --short HEAD`; the working tree is uncommitted WIP on
top of it), sha256
`67f5223bd8f1c5ce8939ea786b62a222cdb5e59763d8bf3fd636ba5d52b6985e`. `curl -I
http://10.0.0.249:8080/artifacts/71/1/pipelines-debug-wip-cfd5887.apk` returned
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18012281`; a streamed `GET | shasum -a 256` returned the same
hash. At 17.2 MiB it exceeds the server's 8 MiB per-file inventory cap, so it is
served by direct URL only.
Not verified: the two app appearances are dark-only (`PipelinesTheme` defaults to
dark), so the `surfaceContainer` step was checked in the dark scheme only; the
pane's leading-edge shadow is not used (the tonal step is the separation) so no
new elevation token was introduced.
### Re-verification of the committed sheet (`1fece88`, 16 Oct 2026, run 73)
The change above is committed at `1fece88`; this run rebuilt and re-installed it
and re-captured the pane on `emulator-5554` (fold AVD; narrow `wm size
1080x1920`, wide `wm size reset` = 2076x2152 / 390dpi ≈ 852dp; **never** the
attached Pixel) against the live server, using `android/scripts/capture_png.sh -s
emulator-5554` (every image validated):
- `gradle :app:assembleDebug` → `BUILD SUCCESSFUL` (JDK 17, Gradle 8.11.1,
`--offline`); `app/build/outputs/apk/debug/app-debug.apk` is 17,846,953 bytes,
sha256 `d47c5bf993ca28293b188829c7fd5eec709fac49f04cca520377df96d393c887`.
- `gradle :app:testDebugUnitTest --rerun-tasks` → `BUILD SUCCESSFUL`; the 18
test-result XMLs aggregate to **137 tests, 0 failures, 0 errors, 0 skipped**.
- `pane-opaque-wide-over-graph.png` / `pane-opaque-wide-over-timeline.png` and
`pane-opaque-narrow-over-graph.png` / `pane-opaque-narrow-over-timeline.png`:
the `implementer` pane opened over run 72's Graph and Timeline is one opaque
`surfaceContainer` sheet — on the wide window from the fixed peek budget to the
right edge, on the narrow window full-window — with the headline rows, section
headers and the tonal step clearly readable.
- `pane-opaque-narrow-over-running-graph.png`: the pane over run 73's running
graph (`Status running`) is equally opaque.
- `adb -s emulator-5554 logcat -d` contained 0 `FATAL EXCEPTION` / `E
AndroidRuntime` lines during the sweep.
- **APK publish.** Copied to
`~/.local/share/pipelines/data/artifacts/73/1/pipelines-debug-wip-1fece88.apk`
(`1fece88` = `git rev-parse --short HEAD`). `curl -I
http://10.0.0.249:8080/artifacts/73/1/pipelines-debug-wip-1fece88.apk` returned
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 17846953`; a streamed `GET | shasum -a 256` returned the same
`d47c5bf…` hash.
### Re-verification on the current tree (`1fece88`, 16 Oct 2026, run 77)
Same committed sheet, rebuilt and re-driven this run on `emulator-5554` only
against the live server:
- `gradle :app:assembleDebug :app:testDebugUnitTest --offline` → `BUILD
SUCCESSFUL` (Gradle 9.7.1, JDK 17 from the Android Studio JBR,
`ANDROID_HOME=~/Library/Android/sdk`); `gradle :app:testDebugUnitTest
--rerun-tasks --offline` re-ran all 18 result XMLs to **137 tests, 0 failures, 0
errors, 0 skipped**. The fresh `app-debug.apk` is 17,846,953 bytes, sha256
`8ff68d24…` — the same size but a different hash from `d47c5bf…` above, because
APK signing is not byte-reproducible (called out in the run-73 review).
- `pane-opaque-wide-over-graph.png` / `pane-opaque-wide-over-timeline.png`
(2076x2152 @ 390dpi ≈ 852dp) and `pane-opaque-narrow-over-graph.png` /
`pane-opaque-narrow-over-timeline.png` (`wm size 1080x1920`, `wm density 480` ≈
360dp): run 76's running `implementer` pane is one solid `surfaceContainer`
sheet, from the fixed peek budget (546 px) to the right edge on the wide window
and full-window on the narrow one, with the headline rows and section headers
readable and the covered panes' peeks untouched. `adb -s emulator-5554 logcat -d`
held 0 `FATAL EXCEPTION` / `E AndroidRuntime` lines; `wm size`/`density` were
reset afterwards.
- **APK publish.** Copied to
`~/.local/share/pipelines/data/artifacts/77/1/pipelines-debug-wip-1fece88.apk`
(`1fece88` = `git rev-parse --short HEAD`); local and streamed `shasum -a 256`
both return `8ff68d24…`. `curl -I
http://10.0.0.249:8080/artifacts/77/1/pipelines-debug-wip-1fece88.apk` returned
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 17846953`.
### Mirror the open/close pane animation (16 Oct 2026, run 82)
A pane used to vanish on close: the destination cleared the selection that named
it (a null `itemId`/`stageKey`) in the same recomposition that lowered the depth,
so the sliding box carried no content, while the pane underneath swapped between
its compact peek and its full body at the transition instant. The slide also used
the default `spring()`, so it had no fixed duration or easing to run backwards.
- `SlidingPaneStack` now slides every pane with one shared spec
(`paneSlideSpec`): a fixed `PANE_SLIDE_MILLIS` (300) duration and a symmetric
`PANE_SLIDE_EASING` (`CubicBezierEasing(0.42, 0, 0.58, 1)`), so the same curve
run from the open offset back to the closed one is the open curve travelled
backwards. A single close is therefore the exact time-reverse of the open.
- The stack reports a level **mounted** while it is open or has not yet finished
sliding out, and only then calls the caller's `pane`. The destinations name a
level's content through the new `rememberPaneContent(value)`, which keeps the
last non-null value, so a closing pane keeps rendering the content that opened
it until it is off-screen instead of vanishing. A fully closed level composes
nothing, so a closed pane does no work and shows no stale content.
- When one tap pops several levels, `paneSlideDelayMillis` waits
`PANE_POP_STEP_MILLIS` (60) longer for each level below the topmost, so the
cascade reverses in order. A level that is open or opening never waits, so a
single-level open/close is unaffected.
- Compose already maps the system animator duration scale onto its animations, so
with animations disabled the slide is instant without a special case.
- The covered pane's compact-vs-full presentation still swaps at the transition
instant, exactly as opening already did (a styled change, not empty content);
that presentation swap was not altered.
Verified on `emulator-5554` only against the live server (wide fold layout,
2076x2152 / 390dpi ≈ 852dp; never the attached Pixel):
- `gradle :app:assembleDebug :app:testDebugUnitTest --offline` → `BUILD
SUCCESSFUL`; `gradle :app:testDebugUnitTest --rerun-tasks --offline` re-ran all
18 result XMLs to **140 tests, 0 failures, 0 errors, 0 skipped** (3 new pure
cases: the easing is its own reverse, a single close starts at once, several
closing levels stagger from the top).
- Open/close pair: `input tap <timeline row>` then `input keyevent KEYCODE_BACK`
on run 80's Timeline, captured with `screenrecord` and split into
`open-1x-frames.png` / `close-1x-frames.png`; the stage pane slides in from the
right on open and slides back out to the right on close, revealing the run
detail underneath, instead of vanishing.
- Multi-level pop: at depth 2, tapping the list peek (`onPopTo(0)`) captured in
`multi-level-pop-1x-frames.png`; the stage pane leaves first and the list is
revealed level by level.
- Slow motion (`animator_duration_scale 10`): `open-close-slow10x.mp4` /
`open-close-slow10x-frames.png`; the close frames are the open frames reversed.
- Reduced motion: `animator_duration_scale 0`; 0.2 s after the open tap the stage
pane is already at its final offset (title at `x=585`), and 0.2 s after Back the
detail is already restored — unchanged 0.6 s later.
- Narrow window (`wm size 1080x1920`, `wm density 480` ≈ 360dp):
`narrow-open-1x-frames.png` / `narrow-close-1x-frames.png` — the full-window run
detail slides in from the right on open and back out to the right on close,
revealing the runs list underneath; `wm size`/`density` reset afterwards.
- Stability: tapping Back mid-open (0.8 s in at `animator_duration_scale 10`)
settles fully at the detail, never half-slid.
- `adb -s emulator-5554 logcat -d` held 0 `FATAL EXCEPTION` / `E
AndroidRuntime` lines; `animator_duration_scale` was left at 1.
- **APK publish.** `app-debug.apk` (18,012,493 bytes, sha256 `d1c5506f…`) copied
to `~/.local/share/pipelines/data/artifacts/82/1/pipelines-debug-wip-1fece88.apk`
(`1fece88` = `git rev-parse --short HEAD`); `curl -I
http://10.0.0.249:8080/artifacts/82/1/pipelines-debug-wip-1fece88.apk` returned
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18012493`.
### Retain the parent identity of a closing pane (16 Oct 2026, run 82/3)
Review of the change above found a blocking defect: `popTo(0)` returns a bare
`PaneSelection` (`itemId=0`, `stageKey=null`), and only the level-1 pane retained
its `itemId`/version pair; the level-2 pane still read its parent id **live** from
the selection, so closing a two-level stack to the list fed `runId=0` /
`pipelineId=0` into the stage pane. The run was then `null`, the graph empty, the
node not found, and the whole exit animation showed the `terminal` chip plus "No
details recorded for this node." (captured in `repro-pop-050.png` /
`pl-pop-090.png`); the same live read also reset the closing detail pane's section
to Summary.
- `rememberPaneContent` now retains the **full** parent identity at every level:
pipeline detail `(itemId, version, sectionIndex)`, pipeline stage
`(itemId, version, stageKey)`, run detail `(itemId, sectionIndex)` and run stage
`(itemId, stageKey, stageVisit)`. Each closing pane therefore keeps rendering
the content, section and visit that opened it until it is off-screen; nothing a
pane displays is read live from the selection while it exits.
- No timing, easing or geometry changed — only what a closing pane reads.
Verified on `emulator-5554` only (2076x2152 / 390dpi fold layout, live server),
`animator_duration_scale 10` for the frame work:
- `gradle :app:assembleDebug :app:testDebugUnitTest --offline` → `BUILD
SUCCESSFUL`; `gradle :app:testDebugUnitTest --rerun-tasks --offline` re-ran all
18 result XMLs to **140 tests, 0 failures, 0 errors, 0 skipped**.
- Pipeline multi-level pop (tapping the list peek, `onPopTo(0)`, from depth 2):
`before-after-pipeline-pop.png` puts the review's empty `pl-pop-090.png` (left)
beside a frame of this build (right); every frame in
`multi-level-pop-pipelines-sheet.png` shows the closing stage pane still
rendering `implementer` / `model` / `Stage definition` with its Prompt, instead
of the empty `terminal` state.
- Runs multi-level pop: `multi-level-pop-runs-sheet.png` /
`multi-level-pop-runs-stage-mid-exit.png` — the closing run stage pane keeps its
run identity (`Status completed`, `Outcome success`, `Duration 5m18s`,
`Visit 2 / 5`, `Target reviewer`, the Artifacts gallery), so `runId` is retained
and the empty-node fallback never appears.
- Single-level close (`single-level-close-runs-sheet.png`): the run detail slides
back out to the right with its Summary section and rows intact, revealing the
runs list underneath.
- Reduced motion: `animator_duration_scale 0`; two captures 0.15 s and 0.6 s
after Back are byte-identical (`sha256 692437bc…`), i.e. the close is instant.
- `adb -s emulator-5554 logcat -d` held 0 `FATAL EXCEPTION` / `E
AndroidRuntime` lines; `animator_duration_scale` was left at 1.
- **APK publish.** `app-debug.apk` (18,012,767 bytes, sha256 `b3b7d948…`) copied
to `~/.local/share/pipelines/data/artifacts/82/3/pipelines-debug-wip-1fece88.apk`
(`1fece88` = `git rev-parse --short HEAD`); `curl -I
http://10.0.0.249:8080/artifacts/82/3/pipelines-debug-wip-1fece88.apk` returned
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18012767`; a streamed `GET | shasum -a 256` returned the same
`b3b7d948…`.
## Pane safe area (16 Oct 2026)
The pane stack now guarantees every pane clears the system UI from the live
window insets instead of relying on each screen's implicit Material defaults.
One shared `paneSafeArea()` (`WindowInsets.safeDrawing`: status bar, any display
cutout, navigation bar and IME) is the single source of that geometry — never a
fixed padding:
- `SlidingPaneStack` reads it (unioned with `systemGestures`) for the covered
peeks' strip geometry, so a peek also clears a cutout and the keyboard.
- Each pane's `Scaffold(contentWindowInsets = paneSafeArea())` reserves it once
for the content, and its `TopAppBar(windowInsets = paneSafeArea().only(Top +
Horizontal))` reserves the top/horizontal part, so a pane can never sit under
the status bar, a cutout, the navigation bar or the IME. Applied to the five
stacked panes (`PipelineListScreen`, `PipelineDetailScreen`, `RunHistoryScreen`,
`RunDetailScreen`, `StageDetailPane`) and to `SettingsScreen`.
- No inset is applied twice: while the connection banner is shown it owns the top
inset and the `NavHost` consumes `paneSafeArea().only(Top)` (was `statusBars`),
so the pane's app bar directly below the banner is not padded a second time.
- The search field lives inside the pane's `Scaffold` content, so it is already
inside the safe area; a future floating overlay must read the same
`paneSafeArea()`.
- The floating destinations pill clears the same safe area
(`windowInsetsPadding(paneSafeArea())`), so the keyboard no longer hides it.
Evidence on `emulator-5554` only (fold AVD; narrow `wm size 1080x2340` @ 390dpi ≈
443dp, wide `wm size reset` = 2076x2152 / 390dpi ≈ 852dp; **never** the attached
Pixel), against the live server, driven with `adb shell input` / `uiautomator
dump` and captured with `android/scripts/capture_png.sh -s emulator-5554` (every
image validated):
- `gradle :app:assembleDebug --console=plain` → `BUILD SUCCESSFUL` (Gradle
8.11.1, JDK 17); `app/build/outputs/apk/debug/app-debug.apk` is 18,029,402
bytes, sha256 `45c1bd09b9622dfe023ff62129a80c44b060bf7c15963757e3f1a5dfa5f851fb`.
- `gradle :app:testDebugUnitTest --rerun-tasks --console=plain` →
`BUILD SUCCESSFUL`; the 18 result XMLs aggregate to **140 tests, 0 failures, 0
errors, 0 skipped**.
- `safe-area-narrow-stage-pane.png` / `safe-area-wide-stage-pane.png`: the run 84
`implementer` stage pane on the narrow and wide windows — the status bar and its
icons are visible, and the pane's app bar and scrolling body sit fully below
them, not clipped or covered.
- `safe-area-wide-ime-open.png` / `safe-area-wide-ime-scrolled.png`: the pipeline
search field focused (IME shown); the list scrolls inside the remaining space so
the last pipeline row is fully visible above the keyboard, and the destination
pill sits above the IME.
- `safe-area-wide-banner-owns-top.png`: with the connection banner shown it owns
the top inset and the pane's app bar follows directly below it — the inset is
reserved once, never twice.
- `adb -s emulator-5554 logcat -d` held 0 `FATAL EXCEPTION` / `E AndroidRuntime`
lines; `wm size` was reset afterwards.
- **APK publish.** Copied to
`~/.local/share/pipelines/data/artifacts/86/1/pipelines-debug-wip-5ad4b58.apk`
(`5ad4b58` = `git rev-parse --short HEAD`; the working tree is uncommitted WIP on
top of it). `curl -I
http://10.0.0.249:8080/artifacts/86/1/pipelines-debug-wip-5ad4b58.apk` returned
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18029402`.
## Full-screen artifact image viewer (16 Oct 2026)
Tapping an image artifact now opens a full-screen viewer (in the run summary
grid, the per-visit artifacts list and the stage pane, which all render through
`ArtifactGallery`), replacing the former small centred dialog rather than stacking
on it. `android/` only; no dependency was added, no run was started from the app,
and every device command targeted `emulator-5554` (never the attached Pixel, never
`emulator-5556`).
- **Viewer.** New `ui/graph/ArtifactViewer.kt` renders a scrim-backed full-screen
`Dialog` (`usePlatformDefaultWidth = false`, `decorFitsSystemWindows = false`);
a `SideEffect` stretches the dialog window to `MATCH_PARENT`, fits no system
insets and draws into the display cutout (each API-guarded), so the dark backdrop
reaches every edge while the content re-applies `paneSafeArea()` (status bar,
cutout, navigation bar) itself. A top-right row keeps the open-in-new and
copy-link actions and adds a close button, backed by a translucent scrim
capsule so the light icons stay legible over a bright image. `dumpsys window`
confirms the dialog
window frame is `[0,0][2076,2152]` (previously inset to `[0,136][2076,2074]`).
- **Gestures.** Pinch zooms about the centroid and a drag pans via the existing
graph `zoomAbout`; a double-tap toggles between fit and 2.5x; a downward swipe at
fit dismisses; a plain tap does nothing. Zoom is clamped to `[1x, 5x]` of fit and
pan is clamped by the new pure `clampImageOffset` so the scaled image can never
be dragged off screen (each axis centred when smaller than the viewport, pinned
to `[viewport - content, 0]` when larger). Zoom state is remembered on the url,
so closing the viewer or opening another image starts again at fit/centred.
System Back and the close button dismiss the viewer without closing the pane
behind it (verified: 0 `Close viewer` nodes and the run detail still shown after
Back). The image loads through the existing cached, off-main-thread
`rememberArtifactBitmap` (now `internal`, reusing the shared fetch/decode path),
with a "Loading image…" spinner and a distinct "Couldn't load image." state. The
loading/error/unavailable message is drawn in the light `inverseSurface` role,
which contrasts with the always-black scrim (the previous `inverseOnSurface`
was a dark colour on the scrim, measured ~1.6:1).
- **Pure helpers.** `fitImageSize`, `clampImageOffset` and `toggleZoomScale` in
`ArtifactViewer.kt`; `ArtifactViewerTest` covers them (fitting, centre/edge
clamping, the toggle, and an anchored-zoom-then-clamp invariant). `zoomAbout`
and the loading path are the existing shared ones, not copies.
Evidence obtained in this pass (macOS, JDK 17 from Homebrew `openjdk@17`, Gradle
8.11.1 from the wrapper cache, `ANDROID_HOME=/Users/alan/Library/Android/sdk`):
- `gradle :app:testDebugUnitTest :app:assembleDebug --console=plain` →
`BUILD SUCCESSFUL`; the result XMLs aggregate to **149 tests, 0 failures, 0
errors, 0 skipped** (up from 140: the new `ArtifactViewerTest`).
`app/build/outputs/apk/debug/app-debug.apk` is 18,043,579 bytes, sha256
`1b3653dbdce9d62fc8dcfdcb986635829b70db38437d6769c77f91d16b7d6b3a`.
- `gradle :app:lintDebug` → only the two **pre-existing** `windowLightNavigationBar`
NewApi errors (`values/themes.xml`, `values-night/themes.xml`); no new lint
finding is attributed to `ArtifactViewer.kt` (39 warnings, down from 40 once the
cutout constant was API-guarded).
- On `emulator-5554` against the live server, the run 90 summary artifacts grid
was opened and `captures/viewer/` (git-ignored, every PNG validated by
`scripts/capture_png.sh -s emulator-5554`) holds: `01_viewer_open`,
`02_doubletap_zoom`, `03_pinch_zoom`, `04_pan`, `05_clamp_1..3`,
`06_fit_reset`, `07_swipedown_dismissed`, `08_back_dismissed`, `09_loading`,
`10_error`, `contact_sheet.png` and `viewer_gestures.mp4` (29 s). Pairwise
pixel diffs (`captures/imgdiff.py`): open→double-tap 19.72, double-tap→pinch
6.72, pinch→pan 5.29, and `05_clamp_1→2` 0.75 → `05_clamp_2→3` **0.0** (the
image is pinned at its bound and cannot be panned further off screen);
fit-reset diff 0.01 (double-tap restores fit exactly). After a swipe-down and
after Back the UI dump has 0 `Close viewer` nodes and the run detail is shown;
a single tap leaves the viewer open (diff 0.02). `Loading image…` and
`Couldn't load image.` were produced against a hanging and a 404 endpoint.
- `adb shell input` cannot synthesise a two-finger pinch (it injects one pointer)
and the shell cannot write `/dev/input` (`sendevent` is permission-denied on
this production image), so pinch and the timed double-tap were driven with a
test-only `app_process` injector (`captures/viewer/tools/Injector.java` →
`Injector.jar`) that injects multi-pointer `MotionEvent`s via the hidden
`InputManager.injectInputEvent`, the same mechanism the platform `input` command
uses. It is verification tooling only, not part of the app or its dependencies.
- `adb -s emulator-5554 logcat -d` held 0 `FATAL EXCEPTION` / 0 `E AndroidRuntime`
lines.
- **APK publish.** Copied to
`~/.local/share/pipelines/data/artifacts/91/1/pipelines-debug-wip-7b61906.apk`
(`7b61906` = `git rev-parse --short HEAD`). `curl -I
http://10.0.0.249:8080/artifacts/91/1/pipelines-debug-wip-7b61906.apk` returned
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18043579`, and a streamed `GET | shasum -a 256` equalled the
local file's `1b3653db…`. At 17.2 MiB it exceeds the 8 MiB per-file inventory
cap, so it is served by direct URL only.
Not verified in this pass: a real hardware fold (the emulator is the 2076x2152
inner display at 390 dpi); an Android 8/9 device branch (the `layoutInDisplayCutout
Mode = SHORT_EDGES` fallback is compiled and lint-guarded but only the API 36 path
ran).
## Page between artifacts in the full-screen viewer (17 Oct 2026)
The full-screen viewer is now a pager: a horizontal drag or flick moves to the
previous/next image artifact in gallery order, and the header shows the open
artifact's position ("2 of 5", reloading that artifact's own name, content type,
image and actions). `ArtifactGallery` owns the one viewer instance over
`pagedArtifacts(groups)` (group by group, each group's images in recorded order —
the order the grid draws), and each tile resolves its viewer index through the new
`viewerIndexByUrl` from that same list, so the grid and the viewer cannot disagree
about which artifact a tap opens (previously a second, untested running counter).
- **Gesture.** The paging/dismiss drag sits on a single full-screen surface in
`ArtifactViewerBody`, not on the image, so a drag that starts on the letterbox
around a fitted image pages too. The rule is "page only at fit": a pinch, or any
drag once the image is zoomed (`canPageAtScale`), pans via the shared
`zoomAbout`/`clampImageOffset` exactly as before. At the first/last artifact the
drag is damped (`PAGE_RESISTANCE`) and never wraps; a one-artifact gallery is
inert; a downward drag at fit still dismisses. The previous/next `IconButton`s
(disabled at each end) keep both neighbours reachable without a swipe, and a
loading/error/unavailable artifact shows its own state while its neighbours stay
reachable. The header, actions and page buttons share one `viewerCapsule()`
scrim background.
- **Pure helpers.** `pagedArtifacts`, `viewerIndexByUrl`, `pagedIndex` (the one
clamp shared by the gesture and the buttons) and `canPageAtScale` in
`ArtifactViewer.kt`.
- **Checks.** `gradle :app:testDebugUnitTest :app:assembleDebug --no-daemon` →
`BUILD SUCCESSFUL`; **317 tests, 0 failures, 0 errors, 0 skipped**. The paging
tests are in `ArtifactViewerTest` (`pagedIndex` next/previous, clamping at both
ends, a single-item and an empty list; `aZoomedViewerDoesNotPage`;
`pagedArtifactsAreTheGalleryImagesInGridOrder`; and
`theGridTileViewerIndicesMatchTheViewerOrder`, which walks the grid's draw order
and asserts every tile resolves to its viewer position). `gradle
:app:lintDebug` → only the two pre-existing `windowLightNavigationBar` NewApi
errors (`values/themes.xml`, `values-night/themes.xml`); 0 findings attributed to
`ArtifactViewer.kt` or `Artifacts.kt`.
- **APK publish.** `~/.local/share/pipelines/data/artifacts/224/3/pipelines-debug-wip-18db2f9.apk`
(`18db2f9` = `git rev-parse --short HEAD`), 18,093,313 bytes, md5
`540168beaf3c7f5b7f19eaecd2c3099a`; `curl -I
http://10.0.0.75:8080/artifacts/224/3/pipelines-debug-wip-18db2f9.apk` returned
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18093313`. Built with Gradle 8.11.1, AGP 8.7.2, JDK 17.0.10
(Android Studio JBR), `compileSdk 35`/`build-tools 35.0.0`, minSdk 26.
Not verified in this pass: the on-device swipe/zoom/back-gesture behaviour and the
narrow/wide covered-pane strip (the device is visual review's); this pass verified
only the build and the unit tests.
## Share every artifact, from the grid cells and the per-visit rows (16 Oct 2026)
Every artifact item now carries a real share action: each image cell in a gallery
grid (`ArtifactTile`) and each non-image row (`ArtifactRow`) has its own
`ArtifactShareButton`. It is a child `IconButton` — its own 48dp hit area — so a
tap on it consumes the gesture and never opens the image or the item, and its
content description is `Share <name>`.
Sharing is not a stub. The new `ui/graph/ArtifactSharing.kt` fetches the resolved
artifact through the app's existing client (`AppViewModel.fetchArtifactBytes` →
`PipelinesClient.fetchBytes`, the shared OkHttp client) into
`cacheDir/shared-artifacts/` and hands the file to the platform chooser through the
declared `androidx.core.content.FileProvider` (`${applicationId}.fileprovider`,
scoped by `res/xml/file_paths.xml` to that one cache subdirectory, not exported).
The intent is `ACTION_SEND` with `EXTRA_STREAM`, `ClipData.newUri`, MIME
`shareMimeType(contentType, fileName)` and `FLAG_GRANT_READ_URI_PERMISSION`, so the
receiving app gets the actual bytes. When the fetch fails the artifact's resolved
link is shared as `text/plain` instead (`shareDelivery`). The cache is bounded:
`pruneSharedArtifacts` drops entries older than a day and enforces a 64 MiB cap,
oldest first. No new dependency: `FileProvider` comes from the already-declared
`androidx.core.ktx` and the share glyph from the already-declared
`material-icons-extended`.
- `gradle :app:testDebugUnitTest` → **157 tests, 0 failures**; the 7 new ones are
`ArtifactSharingTest` (file/link fallback decision, artifact-to-file naming:
content-type/url extension, suffix de-duplication, path sanitisation, per-url
distinctness, and `shareMimeType`).
- `gradle :app:assembleDebug` → succeeded, `app-debug.apk` 18,283,787 bytes,
sha256 `52ad15a6…`.
- On `emulator-5554` (density 390) against the live server, run 91's summary: the
uiautomator dump shows a clickable share node of `117x117px` = **48dp** with a
`Share …` content description beside every preview; the grid and the `.mp4` row
were captured (validated by `scripts/capture_png.sh -s emulator-5554`) to
`grid_cell_share.png` and `list_row_share.png`.
- Tapping a cell's share launched the chooser with the fetched file — logcat
`ActivityTaskManager: START u0 {act=android.intent.action.SEND … clip={image/png
…}}` (image/png), and the sharesheet showed a live preview of the actual PNG
(`share_intent_image_png.png`). The `.mp4` row's share resolved to
`clip={video/mp4 …}`; the cached files are
`viewer_01_viewer_open_2f01f94a.png` and `viewer_viewer_gestures_8e1a3ba4.mp4`
under `cache/shared-artifacts/`.
- Fallback exercised live: with `adb shell cmd connectivity airplane-mode enable`
(10.0.2.2 unreachable), tapping share opened the chooser titled **Sharing link**
with the resolved `http://10.0.2.2:8080/artifacts/91/1/viewer/viewer_gestures.mp4`
as text (`share_fallback_link.png`); `adb logcat -d` held 0 `FATAL EXCEPTION`.
Airplane mode was then disabled and the app reconnected.
- Open and copy-link are unchanged and still enabled on both items.
- **APK publish.** `~/.local/share/pipelines/data/artifacts/94/1/pipelines-debug-wip-d339827.apk`
(`d339827` = `git rev-parse --short HEAD`), sha256 `52ad15a6…`; `curl -I
http://10.0.0.75:8080/artifacts/94/1/pipelines-debug-wip-d339827.apk` returned
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18283787` (18 MB, over the 8 MiB inventory cap, so direct URL
only). `10.0.0.75` is `scripts/lan-address.py`'s output; `10.0.0.249` served it
too.
Not verified in this pass: receiving the shared file inside a third-party app (the
chooser was observed, not an app's import); the 24 h / 64 MiB prune bound was not
reached on the emulator (only two small files were written).
## Multi-select artifacts: bulk copy and share (16 Oct 2026)
A long-press on any artifact in a gallery now enters artifact selection: that item
becomes selected with the app's tonal selected treatment, further taps toggle
items instead of opening them, and a contextual action bar offers **Copy links**,
**Share** and a close. It lives in both artifact surfaces — the run-summary grid
(`RunSummaryTab` → `ArtifactGallery`) and the stage pane's per-visit artifacts
list (`ArtifactsSection`) — and nowhere else (runs/pipelines lists are untouched).
- **Model.** New `ui/graph/ArtifactSelection.kt`: an immutable `ArtifactSelection`
keyed by the artifact url (`enter`, `toggle`, `selectAll`, `clear`, `contains`);
selection mode is exactly "one or more urls selected", so it can never restore
half-applied. `ArtifactSelectionSaver` (a `listSaver`) + `rememberArtifactSelection`
save/restore it across configuration and reseed per run/visit.
- **Action bar.** `ArtifactSelectionBar` is the pane's `TopAppBar` (it replaces the
normal bar while selecting): title `N selected`, a close, a copy and a share, all
Material 3 `IconButton`s (the measured 117x117 px = **48dp** targets) with accurate
descriptions ("Exit selection", "Copy selected links", "Share selected artifacts").
It applies the same `paneSafeArea()` top/horizontal insets as the bar it replaces,
so it stays inside the status bar/cutout and above — never over — the items.
- **Copy links.** `artifactSelectionLinks` resolves each selected url against the
configured server through the existing `resolvedArtifactUrl` (no hardcoded host),
joins one resolved absolute link per line, and copies it through the new one-line
`components/Clipboard.copyText` (the single copy path, now also used by the code
blocks, the pipeline source, the artifact row and the viewer). A `Snackbar`
confirms `Copied N links`. Back leaves selection mode first (a pane-scoped
`BackHandler`), only then runs the pane's own Back.
- **Bulk share.** `shareArtifacts` fetches every selected artifact through the
existing `AppViewModel.fetchArtifactBytes` and reuses the single-item
`writeSharedArtifact` (same bounded cache, same `FileProvider`, same
`pruneSharedArtifacts`) before one `Intent.ACTION_SEND_MULTIPLE` carrying every
uri. Its type is the new pure `bulkShareMimeType` (the common type, else the
wildcard) and its count is the chooser title. If **any** fetch fails the whole set
degrades in the same action to the resolved links as `text/plain`
(`shareLinks`). No parallel share path and no new dependency (icons come from the
declared `material-icons-extended`).
- **Pure helpers / tests.** `ArtifactSelectionTest` (enter, toggle, deselect-last,
select-all + clear, restored state, the one-per-line link formatting, the labels)
and two new `ArtifactSharingTest` cases (`shareTargets` resolution/drop,
`bulkShareMimeType` common-type vs wildcard).
Evidence (macOS, JDK 17 Homebrew `openjdk@17`, Gradle 8.11.1 from the wrapper
cache, `ANDROID_HOME=~/Library/Android/sdk`):
- `gradle :app:testDebugUnitTest :app:assembleDebug --console=plain` →
`BUILD SUCCESSFUL`; the result XMLs aggregate to **168 tests across 21 classes,
0 failures, 0 errors, 0 skipped** (up from 157: the new `ArtifactSelectionTest`
plus the two bulk-share cases). `app-debug.apk` is 17,913,089 bytes; the current
tree's sha256 and the APK publish are recorded in the section below.
- `gradle :app:lintDebug` → the same **2 pre-existing** `windowLightNavigationBar`
NewApi errors (`values/themes.xml`, `values-night/themes.xml`) and 39 warnings;
the only warning attributed to a touched file is the pre-existing
"Modifier parameter should be the first optional parameter" on `StageDetailPane`.
- On `emulator-5554` (never the physical Pixel, never `emulator-5556`; 2076x2152,
density 390) against the live server, run 94's summary and per-visit list were
driven. Every capture is in `captures/selection/` (git-ignored) and was validated
by `scripts/capture_png.sh -s emulator-5554`:
- `01_longpress_selection.png` — long-press on `grid_cell_share.png` entered the
mode: the action bar reads `1 selected` and the cell shows the tonal ring +
check badge (its per-item share button hidden).
- `02_several_toggled.png` — three cells then a non-image row toggled on:
`4 selected`; the row wears the `secondaryContainer`/`onSecondaryContainer`
treatment.
- `03_bulk_copy_confirmation.png` — **Copy links** showed the `Copied 4 links`
Snackbar; pasting the clipboard into the Pipelines search field
(`06_clipboard_pasted_links.png`) yielded exactly the four resolved absolute
links, one per line, against the configured server
(`http://10.0.2.2:8080/artifacts/94/1/grid_cell_share.png` … `/94/2/lint-results-debug.txt`),
in the gallery's (candidate) order.
- `04_bulk_share_intent.png` — sharing the mixed 4 selected ran the **file path**:
`ActivityTaskManager: START … action.CHOOSER … clip={*/* hasLabel(11) 4 items:
{U(content)} x4}`, chooser titled "Sharing 4 files" (mixed types → wildcard).
- `05_bulk_share_images_png.png` — the 3 image cells alone resolved to a concrete
type: `clip={image/png hasLabel(11) 3 items: …}`, chooser "Sharing 3 images".
- `08_bulk_share_fallback_links.png` — with `cmd connectivity airplane-mode
enable` (10.0.2.2 unreachable) the same Share **fell back** in one action to
`text/plain`: `action.SEND`, chooser "Sharing text" showing the three resolved
links newline-joined. Airplane mode was then disabled.
- `07_per_visit_selection.png` — the stage pane's per-visit list enters the same
mode (`3 selected`) with the action bar in the pane's safe area.
- `09_rotation_restored.png` — after `user_rotation 1` (2152x2076) the `2 selected`
selection restored fully, not half-applied.
- Back in selection mode exited the mode and left run 94 open (0 "Exit selection"
nodes afterwards, the normal app bar returned); closing the stage pane by
tapping the run peek and reopening the same visit showed no selection,
confirming the pane-close clear.
- `adb -s emulator-5554 logcat -d` held 0 `FATAL EXCEPTION` / 0 `E AndroidRuntime`.
- **APK publish.** `app-debug.apk` copied to
`~/.local/share/pipelines/data/artifacts/97/1/pipelines-debug-wip-1195535.apk`
(`1195535` = `git rev-parse --short HEAD`); `curl -I/-o` against
`http://10.0.0.249:8080/artifacts/97/1/pipelines-debug-wip-1195535.apk` (and
`10.0.0.75`) returned `HTTP 200`, `Content-Type:
application/vnd.android.package-archive`, 17,913,089 bytes.
Not verified in this pass: a narrow-window layout of the selection bar (the
emulator is the 851dp-wide inner display); receiving the bulk share in a
third-party app (the chooser was observed, not an import).
## Artifact selection: one shared host (16 Oct 2026)
The first pass left the run-summary and stage-pane selection wiring copy-pasted,
and the refactor that removed the duplication had outrun this README. The final
tree keeps one shared host: both `RunDetailScreen` (the run-summary grid) and
`StageDetailPane` (the per-visit list) call `ArtifactSelectionScaffold`, which
owns the remembered `ArtifactSelection`, the `resolvedSelection` lookup, the
single `artifactSelectionActions` copy/share implementation, the `SnackbarHostState`
and the pane-scoped `BackHandler`, and renders the contextual
`ArtifactSelectionBar` in place of the surface's own top bar while selecting.
Neither screen owns a `SnackbarHostState` or a `BackHandler` of its own.
`artifactSelectionActions` resolves every selected url through
`resolvedArtifactUrl` (never a hardcoded host), copies the resolved links one per
line through the one `ClipboardManager.copyText`, and shares every selected
artifact through the single-item `writeSharedArtifact`/`shareArtifacts` path.
`artifactSelectionLinks` resolves each selected url; `artifactSelectionActions`
confirms the number of lines it actually produced (`text.lines().size`) rather
than the raw selection size, so an absolute url plus an unresolvable relative one
under no configured server reports the true count. `writeSharedArtifact` captures a
non-null `fileBytes` from the `shareDelivery` check instead of asserting
`bytes!!`. `ArtifactSelection.selectAll` is kept: it is the task's explicit
select-all test surface even though no UI calls it.
Evidence, re-run on the same environment (`JAVA_HOME=/opt/homebrew/opt/openjdk@17`,
Gradle 8.11.1 from `~/.gradle/wrapper/dists`, `ANDROID_HOME=~/Library/Android/sdk`,
`emulator-5554` only):
- `gradle :app:testDebugUnitTest :app:assembleDebug --rerun-tasks --console=plain`
→ `BUILD SUCCESSFUL`; the result XMLs aggregate to **168 tests across 21 classes,
0 failures, 0 errors, 0 skipped** (`ArtifactSelectionTest` grew to 9 with
`resolvedSelectionKeepsOnlyTheCandidatesStillSelected`). `app-debug.apk` is
17,913,089 bytes; its current sha256 and publish are in the doc-accuracy note
below.
- Rebuilt APK reinstalled on `emulator-5554` (2076x2152, density 390); each frame
validated by `scripts/capture_png.sh -s emulator-5554` and kept in
`captures/selection-run100-final/` and
`~/.local/share/pipelines/data/artifacts/100/1/`:
- `01_longpress_selection.png` — long-press on `grid_cell_share.png` entered the
mode: bar reads `1 selected`, the cell wears the tonal ring + check, and every
per-item `Share`/`Open`/`Copy link` node is gone from the `uiautomator` dump.
- `02_several_toggled.png` — three cells then the `lint-results-debug.txt` row
toggled on → the action bar reads `4 selected`; the two action-bar
`IconButton`s measure **117x117 px = 48dp** with the descriptions
"Copy selected links" / "Share selected artifacts" ("Exit selection" for the
close).
- `03_bulk_copy_confirmation.png` — **Copy links** showed the `Copied 4 links`
Snackbar, and the system clipboard preview under the share bar showed the
resolved absolute link (`http://10.0.2.2:8080/artifacts/94/1/grid_cell_share.png…`).
- `04_bulk_share_intent.png` — **Share** of the mixed 4 ran the **file path**
(`dumpsys activity activities`: `Intent { act=android.intent.action.CHOOSER …
clip={*/* hasLabel(11) 4 items: {U(content)} x4} (has extras) }`), i.e. one
`ACTION_SEND_MULTIPLE` carrying 4 fetched files, typed by the mixed-set
wildcard. The file path ran because the configured server (`10.0.2.2:8080`)
was reachable, so every fetch returned bytes; the unchanged `shareLinks`
fallback (unit-covered by `shareDeliveryIsAFileOnlyWhenTheFetchReturnedBytes`)
is the branch a failed fetch would take in the same action.
- `05_per_visit_selection.png` — the stage pane's per-visit list enters the same
mode (`1 selected`) with the bar inside the pane safe area.
- Back exited selection mode first and left Run 94 open (0 "Exit selection" nodes
afterwards, `Run 94` still present); `adb -s emulator-5554 logcat -d` held 0
`FATAL EXCEPTION` / 0 `E AndroidRuntime`.
- **APK publish.** `app-debug.apk` copied to
`~/.local/share/pipelines/data/artifacts/100/1/pipelines-debug-wip-1195535.apk`
(`1195535` = `git rev-parse --short HEAD`); `curl` against
`http://10.0.0.249:8080/artifacts/100/1/pipelines-debug-wip-1195535.apk` (and
`10.0.0.75`) returned `HTTP 200`, `Content-Type:
application/vnd.android.package-archive`, 17,913,089 bytes.
- **Doc-accuracy pass (16 Oct 2026).** The `ArtifactSelection.kt` doc comment and
this README's "in selection order" claim said the bulk copy preserves selection
order; it actually writes one resolved link per line in gallery (candidate)
order, because `resolvedSelection` filters the surface's own candidates. Both now
state candidate order; no runtime behavior changed. Re-verified on the same
environment: `gradle :app:testDebugUnitTest :app:assembleDebug --rerun-tasks
--console=plain` → `BUILD SUCCESSFUL`, the result XMLs aggregate to **168 tests
across 21 classes, 0 failures, 0 errors, 0 skipped**; `app-debug.apk` is
17,913,089 bytes, sha256
`a6d5caeb0c1e69da879aabfcc7df2eec09e4a44c85000adba3444558a1d3d82b`. The sha is
not a stable tree fingerprint — it moves with any source edit, because the debug
APK embeds Kotlin source info (a comment-only edit to `ArtifactSelection.kt` left
only `classes6.dex` different) — so run 100's build read `763806783f…`. The APK
was published to
`~/.local/share/pipelines/data/artifacts/100/3/pipelines-debug-wip-1195535.apk`;
`curl` against
`http://10.0.0.75:8080/artifacts/100/3/pipelines-debug-wip-1195535.apk` (and
`10.0.0.249`) returned `HTTP 200`, `Content-Type:
application/vnd.android.package-archive`, 17,913,089 bytes.
Not verified in this pass: the link fallback on-device (the reachable server ran
the file path); a narrow-window layout of the selection bar; receiving the bulk
share in a third-party app (the chooser was observed, not an import).
### Named motion tokens and animated list changes (16 Oct 2026, run 104/1)
Every animation duration and easing now lives in one file, and the pipelines and
runs lists animate per item instead of cutting.
- **One motion token file.** `ui/components/Motion.kt` (beside the pane's
dimension tokens in `SlidingPaneStack.kt`) defines two named tokens, each a
duration + easing pair: `MotionQuick` (120ms) for small in-place state changes
(the section chevron, a list row appearing/leaving) and `MotionStandard`
(220ms) for content moving or swapping (a pane sliding, a section
cross-fading, an item taking a new place in a re-sorted list). Nothing exceeds
the `MAX_MOTION_MILLIS` (300ms) cap and both easings are monotonic
ease-in-out curves; `MotionStandard` is symmetric, which is what keeps a pane
close the exact reverse of its open. A call site asks a token for its concrete
spec via `spec()`; it never writes a duration. The pane slide, the section
`Crossfade` and the chevron now use the tokens (`PANE_SLIDE_*` /
`SECTION_SWAP_MILLIS` are gone), and the pane pop stagger moved in as
`MOTION_STAGGER_MILLIS`.
- **Per-item list animation.** A single shared `LazyItemScope.animateListItem()`
(`ListRow.kt`) wraps Compose's supported `Modifier.animateItem(fadeInSpec,
placementSpec, fadeOutSpec)` with the tokens: an item fades in as it appears
and out as it leaves (`MotionQuick`), and the items still on screen slide to
their new positions when the list is refreshed, filtered or re-sorted
(`MotionStandard`) rather than jumping. Pipelines rows, run rows, pipeline
version rows and run evidence rows all use it. Because it is the supported
lazy-list item animation the list keeps its own scroll/measure state; the
modifier only drives the transition, so a resting list is unchanged.
- **System animation setting.** The tokens map onto Compose's standard
animations, so the platform animator duration scale applies unchanged: with
animations disabled each spec runs for zero time and an item is at its final
state at once, no special case.
- **No per-frame allocation.** Specs are built at composition time, not per
frame, and the chevron reads its animating angle inside the layer
(`graphicsLayer { rotationZ = … }`) so it turns without recomposing the header
each frame.
Verified on `emulator-5554` only (fold layout, 2076x2152 / 390dpi ≈ 852dp,
against the live server; never the attached Pixel):
- `gradle :app:assembleDebug :app:testDebugUnitTest --offline --console=plain`
(Gradle 9.7.1, JDK 17, `ANDROID_HOME` set) → `BUILD SUCCESSFUL`.
`gradle :app:testDebugUnitTest --rerun-tasks --offline` re-ran every result XML
to **174 tests across 22 classes, 0 failures, 0 errors, 0 skipped**; the new
`MotionTest` (6 cases) checks the token ordering (quick shorter than standard),
the per-token bands (quick 100-150ms, standard 200-250ms), the ≤300ms cap, that
every easing is monotonic `0→1`, that `MotionStandard` reverses itself, and
that a spec carries its token's timing. `SlidingPaneStackTest` now reads the
pane's timing from the token.
- **Filter change** (`filter.mp4`, frames `sheet1.png`/`sheet2.png`): at
`animator_duration_scale 5`, typing `docker` into the pipelines search fades
the non-matching rows out and moves the survivors up; deleting it brings the
rows back in.
- **A new run arriving** (`newrun.mp4`, frames `newrun_arrival.png` /
`newrun_sheet1.png`): run 105 was admitted out-of-band with
`pipelines run --json --pipeline 8 … --yes` (**not** from the app); tapping
Refresh in the Runs list shows run 105 fade in at the top while every existing
row slides down to make room. Run 105 then failed (its stage returned
`blocked`), so nothing had to be reclaimed.
- **Reduced motion** (`red_sheet.png`): at `animator_duration_scale 0`, typing
`d`/`do`/`doc`/`dock` leaves each captured frame fully settled — no ghosted or
half-placed rows — i.e. the change is instant with no partial state.
- `adb -s emulator-5554 logcat -d` held 0 `FATAL EXCEPTION` / 0
`E AndroidRuntime` lines; `animator_duration_scale` was left at 1.
- **APK publish.** `app-debug.apk` (17,913,089 bytes, sha256 `4bc1b781…`) copied
to `~/.local/share/pipelines/data/artifacts/104/1/pipelines-debug-wip-0b74903.apk`
(`0b74903` = `git rev-parse --short HEAD`); `curl -I
http://10.0.0.249:8080/artifacts/104/1/pipelines-debug-wip-0b74903.apk` returned
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 17913089`, and a streamed `curl | shasum -a 256` returned the
same `4bc1b781…`.
Not verified in this pass: a narrow-window frame of the item animation; an item
leaving a list (a run being deleted is not a client action), only the
appear/move halves driven above.
## Loading, empty and error states cross-fade (16 Oct 2026)
A data-backed pane used to swap its loading spinner, empty message, error message
and content with a plain `when`, so content flashed from empty to full and an
empty or error state popped. Every pane now swaps through one shared
`StateCrossfade` (`ui/components/States.kt`) — a `Crossfade` on the pane's
classified state using the already-named `MotionStandard` token. No dependency,
geometry token or literal was added.
- **`LoadPhase`** is the mutually exclusive presentation state: `Loading`,
`Error(message)`, `Empty(message)`, `Content`. The message-carrying phases keep
the text they were classified with, so the branch that is fading out is never
recomposed against a since-cleared error or a since-changed filter.
- **`listLoadPhase(loading, error, hasData, emptyMessage)`** and
**`detailLoadPhase(error, hasData)`** are the pure classifiers. A list pane
reports a failed load with no data, then a load with no data, then empty, else
content; a detail pane has no empty state, so data present is content, then a
reported error, then loading. Stale data keeps a pane on `Content` (the screen
shows the error inline), exactly as before — only the presentation changed.
- **`StateCrossfade(phase)`** wraps the branch in a `Crossfade` with
`MotionStandard.spec()`; both branches are laid out in one box, so the resting
layout is exactly the branch's own layout and the outgoing phase fades under
the incoming one. Applied to `PipelineListScreen`, `RunHistoryScreen`,
`PipelineDetailScreen` and `RunDetailScreen`. `LoadingState`, `ErrorState` and
`EmptyState` themselves are unchanged.
- The detail panes render the fading-out branch from the last non-null item
(`rememberPaneContent`, the same helper the closing pane uses), so selecting
another pipeline/run fades the old content out instead of blanking it.
- The Runs pane has no pane-level empty state — an empty list keeps its usage
block and sticky headers and shows its `No runs have been recorded yet.` line
inside the list, where it now fades in/out through the existing
`animateListItem()`, as does its inline error line.
Evidence (macOS, JDK 17 from Homebrew `openjdk@17`, Gradle 9.7.1,
`ANDROID_HOME=~/Library/Android/sdk`, `--offline`):
- `gradle :app:assembleDebug :app:testDebugUnitTest --console=plain` →
`BUILD SUCCESSFUL`; `--rerun-tasks` re-ran all 23 result XMLs to **184 tests, 0
failures, 0 errors, 0 skipped** (up from 174; the new `LoadPhaseTest` adds 10
pure cases for the classifiers and the message-carrying phases).
`app/build/outputs/apk/debug/app-debug.apk` is 17,913,089 bytes, sha256
`e99bb970…`.
- On `emulator-5554` only (fold AVD, 2076x2152 / 390dpi; **never** the attached
Pixel, never `emulator-5556`), against the live server, each frame captured and
validated with `scripts/capture_png.sh -s emulator-5554`, `animator_duration_scale`
used only to slow the capture:
- **Loading → content** at `animator_duration_scale 10`
(`load-to-content-10x.mp4`, `load-to-content-10x-sheet.png`): selecting a
pipeline shows `Loading pipeline…` and the summary then fades in;
`load-to-content-10x-overlap.png` freezes the cross-fade with the loading text
(`…ding pip…`) and the dimmed summary visible together, instead of a flash.
- **Empty appearing and going away** at scale 10
(`empty-appear-disappear-10x-sheet.png`): typing `zzz` into the pipelines
search makes `No pipelines match "zzz".` fade in, and clearing it fades the
list back.
- **Error → content** at scale 10 (`error-to-content-recovery-10x-sheet.png`):
with the connection down the Runs pane showed the error state; after the
connection returned, pressing Retry fades the error out and the loaded runs
(usage block, day groups) in.
- **Animations disabled** (`animator_duration_scale 0`): `disabled-empty-sheet.png`
(same type/clear) and `disabled-content-sheet.png` (open a pipeline) are each
fully settled on every frame — no ghosted or half-placed state, i.e. the swap
is instant with no special case.
- **Resting layout**: a settled Pipelines list captured at scale 1 and at scale
0 is pixel-identical (`captures/imgdiff.py` → `([0.0, 0.0, 0.0], 0.0)`), so the
cross-fade never alters the settled layout.
- `adb -s emulator-5554 logcat -d` held 0 `FATAL EXCEPTION` / 0
`E AndroidRuntime` lines; `animator_duration_scale` was left at 1; no run was
started from the app.
- **APK publish.** `app-debug.apk` copied to
`~/.local/share/pipelines/data/artifacts/106/1/pipelines-debug-wip-934994d.apk`
(`934994d` = `git rev-parse --short HEAD`; the working tree is uncommitted WIP on
top of it), sha256 `e99bb970…`. `curl
http://10.0.0.75:8080/artifacts/106/1/pipelines-debug-wip-934994d.apk` returned
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 17913089`, and a streamed `GET | shasum -a 256` returned the
same `e99bb970…` (`10.0.0.249` served it too; at 17.1 MiB it exceeds the 8 MiB
per-file inventory cap, so it is served by direct URL only).
Not verified in this pass: a narrow-window frame (the fold inner display is
851dp wide); the error state's fade-in from loading (the disconnected load failed
before a loading frame could be drawn, only its fade-out was captured).
### Animated selection and state changes (16 Oct 2026, run 109/1)
Selection and live state changes animate instead of cutting, and every resting
state is unchanged. All of it reuses the one `Motion.kt` token file; no new
dependency, geometry or literal.
- **The destination pill's indicator travels.** `DestinationPill`
(`PipelinesApp.kt`) now draws one selection indicator behind the three icons
and animates its offset between them (`animateDpAsState`, `MotionStandard`), so
picking another destination slides the highlight across rather than each icon
swapping its own background; the glyph tint cross-fades in step
(`animateColorAsState`). The geometry comes from two named tokens,
`DESTINATION_ITEM_SIZE`/`DESTINATION_ITEM_GAP` (the existing 48dp target and
4dp gap, named once), through the pure `destinationIndicatorOffsetDp`, which is
unit-tested. The icons own the taps, so a tap registers while the indicator is
still travelling, and a rapid run of taps only retargets the one animator.
- **A selected row's highlight fades in.** The shared `ListRow` animates its
tonal container and content colour under `MotionQuick` instead of switching, so
selecting a pipeline/run row fades the `secondaryContainer` highlight in and
out; the settled row is exactly the old one.
- **Section bodies animate with their chevron.** A new shared
`CollapsibleSectionBody` (`Sections.kt`) wraps a section's body in
`AnimatedVisibility` with `expandVertically`/`shrinkVertically` + fade under
`MotionQuick` — the same token the `SectionHeader` chevron turns with — so the
content and the chevron move together. Both `collapsibleSection` (the lazy
variant) and the stage pane's `StageSection` use it; collapsed, the body is not
composed, so a resting section is unchanged. (The section *switch* was already
an in-place `Crossfade` with no lateral motion and is unchanged.)
- **A live run's status change animates.** `StatusChip` eases its container and
label colour under `MotionQuick` and `RunStatusIcon` eases its glyph tint, so a
run whose status changes while the 1s poll is running visibly transitions the
chip and the row's leading accent instead of silently swapping a colour.
- **Taps, pause and the animator scale.** These are ordinary Compose animators,
so the platform animator duration scale applies unchanged (disabled = instant),
the recomposer pauses them while the screen is not resumed, and the
selectable/clickable nodes are independent of the animators, so taps register
mid-animation.
Verified on `emulator-5554` only (fold layout, 2076x2152 / 390dpi; never the
attached Pixel, never `emulator-5556`), against the live server; each frame
captured and validated with `scripts/capture_png.sh -s emulator-5554`:
- `gradle :app:assembleDebug :app:testDebugUnitTest --offline --console=plain` →
`BUILD SUCCESSFUL`; `gradle :app:testDebugUnitTest --rerun-tasks --offline`
re-ran every result XML to **186 tests across 23 classes, 0 failures, 0 errors,
0 skipped**. The new `PipelinesNavTest` cases check the indicator offset lines
up with each slot and pins to slot 0 when nothing is selected.
- **Pill selection moving** at `animator_duration_scale 6`
(`pill_0/1/5.png`): with Pipelines selected, tapping Runs leaves `pill_0` on
Pipelines, `pill_1` freezes the highlight between the two icons, and `pill_5`
settles under Runs.
- **Section collapsing** at `animator_duration_scale 15`
(`sec2_expand_3.png`, `sec2_collapse_2.png`): the Input tab's `prompt` section
expands with the code block revealing under a down chevron, and collapses with
the block clipped and the following `pwd` header rising as the chevron returns.
- **Live status change** (`status3_post_01/02/03.png`): run 112 was started
out-of-band with `pipelines run … --pipeline 1 --prompt "… sleep 45 …"` (**not**
from the app) and watched in its open detail; its summary chip goes from
`running` (`status3_post_01`) through the mid-transition tint
(`status3_post_02`) to `succeeded` (`status3_post_03`).
- **Taps mid-animation**: at scale 15, tapping Runs and then Settings 0.2s later
(while the indicator was still travelling) landed on the Settings screen, so
the second tap registered.
- `adb -s emulator-5554 logcat -d` held 0 `FATAL EXCEPTION` / 0
`E AndroidRuntime` lines; `animator_duration_scale` was left at 1.
- **APK publish.** `app-debug.apk` (18,133,184 bytes, sha256 `567c437d…`) copied
to `~/.local/share/pipelines/data/artifacts/109/1/pipelines-debug-wip-b89ad29.apk`
(`b89ad29` = `git rev-parse --short HEAD`); `curl -I
http://10.0.0.249:8080/artifacts/109/1/pipelines-debug-wip-b89ad29.apk` returned
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18133184`, and a streamed `curl | shasum -a 256` returned the
same `567c437d…`.
Not verified in this pass: a clean *settled* frame of the selected-row highlight
(it fades in while the wide layout then covers the list with the opened pane, so
only a transient mid-fade frame was captured); resume-after-pause of an
in-flight animation on device (the pause is Compose's own recomposer behaviour,
not code here).
## One source of truth for app geometry, with an enforcement test (16 Oct 2026)
`android/` only. No layout changed: every moved value is identical, so the app
renders exactly as before. No new dependency, no server/Go/installer/Docker file
touched, no run started from the app.
- **`ui/theme/Dimens.kt`** is the single source of truth for app geometry,
alongside `Typography.kt` for type. It defines the 4dp **spacing scale**
(`SPACING_XXS`/`XS`/`S`/`M`/`L`/`XL`/`XXL`, each comment tied to that base
step) and moves the geometry constants that already existed:
`PEEK_WIDTH_DP` (the collapsed/peek strip), `PEEK_BUDGET_DP`,
`MIN_ACTIVE_PANE_WIDTH_DP`, `MIN_COVERED_PANE_WIDTH_DP` (from
`SlidingPaneStack.kt`), `DESTINATION_PILL_RESERVE` (from `PipelinesApp.kt`),
`WIDE_RAIL_WIDTH_DP` and `DETAIL_MAX_WIDTH_DP` (from `DetailTabs.kt`). The
removed `LIST_PANE_WIDTH`, `COLLAPSED_LIST_PANE_WIDTH` and
`COLLAPSED_RAIL_WIDTH_DP` no longer exist, so there was nothing to move for
the "list pane width" or the rail's collapsed width; the collapsed *strip*
that survives is `PEEK_WIDTH_DP`. Call sites import the tokens; their values
(`56/224/320/112/88/200/840`) are unchanged.
- **`ui/theme/DimensTest.kt`** scans the app's Kotlin sources
(`src/main/java`, excluding `Dimens.kt`) for raw `dp`/`sp` literals, masking
comment and string contents first so prose and URLs are not hits. It
allow-lists the 34 literals that predate the file, each with a written reason
(structural zeros/hairlines, the 4dp-scale members that are not yet migrated,
component glyph sizes, the workflow-graph's own pixel geometry, container
sizes and the `sp` typography values owned by `Typography.kt`). A literal that
is neither a token nor allow-listed fails with `file:line: literal`. The list
is expected to shrink as call sites move onto the tokens.
Evidence (macOS, JDK 17 from Homebrew `openjdk@17`,
`ANDROID_HOME=~/Library/Android/sdk`, Gradle 9.7.1, `--offline`):
- `gradle :app:assembleDebug :app:testDebugUnitTest --rerun-tasks --console=plain`
→ `BUILD SUCCESSFUL`; `--rerun-tasks` re-ran all 24 result XMLs to **188 tests,
0 failures, 0 errors, 0 skipped** (up from 186/23; the new `DimensTest` adds
`rawDimensionLiteralsAreTokensOrReasonedAllowListEntries` and
`everyAllowListEntryHasAWrittenReason`).
`app/build/outputs/apk/debug/app-debug.apk` is 17,929,473 bytes, sha256
`e52ceb25…`.
- **Enforcement proof.** Adding `private val PROBE_RAW_LITERAL = 123.dp` to
`ui/PipelinesApp.kt` made
`gradle :app:testDebugUnitTest --tests net.awan.pipelines.ui.theme.DimensTest`
`FAILED` with
`raw dimension literals outside net/awan/pipelines/ui/theme/Dimens.kt: [net/awan/pipelines/ui/PipelinesApp.kt:455: 123.dp]`
(file, line and literal); removing the line made the same task
`BUILD SUCCESSFUL`. The probe was reverted.
- **Before/after screenshots on `emulator-5554` only** (fold AVD, 2076x2152 /
390dpi; never the attached Pixel, never `emulator-5556`), against the live
server, each frame captured and validated with
`scripts/capture_png.sh -s emulator-5554`: the **before** APK was built from
HEAD `d019213` (android changes stashed, built, then restored) and the
**after** APK from the working tree, each installed with
`adb -s emulator-5554 install -r`, force-stopped and relaunched. Screen A is
the Pipelines list; screen B is the "Complete a Task" pipeline detail (the
wide rail plus the covered list peek, i.e. the moved rail/detail/pane
tokens). `captures/imgdiff.py` reports `([0.0, 0.0, 0.0], 0.0)` for both the
A and B pairs — pixel-identical before and after.
- `adb -s emulator-5554 logcat -d` held 0 `FATAL EXCEPTION` / 0
`E AndroidRuntime` lines; `animator_duration_scale` was left at 1; no run was
started from the app.
- **APK publish.** `app-debug.apk` copied to
`~/.local/share/pipelines/data/artifacts/116/1/pipelines-debug-wip-d019213.apk`
(`d019213` = `git rev-parse --short HEAD`; the working tree is uncommitted WIP
on top of it), sha256 `e52ceb25…`. `curl -I
http://10.0.0.249:8080/artifacts/116/1/pipelines-debug-wip-d019213.apk`
returned `HTTP/1.1 200 OK`, `Content-Type:
application/vnd.android.package-archive`, `Content-Length: 17929473`, and a
streamed `GET | shasum -a 256` returned the same `e52ceb25…`.
Not verified in this pass: whether `:app:lintDebug` stays at its two
pre-existing `NewApi` errors (it was not run).
## The list and detail screens on the geometry tokens (16 Oct 2026)
`android/` only. Every replacement is value-equal, so the screens render exactly
as before. No new dependency, no server/Go/installer/Docker file touched, no run
started from the app, and every `adb`/emulator command targeted `emulator-5554`
only (never `emulator-5556` or the attached Pixel).
- **Scope.** The four list/detail screens
(`ui/screens/PipelineListScreen.kt`, `RunHistoryScreen.kt`,
`PipelineDetailScreen.kt`, `RunDetailScreen.kt`) and the shared components
they are built from (`ListRow`, `States`, `Sections`, `PaneIdentity`,
`ConnectionBanner`, `FilterMenu`, `CodeBlock`, `RunStatus`, `DetailTabs`). The
navigation chrome (`SlidingPaneStack`, `PipelinesApp`) and the workflow-graph
package keep their literals.
- **Spacing.** Every 4/8/12/16/24dp padding, gap and arrangement on those files
now references the previous item's `SPACING_XS/S/M/L/XL` tokens (and
`SPACING_XXS` for the 2dp chip gaps); no value changed. The 10dp dense row
padding, the 2dp progress hairline and the `0.dp` elevations stay as reasoned
allow-list entries because they are not on the spacing scale.
- **Glyph sizes.** Four new tokens in `ui/theme/Dimens.kt` name the icon sizes
that cannot derive from layout: `ICON_STATUS_DP` (14dp), `ICON_INLINE_DP`
(18dp), `ICON_LIST_DP` (20dp) and `ICON_RAIL_DP` (24dp), used by `RunStatus`,
`CodeBlock`, `RunHistoryScreen`, `RunDetailScreen`, `PipelineDetailScreen` and
`DetailTabs`.
- **The allow-list shrinks.** `ui/theme/DimensTest.kt`'s allow-list drops from
**30 to 24 entries**: `14.dp`, `18.dp` and `20.dp` are gone because their last
call site migrated, and the already-unused `32.dp`, `11.sp` and `13.sp` entries
were removed. The remaining entries are the structural hairlines/zeros
(0/2/3/6dp), the not-yet-migrated graph/app-shell values, the container sizes
and the `sp` type values owned by `Typography.kt`.
Evidence (macOS, JDK 17 from Homebrew `openjdk@17`,
`ANDROID_HOME=~/Library/Android/sdk`, Gradle 9.7.1, `--offline`):
- `gradle :app:assembleDebug :app:testDebugUnitTest --rerun-tasks --console=plain`
→ `BUILD SUCCESSFUL`; `--rerun-tasks` re-ran all 30 result XMLs to **259 tests,
0 failures, 0 errors, 0 skipped**. `app/build/outputs/apk/debug/app-debug.apk`
is 17,995,009 bytes, sha256 `d40d7b78…`.
- **Allow-list shrinks.** `git show HEAD:…DimensTest.kt` counts 30 entries; the
working tree counts 24 (`14.dp`, `18.dp`, `20.dp`, `32.dp`, `11.sp`, `13.sp`
gone, the rest re-reasoned).
- **Enforcement proof.** Appending `private val PROBE_RAW_LITERAL = 123.dp` to
`ui/components/ListRow.kt` made
`gradle :app:testDebugUnitTest --tests net.awan.pipelines.ui.theme.DimensTest`
`FAILED` with `raw dimension literals outside
net/awan/pipelines/ui/theme/Dimens.kt:
[net/awan/pipelines/ui/components/ListRow.kt:113: 123.dp]`; removing the line
made the same task pass. The probe was reverted.
- **Before/after screenshots on `emulator-5554` only** (fold AVD, 2076x2152 /
390dpi, dark mode; narrow 1080x2340 and wide 2000x3400 via `wm size`; never
`emulator-5556` or the attached Pixel), against the live server at
`ws://10.0.2.2:8080/connect`, each frame captured and validated with
`scripts/capture_png.sh -s emulator-5554`. The **before** APK was built from
HEAD `8e49a0c` (sha256 `e50bb381…`) with the working changes stashed; the
**after** APK from the working tree (sha256 `d40d7b78…`). Every converted
screen was captured at both widths (Pipelines list, Runs list, pipeline
detail, run detail): `geom-<screen>-<width>-before.png` / `-after.png` in
`~/.local/share/pipelines/data/artifacts/122/1/`. `captures/imgdiff.py`
reports a mean channel difference of 0.01–0.04 for both detail screens,
0.02–0.04 for the Pipelines list and 0.04–0.12 for the Runs list, all
confined to the status-bar clock, the live relative-time/badge text and
thumbnails that load asynchronously; the layout itself is unchanged.
- `adb -s emulator-5554 logcat -d` held 0 `FATAL EXCEPTION` / 0
`E AndroidRuntime` lines; `animator_duration_scale` was left at 1; no run was
started from the app.
- **APK publish.** `app-debug.apk` copied to
`~/.local/share/pipelines/data/artifacts/122/1/pipelines-debug-wip-8e49a0c.apk`
(`8e49a0c` = `git rev-parse --short HEAD`; the working tree is uncommitted WIP
on top of it), sha256 `d40d7b78…`. `curl -I
http://10.0.0.249:8080/artifacts/122/1/pipelines-debug-wip-8e49a0c.apk`
returned `HTTP/1.1 200 OK`, `Content-Type:
application/vnd.android.package-archive`, `Content-Length: 17995009`, and a
streamed `GET | shasum -a 256` returned the same `d40d7b78…`.
Not verified in this pass: `:app:lintDebug` (not run); the Runs-list and
run-detail before/after pairs are not byte-identical because their live
relative-time text and artifact thumbnails load asynchronously.
## The graph, panes, rail and sheet on the geometry tokens (16 Oct 2026)
`android/` only. Every replacement is value-equal, so the workflow graph, the
artifact gallery/viewer and the pane surfaces render exactly as before. No new
dependency, no server/Go/installer/Docker file touched, no run started from the
app, and every `adb`/emulator command targeted `emulator-5554` only (never
`emulator-5556` or the attached Pixel).
- **Scope.** The workflow-graph package (`ui/graph/WorkflowGraph.kt`,
`StageDetailPane.kt` — the stage detail *sheet* — `Artifacts.kt`,
`ArtifactViewer.kt`, `ArtifactImage.kt`) plus the two navigation components the
previous item left with their literals: the sliding *pane*
(`ui/components/SlidingPaneStack.kt`) and the detail *rail*
(`ui/components/DetailTabs.kt`). The pane and the rail already derive every
width and offset from tokens, so their only remaining literal is the structural
`0.dp` recorded in the allow-list; the graph/sheet/gallery files carried the
rest.
- **Spacing.** Every 2/4/8/12/16/24dp padding, gap, arrangement and offset on
those files now references `SPACING_XXS/XS/S/M/L/XL`; no value changed.
- **New tokens.** The off-scale component and graph-chrome sizes move into
`ui/theme/Dimens.kt`: the run legend's `GRAPH_LEGEND_PAD_X` (6dp),
`GRAPH_LEGEND_PAD_Y` (3dp) and `GRAPH_LEGEND_GAP` (10dp); the collapsed
`GRAPH_PANEL_MIN_HEIGHT` (320dp, moved off `WorkflowGraph.kt` and now imported
by its test); the gallery's `ARTIFACT_TILE_DP` (96dp), `ARTIFACT_THUMB_DP`
(56dp), `ARTIFACT_BADGE_DP` (16dp), `ARTIFACT_PROGRESS_DP` (24dp) and
`ARTIFACT_PROGRESS_STROKE_DP` (2dp); and the stage-type chip's
`STAGE_CHIP_PAD_H` (10dp). The artifact tile/row and thumbnail corner radii
derive from the Material shape scale (`MaterialTheme.shapes.medium`/`.small`),
exactly as the graph's own node corners already do, so no radius literal
remains.
- **The allow-list shrinks.** `ui/theme/DimensTest.kt`'s allow-list drops from
**24 to 21 entries**: `24.dp`, `56.dp` and `96.dp` are gone because their last
call site migrated onto a token. The remaining entries are the structural
hairlines/zeros (0/2/3/6dp), the spacing values still used by the not-yet-
migrated app shell and Settings screen, and the `sp` type values owned by
`Typography.kt`.
Evidence (macOS, JDK 17 from Homebrew `openjdk@17`,
`ANDROID_HOME=~/Library/Android/sdk`, Gradle 9.7.1, `--offline`):
- `gradle :app:assembleDebug :app:testDebugUnitTest --rerun-tasks --console=plain`
→ `BUILD SUCCESSFUL`; `--rerun-tasks` re-ran all 30 result XMLs to **259 tests,
0 failures, 0 errors, 0 skipped**. `app/build/outputs/apk/debug/app-debug.apk`
is 17,995,009 bytes, sha256
`c5da095aec8a01120d4d847da69f71fa2fe0f937290f3c9a5190a9de8b813b0f`.
- **Allow-list shrinks.** `git show HEAD:…DimensTest.kt` counts 24 entries; the
working tree counts 21.
- **Enforcement proof.** Appending `private val PROBE_RAW_LITERAL = 123.dp` to
`ui/graph/Artifacts.kt` made
`gradle :app:testDebugUnitTest --tests net.awan.pipelines.ui.theme.DimensTest`
`FAILED` with `raw dimension literals outside
net/awan/pipelines/ui/theme/Dimens.kt:
[net/awan/pipelines/ui/graph/Artifacts.kt:497: 123.dp]`; removing the line made
the same task `BUILD SUCCESSFUL`. The probe was reverted.
- **Before/after screenshots on `emulator-5554` only** (fold AVD, 2076x2152 /
390dpi; narrow 1080x2340 and wide 2000x3400 via `wm size`; never
`emulator-5556` or the attached Pixel), against the live server at
`ws://10.0.2.2:8080/connect`, each frame captured and validated with
`scripts/capture_png.sh -s emulator-5554`. The **before** APK was built from a
`git archive HEAD` tree (`3765fdf`, sha256 `d40d7b78…`, byte-identical to the
previous item's published APK); the **after** APK from the working tree (sha256
`c5da095a…`). Three surfaces were captured at both widths — the Pipelines list
(the *panes*), the "Friend demo" pipeline **Graph** tab, and the opened stage
detail **sheet** — as `graph-*`, `sheet-*` and `list-{narrow,wide}-{before,after}.png`
in `~/.local/share/pipelines/data/artifacts/125/1/`. `captures/imgdiff.py`
reports a mean channel difference of `0.0` for the wide sheet, `0.01` for the
wide/narrow graph and the wide list, and `0.03` for the narrow sheet — the only
differing pixels are the status-bar clock; the list pairs also differ on their
live relative-time text. The layout itself is unchanged.
- `adb -s emulator-5554 logcat -d` held 0 `FATAL EXCEPTION` / 0
`E AndroidRuntime` lines; `animator_duration_scale` was left at 1; no run was
started from the app.
- **APK publish.** `app-debug.apk` copied to
`~/.local/share/pipelines/data/artifacts/125/1/pipelines-debug-wip-3765fdf.apk`
(`3765fdf` = `git rev-parse --short HEAD`; the working tree is uncommitted WIP
on top of it), sha256 `c5da095a…`. `curl -I
http://10.0.0.249:8080/artifacts/125/1/pipelines-debug-wip-3765fdf.apk`
returned `HTTP/1.1 200 OK`, `Content-Type:
application/vnd.android.package-archive`, `Content-Length: 17995009`, and a
streamed `GET | shasum -a 256` returned the same `c5da095a…`.
Not verified in this pass: `:app:lintDebug` (not run); the app shell
(`PipelinesApp.kt`) and the Settings screen still keep their literals, so those
allow-list entries remain.
## An app-owned run-status palette (16 Oct 2026)
Run status had the wrong hue for its two most important states because it was
mapped onto Material roles: `primary` (mint) made a **running** run read green and
`tertiary` (amber) made a **succeeded** run read yellow. `android/` only; nothing
in the Pipelines server, its Go source, the Docker/compose files or the installer
was touched, no dependency was added, no run was started from the app, and the
attached Pixel 10 Pro Fold was never installed on or driven (every `adb`/emulator
command targeted `emulator-5556`; lane A's `emulator-5554` was not used).
- **A new app-owned palette.** `ui/components/RunStatusPalette.kt` defines one
`Entry(colour, rationale)` per status, fixed (not scheme-derived) so a status
reads the same on every device, with a one-line reason each: Running/Active
blue, Succeeded green, Failed the app error red, Interrupted amber, Canceled
muted grey, Queued neutral grey, Unknown the low-key surface grey.
`runStateColor` is now a pure function over this palette (no `MaterialTheme`), so
it is asserted in a plain JVM test. Each state keeps its distinct material glyph
and text label, so status is never colour alone.
- **The graph outcome palette is unchanged.** `GraphPalette` and the terminal
`success`/`error` roles are untouched; run status and stage outcome stay
different vocabularies. The runs-list **Timeline** step chips (and their leading
glyphs) previously rendered through `runStateOf`/`StatusChip`, i.e. the run-status
mapping, so they were pointed at the graph's outcome palette instead: they now
call the shared `graphColors(scheme)` factory (extracted from `WorkflowGraph`,
which uses it too) and `outcomeColor`, so a step chip agrees with the graph.
The run header and runs-list cards keep the run-status palette.
- **Shared helper.** `ui/components/RunStatus.kt` gained `ColoredChip(label,
colour, icon, …)` — the single pill layout now used by both `StatusChip` (run
status) and the Timeline's outcome chip, instead of a second copy.
Evidence (macOS, JDK 17 from Homebrew `openjdk@17`, Gradle 8.11.1,
`ANDROID_HOME=/Users/alan/Library/Android/sdk`, `ANDROID_SDK_ROOT` set,
`--offline`):
- `gradle :app:testDebugUnitTest` reported **143 tests, 0 failures, 0 errors**
(new `RunStatusPaletteTest`: WCAG-AA contrast ≥ 4.5:1 for every status colour
against `DarkSurface 0xFF0E1513`, Succeeded green and ≠ `DarkTertiary`, Running/
Active blue and ≠ `DarkPrimary`, Failed = `DarkError`, Interrupted amber and ≠
Failed, Queued near-grey and ≠ Running, and a non-blank rationale per status).
`gradle :app:assembleDebug` succeeded (18,009,527-byte debug APK, sha256
`17f52f23e40f4ba0c524ac2929adfd6a8f39353e68ccdeedb2e029019225e350`).
- On `emulator-5556` (`FoldB_API_36`, 2208x1840, density 420) in dark mode
(`adb shell cmd uimode night yes`) against the live server
`ws://10.0.2.2:8080/connect`, driven with `adb shell input` and `uiautomator
dump`. Every capture below was written with `android/scripts/capture_png.sh -s
emulator-5556` (which names the SurfaceFlinger display id and validates the PNG
magic bytes), and a validated screenshot was pixel-sampled to read the rendered
colour back:
- **Before** (pre-change tree, `git stash` build): runs-list usage values were
Succeeded `#F2C879` (amber), Running card `#6FD3B8` (mint); a run header read
`#F2C879` (succeeded) and `#6FD3B8` (running) — the reported bug, `captures` in
`runs_list_before.png`, `run_header_before.png`, `run_header_running_before.png`.
- **After**: runs-list usage values were Succeeded `#7FE0A8` (green), Failed
`#FFB4AB` (error red), Canceled `#889391` (muted), Interrupted `#E8C06A`
(amber), Active `#7FB2F0` (blue); the running card was `#7FB2F0` and the
succeeded card `#7FE0A8` (`runs_list_after.png`). A run header read `#7FE0A8`
(succeeded) and `#7FB2F0` (running) (`run_header_after.png`,
`run_header_running_after.png`).
- **Timeline agrees with the graph**: before, a graph-only outcome still went
through the run-status mapping — an `approved` step chip sampled `#BEC9C5`
(the run-status `Unknown` grey). After, the `success` step chip sampled
`#F2C879` (the graph's tertiary terminal role) and the `approved` chip
`#C0A3F5` (`GraphPalette` index 5), both equal to the graph's `outcomeColor`
(`run_timeline_before.png`, `run_timeline_after.png`).
- `adb -s emulator-5556 logcat -d` contained 0 `FATAL EXCEPTION` / `E
AndroidRuntime` lines (the only app-matched lines were expected
`InputDispatcher … Consumer closed input channel` warnings from the
force-stop/reinstall).
- **APK publish.** `app/build/outputs/apk/debug/app-debug.apk` was copied to
`…/artifacts/69/1/pipelines-debug-wip-cd85f69.apk` (`cd85f69` = `git rev-parse
--short HEAD`); `shasum -a 256` matched. `curl -I
http://10.0.0.249:8080/artifacts/69/1/pipelines-debug-wip-cd85f69.apk` (LAN
address from `ipconfig getifaddr en0`) returned `HTTP/1.1 200 OK`,
`Content-Type: application/vnd.android.package-archive`, `Content-Length:
18009527`; a streamed `GET | shasum -a 256` equalled the local file. At 17.2 MiB
it exceeds the server's 8 MiB per-file inventory cap, so it is served by direct
URL only.
### Re-verified against the committed tree (run 72, 16 Oct 2026)
The change above is committed at `24584d8`; re-checked independently on that exact
tree (JDK 17 from Homebrew `openjdk@17`, Gradle 8.11.1, `--offline`):
- `gradle --offline :app:testDebugUnitTest --rerun` → **143 tests, 0 failures, 0
errors** (`RunStatusPaletteTest` 7/7, including the per-status WCAG-AA contrast
check). `gradle --offline :app:assembleDebug` succeeded; the APK is 18,009,527
bytes, sha256 `17f52f23e40f4ba0c524ac2929adfd6a8f39353e68ccdeedb2e029019225e350`.
- Before/after captured on `emulator-5556` (`sdk_gphone16k_arm64`, 2208x1840,
density 420, dark mode) with `android/scripts/capture_png.sh -s emulator-5556`.
The pre-change build was produced from a clean `git archive cd85f69` tree (never
a working-tree stash), and each capture was pixel-sampled to read the rendered
colour back:
- **Before**: runs-list usage Succeeded `#F2C879` (amber) and Active `#6FD3B8`
(mint); run 69 header `#F2C879`, run 72 header `#6FD3B8`; the `approved`
Timeline chip `#BEC9C5` (run-status `Unknown` grey).
- **After**: Succeeded `#7FE0A8` (green), Failed `#FFB4AB`, Canceled `#889391`,
Interrupted `#E8C06A`, Active `#7FB2F0`; run 69 header `#7FE0A8`, run 72 header
`#7FB2F0`; the `approved` Timeline chip `#C0A3F5` (graph palette index 5) while
the `success` chip stays `#F2C879` (the graph's tertiary role), so a step chip
agrees with the graph. `logcat` after a fresh launch had 0 `FATAL EXCEPTION` /
`E AndroidRuntime` lines.
- **APK publish.** `app/build/outputs/apk/debug/app-debug.apk` copied to
`…/artifacts/72/1/pipelines-debug-wip-24584d8.apk` (`24584d8` = `git rev-parse
--short HEAD`); `curl -I
http://10.0.0.249:8080/artifacts/72/1/pipelines-debug-wip-24584d8.apk` returned
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18009527`, and a streamed `GET | shasum -a 256` matched.
## Last-run facts on every pipeline row (16 Oct 2026)
`android/` only. No server field was added: the whole run history already arrives
from `list_runs` (`internal/pipeline/runs.go`, id DESC), so the join is
client-side.
- **Pure join.** `ui/screens/PipelineLastRun.kt` adds `pipelineRunBadges(runs, now)`,
which folds the history onto a `Map<Long, PipelineRunBadge>` keyed by
pipeline id with `runId`, `state` (`runStateOf`), `ranAgo` and `duration`.
Recency comes from the run timestamps, not the input order — the higher run id
breaks an exact tie (or a missing/blank `created_at`), so an unsorted or
partial response is still correct. `PipelineRunBadge.metaLine()` formats
`ago · duration · run N` and drops any fragment that is genuinely absent (a
still-running run has no `finished_at`); it never prints a blank separator.
`formatRanAgo` mirrors the `formatDuration` integer rhythm (`just now`, then
`Nm ago`/`Nh ago`/`Nd ago`) and clamps clock skew to `just now`. A pipeline with
no run is simply absent from the map and the row prints the explicit
`NO_RUNS_RECORDED`
("no runs recorded") instead of a blank line. The last-run line is withheld
until `runsState.data != null` (`runsKnown`), so a not-yet-loaded history never
makes the false "no runs recorded" claim.
- **Row.** `PipelineListScreen.kt` refreshes runs alongside pipelines, anchors
"now" once per composition (`remember`), and renders the chip + meta line in a
`Row` under the unchanged title/secondary lines; the selected-row highlight is
untouched.
- **Tests.** `test/.../PipelineLastRunTest.kt` (10 cases) covers most-recent-wins
on unsorted input, no runs, unknown pipeline id, equal timestamps, an
unparseable timestamp, an unknown status word (`RunState.Unknown`, id still
rendered), each `formatRanAgo` scale plus blank/bad input, and the
`NO_RUNS_RECORDED` wording.
Verified on this tree (macOS, JDK 17 from Homebrew `openjdk@17`, Gradle 9.7.1,
`ANDROID_HOME=/Users/alan/Library/Android/sdk`):
- `gradle :app:testDebugUnitTest` → **153 tests, 0 failures, 0 errors, 0
skipped** (`PipelineLastRunTest` 10/10).
- `gradle :app:assembleDebug --rerun-tasks --no-build-cache` succeeded →
`app-debug.apk` **17,863,337 bytes**, sha256
`b22550660c1ce9f42719eb5a32a296055d9f3df97fa0fd94bb26fa3868730506`. This is a
full rebuild of the current tree; the review's blocker was that the earlier
published `artifacts/83/1/pipelines-debug-wip-5444390.apk` (17,997,811 bytes,
sha256 `0fb07207…`) was a different revision of `PipelineListScreen.kt`, so it
has been rebuilt and republished (see below).
- Screenshots on `emulator-5556` (`FoldB_API_36`, 2208x1840, density 420, dark
mode) with `android/scripts/capture_png.sh -s emulator-5556`: the narrow window
via `adb shell wm size 1080x2340`, the wide window at the default 2208x1840
(`wm size reset`). Both show the running run omitting its duration, the failed
and canceled rows carrying `ago · duration · run N`, and pipeline id 3 "Plan,
implement, review" printing `no runs recorded`.
- **APK publish.** Copied to
`…/artifacts/83/3/pipelines-debug-wip-5444390.apk` (`5444390` = `git rev-parse
--short HEAD`). `curl -I
http://10.0.0.249:8080/artifacts/83/3/pipelines-debug-wip-5444390.apk` returned
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 17863337`, and a streamed `GET | shasum -a 256` returned the
same `b2255066…` as the local file. The same APK was installed on the emulator
and the pulled installed `base.apk` hashed to `b2255066…`, so the reviewed
source is what was actually rendered.
## Remembered sort options for the pipelines and runs lists (16 Oct 2026)
Both list top bars gained a sort control that opens the choices plus a Reset, and
the choice is remembered per list across restarts. `android/` only; nothing in
the Pipelines server, its Go source, the Docker/compose files or the installer was
touched, no dependency was added (the icons come from the already-declared
`material-icons-extended`), no run was started from the app, and the attached
Pixel 10 Pro Fold was never installed on or driven (every `adb`/emulator command
targeted `emulator-5556`).
- **Pure comparators.** `ui/screens/ListSort.kt` defines the `PipelineSort`
(`ServerOrder` default, `NameAsc`, `NameDesc`, `RecentRun`, `FewestStages`,
`MostStages`) and `RunSort` (`NewestFirst` default, `OldestFirst`,
`LongestDuration`, `ShortestDuration`, `PipelineName`, `Status`) enums plus one
pure `pipelineComparator`/`runComparator` per sort and the `sortPipelines`/
`sortRuns` helpers. Every comparator ends in an explicit tie-break, so equal
primary keys always order the same way; a blank/unparseable timestamp and a run
with no recorded duration (still executing) sort last regardless of direction
instead of crashing. `ServerOrder` is a zero comparator, so the stable sort
preserves the server's own order exactly. `RecentRun` uses the shared
per-pipeline latest-run fold (`latestRunByPipeline`, extracted from the
last-run badge join in `PipelineLastRun.kt`) rather than folding the history
twice.
- **Shared time helpers.** `ui/Format.kt` gained `parseInstant` (moved out of
`PipelineLastRun.kt`) and `durationSeconds`; the existing `formatDuration` now
delegates to `durationSeconds`, so the printed duration and the sort key can
never disagree.
- **Shared control.** `ui/components/SortMenu.kt` is the one top-bar control both
screens use: an `IconButton` (its own glyph and content description, so it
cannot collide with the adjacent Refresh action or a future search entry point)
opening a `DropdownMenu` of the options — the active one carries a leading
check glyph, not colour alone — then a divider and Reset. It has no geometry
literals and anchors correctly at both window widths. The glyph is
`Icons.AutoMirrored.Filled.Sort` (the RTL-aware form, so no `Icons.Default.Sort`
deprecation warning at build time and the arrow mirrors correctly).
- **Persistence.** `data/SettingsRepository.kt` stores each choice as its stable
storage key (`pipeline_sort`, `run_sort`) with a `StateFlow`, exactly like the
server URL/workspace; `AppViewModel` exposes them and their setters. The list
screens resolve the stored string with `PipelineSort.fromStorage`/
`RunSort.fromStorage`, which fall back to the default for a stale, unknown or
blank value (the repository stays unaware of the UI enums).
- **Grouping.** `groupRunsByDay` now takes the ordering comparator and preserves
the order it produces (the default is still newest first, so the default output
is unchanged); the run list groups by day in that order and sorts within a day
by the same comparator.
Verified on this tree (macOS, Homebrew JDK 25 (`openjdk@25`), Gradle 9.7.1,
`ANDROID_HOME=/Users/alan/Library/Android/sdk`, `--offline`):
- `gradle --offline :app:testDebugUnitTest --rerun-tasks` → the 21 test-result XMLs
aggregate to **167 tests, 0 failures, 0 errors, 0 skipped** (the new
`ListSortTest` has 13 cases covering the storage fallback for both enums, server
order, case-insensitive name/stage sorts with their id/name tie-breaks,
recent-run no-run-last and run-id tie-breaks, newest/oldest with unparseable
timestamps last, duration longest/shortest with a still-executing run last and
equal-duration tie-break, pipeline-name/status sorts, and that equal keys order
identically whatever the input order; `RunGroupingTest` gained an explicit-order
case). `compileDebugKotlin` emits no warnings.
- `gradle --offline :app:assembleDebug --rerun-tasks --no-build-cache` (a full
rebuild, so the published binary is exactly this tree) succeeded →
`app-debug.apk` **17,879,721 bytes**, sha256
`cb68fbb13e469e81c15837ba95314a2ab40f1f29f4769e4a615bbc0ce4636a30`.
- On `emulator-5556` (`FoldB_API_36`, 2208x1840, density 420, dark mode) against
the live server `ws://10.0.2.2:8080/connect`, driven with `adb shell input` and
`uiautomator dump`; every capture below was written with
`android/scripts/capture_png.sh -s emulator-5556` (validated PNG, named display
id) into `…/artifacts/87/1/`. The live server's pipeline set churns while the
maintenance workflow runs, so the concrete names differ between captures, but
each ordering was read back from the accessibility tree:
- Wide (2208x1840 ≈ 841dp): tapping `Sort pipelines` opened the six options plus
`Reset` (`01_wide_pipelines_sort_open.png`); choosing `Name Z–A` reordered the
list to descending names and stored `pipeline_sort=name_desc`
(`02_wide_pipelines_name_za.png`). `Sort runs` opened the six run options plus
`Reset` (`03_wide_runs_sort_open.png`); `Oldest first` showed run 1 → 2 → 3 and
stored `run_sort=oldest_first` (`04_wide_runs_oldest_first.png`). The sort icon
and the adjacent `Refresh` stay separate actions at both widths (the icon's own
`Sort pipelines`/`Sort runs` content description sits left of `Refresh …`).
- **Persistence proof.** After setting pipelines `Name Z–A` and runs
`Oldest first`, `run-as net.awan.pipelines cat shared_prefs/pipelines_settings.xml`
showed `pipeline_sort=name_desc`, `run_sort=oldest_first`. `am force-stop
net.awan.pipelines` (verified `pidof` empty) then `am start` and a fresh
`uiautomator dump` showed the pipelines list still in descending-name order
(`05_wide_pipelines_name_za_after_relaunch.png`) and the runs list still oldest
first, run 1 → 2 → 3 (`06_wide_runs_oldest_first_after_relaunch.png`), with no
interaction.
- `Reset` on the pipelines menu restored the server order (id 1 → 5 → 11 → 6 →
4 → 9 → 3) and stored `pipeline_sort=server_order`; `Reset` on the runs menu
restored `run_sort=newest_first` and run 87 → 86 → 85 → 84 → 83 → 82
(`10_narrow_runs_reset_newest_first.png`).
- Narrow (`adb shell wm size 1080x2340` ≈ 411dp; `wm size reset` afterwards):
both `Sort pipelines` and `Sort runs` opened their menus
(`07_narrow_runs_sort_open.png`); `Status` ordered Canceled → Failed → Failed …
and stored `run_sort=status` (`08_narrow_runs_status_sort.png`); `Most recent
run` ordered the rows by recency 10h → 3d → 3d → 4d → 4d → 5d and put the
runless pipeline (`no runs recorded`) last, storing `pipeline_sort=recent_run`
(`09_narrow_pipelines_recent_run.png`).
- **Stale-key tolerance on device.** With `pipeline_sort` and `run_sort` set to
`garbage_key` in `shared_prefs/pipelines_settings.xml` (verified via `run-as …
cat`, then replaced by push + `run-as … cp`) and the app force-stopped and
relaunched, the pipelines list came back in the server's order (id 1 → 5 → 11 →
6 → 4 → 9 → 3, `11_narrow_pipelines_stale_key_falls_back_to_server_order.png`)
and the runs list in newest-first (run 87 → 86 → 85), with no crash.
- `adb -s emulator-5556 logcat -d | grep -c 'FATAL EXCEPTION'` and `… | grep -c
'E AndroidRuntime'` each returned 0; no run was started from the app.
- **APK publish.** `app-debug.apk` was copied to
`~/.local/share/pipelines/data/artifacts/87/1/pipelines-debug-wip-3480461.apk`
(`3480461` = `git rev-parse --short HEAD`); `shasum -a 256` matched. `curl -I
http://10.0.0.249:8080/artifacts/87/1/pipelines-debug-wip-3480461.apk` returned
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 17879721`, and a streamed `GET | shasum -a 256` returned the
same `cb68fbb1…` as the local file. The deterministic full-rebuild APK was
installed on `emulator-5556` (`adb -s emulator-5556 install -r`) and the pulled
installed `base.apk` hashed to `cb68fbb1…`, so the reviewed source is what was
actually rendered. At 17.1 MiB it exceeds the server's 8 MiB per-file inventory
cap, so it is served by direct URL only.
Not verified in this pass: `:app:lintDebug` was not run (its only reported issues
are the two pre-existing `NewApi` errors for `android:windowLightNavigationBar`);
a real hardware fold to the cover display was not exercised (narrow was produced
with `wm size`); no before/after baseline build was captured, since the change is
additive and the default orders are asserted unchanged by the `ServerOrder`/
`NewestFirst` unit tests.
## Filters for the runs and pipelines lists (16 Oct 2026)
Both list top bars gained a filter control, remembered per list across restarts
like the sort. `android/` only; nothing in the Pipelines server, its Go source,
the Docker/compose files or the installer was touched, no dependency was added
(the one new glyph, `Icons.Default.FilterList`, is from the already-declared
`material-icons-extended`), no run was started from the app, and the attached
Pixel 10 Pro Fold was never installed on or driven (every `adb`/emulator command
targeted `emulator-5556`).
- **Pure predicates.** `ui/screens/ListFilter.kt` defines `RunTimeRange`
(`AnyTime` default, `Today`, `Last7Days`, `Last30Days`), `RunPresence`
(`Any` default, `HasRuns`, `NoRuns`) and the `RunFilters`/`PipelineFilters`
data classes plus one pure predicate per facet (`runMatchesStatuses`,
`runMatchesPipeline`, `runMatchesTimeRange`, `pipelineMatchesPresence`,
`pipelineMatchesLastRunStatus`) and the AND-combining `filterRuns`/
`filterPipelines`. A default filter narrows nothing; an empty status set means
"any status". The status options are the server's own run vocabulary
(queued/running/succeeded/failed/canceled/interrupted), not the app-only
`active`/`unknown` buckets. A time window is inclusive calendar days ending
today (last 7 = today + the six days before), and a blank, unparseable or
future-dated timestamp never matches a finite window. A pipeline with no run
has no last-run status, so a selected status never matches it. `fromStorage`
tolerates stale/unknown/blank values by returning the default, and
`encodeRunStates`/`decodeRunStates` round-trip the status set as the server
status words in ordinal order.
- **Runs list.** Status (multi-select), pipeline (single-select from the
distinct pipelines already present in the run history, named by their runs, so
no extra fetch) and the time range, combined with AND.
- **Pipelines list.** The existing name search stays a separate field; the new
filter adds has-runs / no-runs and the most-recent run's status (multi-select).
Both pipeline facets depend on the run history, so `filterPipelines` leaves the
list unfiltered until that history is known rather than briefly hiding every
row.
- **Shared control.** `ui/components/FilterMenu.kt` is the one top-bar control
both screens use: an `IconButton` carrying a numeric active-filter count badge
(so "filters active" is never colour alone) opening the caller's sections plus
a divider and one Clear filters action (disabled when nothing is active). Its
`optionContent` slot receives a `dismiss` callback, so single-select entries
close the menu while multi-select toggles keep it open; `FilterCheckItem` is
the shared leading-check row. It has no geometry literals and anchors
correctly at both window widths.
- **Empty states.** `ui/components/States.kt`'s `EmptyState` gained optional
`actionLabel`/`onAction`. Both lists now distinguish "nothing exists" (no
action) from "nothing matches the current filters" (a Clear filters action);
the pipelines list also says when the name search and the filters together
match nothing. The clear action resets that list's filters (and, on Pipelines,
the search) without touching the other list.
- **Persistence.** `data/SettingsRepository.kt` stores each facet under its own
stable key (`run_filter_statuses`, `run_filter_pipeline`,
`run_filter_time_range`, `pipeline_filter_presence`,
`pipeline_filter_run_statuses`) with a `StateFlow`, exactly like the sorts;
`AppViewModel` exposes them and their setters. The screens resolve the stored
strings with `RunFilters.fromStorage`/`PipelineFilters.fromStorage` (the
repository stays unaware of the UI enums).
- **Shared time helper.** The run screen's file-private `runDate` was removed in
favour of `ListFilter.kt`'s `runLocalDate`, so the day-grouping label and the
time-range predicate share one parse. `groupRunsByDay` is unchanged.
Verified on this tree (macOS, Homebrew JDK 25 (`openjdk@25`), Gradle 9.7.1,
`ANDROID_HOME=/Users/alan/Library/Android/sdk`, `--offline`):
- `gradle --offline :app:testDebugUnitTest --rerun-tasks` → the 22 test-result
XMLs aggregate to **183 tests, 0 failures, 0 errors, 0 skipped** (up from 167;
the new `ListFilterTest` has 16 cases covering stored-value parsing/fallback,
encode/decode round-trip and garbage tolerance, empty-status "any", the status
union, pipeline id vs any, the inclusive time windows and blank/future
timestamps, the AND combination of every facet, presence has/no-runs, last-run
status excluding runless pipelines, the `runsKnown` guard, and the
distinct/sorted pipeline options).
- `gradle --offline :app:assembleDebug --rerun-tasks --no-build-cache` (a full
rebuild, so the published binary is exactly this tree) succeeded →
`app-debug.apk` **17,912,489 bytes**, sha256
`eaa34c0b030511c2e4de1964dc4e905e62e822e876b5c0128bfff4d918933fc5`.
- On `emulator-5556` (`sdk_gphone16k_arm64`, 2208x1840, dark mode) against the
live server `ws://10.0.2.2:8080/connect`, driven with `adb shell input` and
`uiautomator dump`; every capture below was written with
`android/scripts/capture_png.sh -s emulator-5556` (validated PNG, named display
id) into `…/artifacts/89/1/`:
- Selecting status `failed` narrowed the runs list to the failed runs and
showed the badge `1` (`01_runs_filtered_failed.png`), read back from the
accessibility tree.
- The runs `Filter runs` menu opened with its Status, Pipeline and Time range
sections, the active-count badge and `Clear filters`
(`02_runs_filter_menu_open.png`).
- **Filtered-empty state.** Adding pipeline `Complete a Task` to the `failed`
status matched run 43, but the contradictory `running` status (no `Complete
a Task` run is running) yielded no match: the list showed `No runs match the
current filters.` with a `Clear filters` button and badge `2`
(`03_runs_filtered_empty.png`); the button restored the full list and removed
the badge.
- The pipelines `Filter pipelines` menu carries the Runs (Any/Has runs/No runs)
and Last run status sections, the badge and `Clear filters`
(`05_pipelines_filter_menu_open.png`). `Has runs` + last-run status
`succeeded` narrowed the list to its succeeded-last-run pipelines
(`04_pipelines_filtered_has_runs_succeeded.png`); `No runs` + last-run status
`succeeded` is contradictory and showed `No pipelines match the current
filters.` with `Clear filters` and badge `2`
(`06_pipelines_filtered_empty.png`); the button restored the list and cleared
only the pipelines filter (the runs filter was left intact).
- **Persistence proof.** With runs status `failed` and pipelines `has_runs` +
last-run status `succeeded`, `run-as net.awan.pipelines cat
shared_prefs/pipelines_settings.xml` showed `run_filter_statuses=failed`,
`pipeline_filter_presence=has_runs`, `pipeline_filter_run_statuses=succeeded`.
`am force-stop net.awan.pipelines` (verified `pidof` empty) then `am start`
and a fresh `uiautomator dump` showed the pipelines list still narrowed with
badge `2` (`07_pipelines_filtered_after_relaunch.png`) and the runs list still
filtered to `failed` with badge `1`
(`08_runs_filtered_after_relaunch.png`), with no interaction.
- `adb -s emulator-5556 logcat -d | grep -c 'FATAL EXCEPTION'` and `… | grep -c
'E AndroidRuntime'` each returned 0; no run was started from the app.
- **APK publish.** `app-debug.apk` was copied to
`~/.local/share/pipelines/data/artifacts/89/1/pipelines-debug-wip-1c925d7.apk`
(`1c925d7` = `git rev-parse --short HEAD`); `shasum -a 256` matched. `curl -I
http://10.0.0.249:8080/artifacts/89/1/pipelines-debug-wip-1c925d7.apk`
returned `HTTP/1.1 200 OK`, `Content-Type:
application/vnd.android.package-archive`, `Content-Length: 17912489`, and a
streamed `GET | shasum -a 256` returned the same `eaa34c0b…` as the local file.
The deterministic full-rebuild APK was installed on `emulator-5556`
(`adb -s emulator-5556 install -r`) and the pulled installed `base.apk` hashed
to `eaa34c0b…`, so the reviewed source is what was actually rendered. At
17.1 MiB it exceeds the server's 8 MiB per-file inventory cap, so it is served
by direct URL only.
Not verified in this pass: `:app:lintDebug` was not run; a real hardware fold to
the cover display was not exercised (all captures were at the inner panel's
2208x1840 width, so no narrow-width capture of the filter menu was taken); the
time-range facet was unit-tested but not exercised on device, and no before/after
baseline build was captured, since the change is additive and the default filters
are asserted to narrow nothing by the unit tests.
### Filter menu overflow and accessibility (16 Oct 2026)
A UI review of the pass above found the runs `DropdownMenu` grew unbounded with
the distinct-pipeline count (N=8 made it fill the whole window), clipping the
`Clear filters` item under the bottom gesture inset, and that neither the
active-filter count nor the checked facets were exposed to accessibility. Fixed
in `ui/components/FilterMenu.kt` only (`android/`, no new dependency):
- **Bounded menu.** `filterMenuMaxHeight(screenHeightDp)` caps the menu at
`0.85 ×` the window height (window-derived, like the graph's height helpers, so
no new geometry literal), so the menu scrolls internally instead of growing
past the window as `N` rises.
- **Reset always visible.** The single `Clear filters` action is now a leading
header row (`Filters` + the reset `TextButton`, disabled when nothing is
active), so it is fully in view on open and never below the fold or clipped.
- **Above the navigation inset.** A trailing spacer of
`WindowInsets.navigationBars` bottom padding keeps the last option clear of the
gesture area at maximum scroll.
- **Accessible state.** The icon's description now folds in the count
(`filterMenuDescription`, e.g. "Filter runs, 2 filters active"), and
`FilterCheckItem` exposes `toggleableState` plus `Role.Checkbox`, so TalkBack
announces the count and which facet is checked.
Re-verified on this tree (Homebrew JDK 25, Gradle 9.7.1,
`ANDROID_HOME=/Users/alan/Library/Android/sdk`, `--offline`):
- `gradle --offline :app:testDebugUnitTest --rerun-tasks` → **185 tests, 0
failures** (new `FilterMenuTest`: the height helper's proportional/positive
growth and the description's 0/1/2/negative wording).
- `gradle --offline :app:assembleDebug` succeeded → `app-debug.apk` **18,005,500
bytes**, sha256 `7351c13b…`.
- On `emulator-5556` (2208x1840, density 420, dark mode) against
`ws://10.0.2.2:8080/connect`, captured with `android/scripts/capture_png.sh -s
emulator-5556` into `…/artifacts/89/4/`:
- The runs menu now has window `[1210,75]–[1945,1639]` (1564px = the 596dp cap),
ending ~138px above the gesture exclusion (y=1777); `Filters`/`Clear filters`
sit at the top (y=133–186) and after four swipes the last item `Last 30 days`
is at y=1466–1519, fully visible with the nav spacer below it
(`02_runs_filter_menu.png`).
- `uiautomator dump` reports the runs filter rows `checkable=true` with the
selected row `checked=true` (`Any time`), and the icon `content-desc` is
`Filter runs, 2 filters active` / `Filter runs, 1 filter active` matching
the badge (`03_runs_filtered_failed.png`, `01_runs_filtered_empty.png`).
- The pipelines menu (`Filters`/`Clear filters` at the top, `Runs` and `Last run
status` sections) is `[1542,93]–[1945,1622]`, also above the inset
(`04_pipelines_filter_menu.png`); `Has runs` + last-run `succeeded` filtered
the list (`05_…png`), `No runs` + `succeeded` showed `No pipelines match the
current filters.` with `Clear filters` (`06_…png`).
- **Persistence proof.** `am force-stop net.awan.pipelines` (verified `pidof`
empty) then `am start` and a fresh dump showed the pipelines screen still
filtered (badge `2`) and the runs list still `Filter runs, 1 filter active`
(`07_…png`, `08_…png`), with no interaction.
- `adb -s emulator-5556 logcat -d | grep -c 'FATAL EXCEPTION'` and `… | grep -c
'E AndroidRuntime'` each returned 0.
- **APK publish.** `app-debug.apk` copied to
`…/artifacts/89/4/pipelines-debug-wip-1c925d7.apk` (`1c925d7` = `git rev-parse
--short HEAD`); `shasum -a 256` matched. `curl` against
`http://10.0.0.75:8080/artifacts/89/4/pipelines-debug-wip-1c925d7.apk` returned
`HTTP 200`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18005500`.
Not verified: the **"nothing exists"** variants (`No pipelines are defined on this
server.` / `No runs have been recorded yet.`) were not captured — the live server
has both pipelines and runs, `list_runs` is not workspace-scoped, and the task
forbids touching the server's data, so there was no empty source to render them
against; the branch is unit-covered only indirectly. A real hardware fold and
`:app:lintDebug` were again not exercised.
## Executed vs not-executed is structural, with a legend (16 Oct 2026)
`android/` only. Nothing in the Pipelines server, its Go source, the Docker/
compose files or the installer was touched, no dependency was added, no run was
started from the app, and every `adb`/emulator command targeted `emulator-5556`
(lane A's `emulator-5554` was never used; the attached Pixel was never installed
on or driven).
- **The two states differ by shape, fill and border style, not by a faded tint.**
`ui/graph/WorkflowGraph.kt` now draws an executed route as a solid full-colour
stroke **with** its arrowhead, and a not-executed route as a dashed muted
stroke **without** an arrowhead. A node the run visited is filled with its
normal border; a node it did not is hollow (no fill) with a dashed muted border
and a muted-but-legible `onSurfaceVariant` label. The old `alpha = 0.25f` /
`0.3f` dimming is gone, so the distinction survives a screenshot, a dim screen
and a colour-blind reader.
- **Shared, testable predicates.** `stageIsExecuted(key, runState)` and
`edgeIsExecuted(edge, runState)` (both `runState == null` ⇒ executed) replace
the private `EdgeLayout.isExecuted` and the inline `visitedStages` check, so
drawing and the screen-reader `graphDescription` share one definition.
- **Dash token.** `INACTIVE_DASH_INTERVALS = floatArrayOf(14f, 10f)` is the one
line-style token; `INACTIVE_DASH_EFFECT` is the lazily-built `PathEffect` used
by both the not-executed edges and the not-executed node borders, so it is
never rebuilt per frame. Node/edge geometry keeps the existing layout
tokens/insets — the only new literals are the dash rhythm and the compact
legend swatch, not graph geometry.
- **Compact legend.** `GRAPH_LEGEND` (a solid, arrowed swatch labelled
`Executed`; a dashed, arrowless swatch labelled `Not executed`) is drawn as a
one-line `Row` pinned to the graph's top-start, opposite the Fit/expand
controls, so it stays visible with the top of the panel even on a short/narrow
window. It renders only when a run is selected.
- **The definition-only view is untouched.** With no `runState` every
stage/route is executed, so the graph renders exactly as before (solid, filled,
arrowed) and the legend is not composed — confirmed against the pipeline Graph
tab. (Superseded later the same day: the pass/fail change below now widens an
executed `success`/`error` route in this view too.)
- The run-detail Graph tab's help line was updated from "highlighted … dimmed" to
"solid … dashed and outlined".
Verification (macOS; Homebrew `openjdk@17` at
`JAVA_HOME=/opt/homebrew/opt/openjdk@17/libexec/openjdk.jdk/Contents/Home`,
Gradle 8.11.1, `ANDROID_HOME=/Users/alan/Library/Android/sdk`, `--offline`):
- `gradle --offline clean :app:testDebugUnitTest :app:assembleDebug` →
**188 tests, 0 failures, 0 errors**; `WorkflowGraphTest` **34** tests (3 new:
the executed predicates over the definition view and a `RunGraphState`, the
dash pattern being a positive even-length rhythm, and the legend naming both
states with executed first). The clean `:app:assembleDebug` produced
`app-debug.apk` **17,912,489 bytes**, sha256
`49631a3a2763bf1d9232eb9e7c8f9ff3edd719355ac0a99b7c91f7f40c3a1cc5` (two clean
rebuilds were byte-identical; this is the published artifact).
- A partly-executed run (run 77, pipeline id 11 "Focused tweak - implement review
commit": `implementer`, `reviewer`, `ui_reviewer` ran, `committer` did not) was
opened in the app against the live server `ws://10.0.2.2:8080/connect` in dark
mode, driven with `adb shell input`, and every capture below was written with
`android/scripts/capture_png.sh -s emulator-5556` (validated PNG magic bytes;
the fold emulator has two displays, so a `screencap` redirect must never be
used). Captures are in `…/artifacts/93/1/`:
- **Narrow** 1080x1920 @ density 480 (≈360dp): `[implementer]`, `[reviewer]`,
`[ui_reviewer]` and `[FAILURE]` are filled with solid, arrowed routes between
the visited stages and into `#failure`; `[committer]` and `[SUCCESS]` are
hollow with dashed borders, and every other route is dashed with no arrowhead
(`graph_partly_exec_narrow_1x.png`).
- **Narrow, 2x** at 2160x3840 @ density 960 (same 360dp): the same graph at
double the pixel density, dashes and arrowheads clearly resolved
(`graph_partly_exec_narrow_2x.png`).
- **Wide** 2208x1840 @ density 420 (≈841dp): `graph_partly_exec_wide_1x.png`;
**wide 2x** at 4416x3680 @ density 840: `graph_partly_exec_wide_2x.png`; a
colour 2x crop of the graph and legend `graph_partly_exec_wide_1x_zoom.png`.
- **Grayscale check.** Greyscale conversions (`PIL` `Image.convert('L')`) of
the narrow-2x and wide-1x captures, plus a 2x greyscale crop, keep the
distinction: the executed routes are continuous solid lines with arrowheads
and the nodes fill, while the not-executed routes are broken dashed lines and
the nodes are hollow outlines (`graph_partly_exec_narrow_2x_gray.png`,
`graph_partly_exec_wide_1x_gray.png`,
`graph_partly_exec_wide_1x_gray_zoom.png`).
- **Definition-only view unchanged.** Captured the pipeline Graph tab (no run)
on a pre-change build (a `54af453` worktree) and on this build; the graph pane
is pixel-identical (no legend on either side). A
`PIL ImageChops.difference` over the graph pane (`x 1150–2208, y 150–1500`)
reported `bbox None` / `0` differing pixels of 1,428,300 / max channel diff
`0`. Before/after pair: `def_before_p8.png` / `def_after_p8.png` (pipeline 8
Graph tab); the same source's pipeline-11 Graph tab after is
`graph_definition_only_wide_1x.png`.
- `adb -s emulator-5556 logcat -d` contained 0 `FATAL EXCEPTION` and 0
`E AndroidRuntime` lines.
- **APK publish.** `app-debug.apk` copied to
`…/artifacts/93/1/pipelines-debug-wip-54af453.apk` (`54af453` = `git rev-parse
--short HEAD`); `shasum -a 256` matched. `curl -I
http://10.0.0.249:8080/artifacts/93/1/pipelines-debug-wip-54af453.apk` (`10.0.0.249`
from `ipconfig getifaddr en0`) returned `HTTP/1.1 200 OK`,
`Content-Type: application/vnd.android.package-archive`, `Content-Length:
17912489`, and a streamed `GET | shasum -a 256` equalled the local file. At
~17.1 MiB the APK exceeds the server's 8 MiB per-file inventory cap, so it is
served by direct URL only.
Not verified in this pass: `:app:lintDebug`, the light theme, and a real hardware
fold (the wide/narrow layouts were produced with `wm size`/`wm density`); the
on-device captures used the debug build of this source, while the published APK
is a clean rebuild of the same source.
## Pass/fail edges are the loudest lines (16 Oct 2026)
`android/` only. Nothing outside `android/` was touched, no dependency was added,
no run was started from the app, and every `adb`/emulator command targeted
`emulator-5556` (lane A's `emulator-5554` was never used; the attached device was
never installed on or driven).
- **Two decisive outcomes, drawn heavier.** `ui/graph/WorkflowGraph.kt` now
treats `success` (pass) and `error` (fail) as the emphasised outcomes
(`isPassFailOutcome`). An executed pass/fail edge is drawn at
`PASSFAIL_EDGE_STROKE = 7f` — noticeably heavier than the previous `3f` — with
a stronger, more saturated stroke and a filled arrowhead proportional to its
own width (`edgeArrowHeadSize`, i.e. `strokeWidth * ARROW_HEAD_SCALE` with
`ARROW_HEAD_SCALE = 4`: 28f for this 7f pass/fail stroke, 12f for a normal
executed route), so pass/fail is obvious at a glance and from a distance.
- **Other lines stay finer.** Every other executed outcome keeps `EDGE_STROKE =
3f`, and a not-executed edge uses the finer `INACTIVE_EDGE_STROKE = 2.5f`, so
the two emphasised outcomes dominate. No outcome hue changed.
- **Stronger, same-hue stroke.** `boostSaturation(color, factor)` in
`ui/graph/GraphPalette.kt` scales HSV saturation by `PASSFAIL_SATURATION =
1.6f`, clamping at 1 while preserving hue, value and alpha. On the dark theme
the executed `success` stroke moves from `#F2C879` (hue 39.2°) to a vivid
`#F2AF30`-ish core (hue 39.3°, measured pixel `(242,175,48)`) and the executed
`error` stroke from `#FFB4AB` (hue 6.4°) to a stronger `(255,135,121)` (hue
6.3°); the measured pixel hues match their unboosted originals, so meaning is
not conveyed by a new colour. A non-pass/fail or not-executed edge keeps its
exact outcome colour.
- **Widths come from named tokens, not call sites.** `edgeStrokeWidth`,
`edgeArrowHeadSize` and `edgeStrokeColor` pick the token for an edge; the old
`12f` arrowhead literal is gone (the draw scope takes the size as a
parameter). The legend swatch keeps the base `EDGE_STROKE`/`ARROW_HEAD_SIZE`
because it names the generic executed/not-executed states, not pass/fail.
- **Definition-only view.** With no run selected every route counts as executed,
so the definition graph now shows the same pass/fail emphasis (still no
legend). The run Graph tab help line now adds "Executed success and failure
routes are drawn thickest."
Verification (macOS; Homebrew `openjdk@17`,
`JAVA_HOME=/opt/homebrew/opt/openjdk@17/libexec/openjdk.jdk/Contents/Home`,
Gradle 8.11.1 at
`~/.gradle/wrapper/dists/gradle-8.11.1-bin/…/gradle-8.11.1/bin/gradle`,
`ANDROID_HOME=/Users/alan/Library/Android/sdk`, `--offline`):
- `gradle --offline clean :app:testDebugUnitTest :app:assembleDebug` →
**193 tests, 0 failures, 0 errors**; `WorkflowGraphTest` **36** (2 new: the
executed pass/fail edge is the widest and its arrowhead scales, and only
`success`/`error` are pass/fail outcomes) and `GraphPaletteTest` **10** (3 new:
`boostSaturation` raises saturation while keeping hue/value/alpha, is safe and
clamped at the edges, and only executed pass/fail strokes are saturated
further). The clean `:app:assembleDebug` produced `app-debug.apk`
**17,912,489 bytes**, sha256
`ce63722b851ce26322da69fa47bdc91958c3d7db3e339c1340efc3e04b6780f8`.
- **Before/after on a run with both a success and an error edge.** Run 77
(pipeline 11 "Focused tweak - implement review commit", failed at `ui_reviewer`
with `error`) was opened in the app against the live server
`ws://10.0.2.2:8080/connect` in dark mode; its taken routes include a `success`
and an `error` edge. "Before" is HEAD `9c47527` (the six edited files stashed,
rebuilt, installed; verified by the help line without "thickest"); "after" is
this change. Captures were written with
`android/scripts/capture_png.sh -s emulator-5556`:
- **Wide** 2208x1840 @ density 420 (≈841dp): `before_wide_1x.png` /
`after_wide_1x.png`. At the panel's fit scale the executed success/error
stroke's saturated core measures **1px before, 3px after** (sampled at the
same x), while the dashed non-pass/fail routes stay ~1px.
- **Wide 2x** 4416x3680 @ density 840: `before_wide_2x.png` /
`after_wide_2x.png`.
- Cropped graph panes `before_wide_{1x,2x}_graphcrop.png` /
`after_wide_{1x,2x}_graphcrop.png` and stacked before/after sheets
`compare_wide_1x.png` / `compare_wide_2x.png` show the two amber `success`
edges and the red `error` edge as the boldest lines after the change, with
the dashed `blocked`/`rejected`/`approved`/`skipped` routes and the
not-executed `committer`/`SUCCESS` edges unchanged.
- `adb -s emulator-5556 logcat -d` contained 0 `FATAL EXCEPTION` and 0
`E AndroidRuntime` lines.
- **APK publish.** `app-debug.apk` copied to
`…/artifacts/98/1/pipelines-debug-wip-9c47527.apk` (`9c47527` = `git rev-parse
--short HEAD`); `shasum -a 256` matched. `curl -I
http://10.0.0.249:8080/artifacts/98/1/pipelines-debug-wip-9c47527.apk` (`10.0.0.249`
from `ipconfig getifaddr en0`) returned `HTTP/1.1 200 OK`,
`Content-Type: application/vnd.android.package-archive`, `Content-Length:
17912489`, and a streamed `GET | shasum -a 256` equalled the local file. The
APK exceeds the server's per-file inventory cap, so it is served by direct URL
only.
Not verified in this pass: `:app:lintDebug`, the light theme, and a real hardware
fold (the wide layout was produced with `wm size`/`wm density`); the on-device
captures used the debug build of this source, while the published APK is a clean
rebuild of the same source.
## A modern visual language for the workflow graph (16 Oct 2026)
The graph read like an old terminal diagram (flat fills, hard outlines, sharp
right angles, `[bracketed]` all-caps labels, small arrowheads, raw text over the
canvas). This pass gives it a modern surface language without changing any
information or any hue. `android/` only; no dependency was added (the graph's
corner comes from the theme's own shape scale), no run was started from the app,
and every `adb`/emulator command targeted `emulator-5556` (lane A's
`emulator-5554` was never used; the attached Pixel was never installed on or
driven). The only modified tracked files are the four under `android/` shown in
`git status --short` below; the capture runs also leave untracked scratch
directories at the repo root (`.ui_review*/`), so a bare `git status --short` is
not clean and the "nothing outside `android/` touched" claim is only about the
change itself, not those untracked captures.
- **Nodes are rounded and tonal, terminals are pills.** `WorkflowGraph.kt` reads
`MaterialTheme.shapes.medium` once per composition for a stage's corner and
gives a terminal a full pill (`height/2`), so a terminal is visibly not a stage.
The fill is a *tonal surface*: the new pure `tonalFill(surface, accent,
fraction)` blends a raised `surfaceContainerHigh` with a subtle fraction of the
node's semantic colour (`NEUTRAL_TINT`/`KIND_TINT` for a stage by kind,
`TERMINAL_TINT` for a terminal's success/error hue), and the hard outline is
replaced by a soft `outlineVariant` border (`NODE_BORDER`, strengthened for a
selected stage with `NODE_BORDER_SELECTED`). Every kind's hue survives; the
terminal fill now genuinely tints the outcome hue.
- **Type comes from the app's scale.** The node name uses the app's `cardTitle`
role and the outcome labels its `label` role (no ad-hoc `13.sp`/`11.sp`), with
the theme's own line height and letter spacing; the `[brackets]` and the
all-caps `SUCCESS`/`FAILURE` are gone — the graph shows `Success`/`Failure` in
the terminal's own colour (the new pure `nodeDisplayLabel`; the shared
`GraphSemantics.nodeLabel` the TUI-mirroring panes use is untouched).
- **Edges are smoother, with one control offset and matched arrowheads.** The
stored route is still the axis-aligned polyline (`routePoints`, and its layout
tests, are unchanged), but drawing now rounds every right-angle bend with the
single `ROUTE_CORNER_RADIUS` control offset (the pure `cornerCutRadius` clamps a
short adjacent segment to half its length so two cut-backs can never meet),
uses `StrokeCap.Round`/`StrokeJoin.Round`, and scales the filled arrowhead to
the line with one `ARROW_HEAD_SCALE` (`edgeArrowHeadSize = edgeStrokeWidth *
ARROW_HEAD_SCALE`). Labels sit on a rounded *tonal chip* (`tonalFill` of the
raised surface with the label's own colour) instead of raw text over the canvas.
- **More breathing room, from named tokens.** Node width/height, the horizontal
gap, the graph padding, the per-edge lane spacing and track step, and the
terminal-row gap are now named dp tokens (no inline geometry literals); the
values grew so nodes and the per-edge tracks have visibly more room, and the
collapsed-panel floor grew to `320.dp` to still fit a 4-stage graph with its
terminal row.
- **Nothing semantic changed.** The executed/not-executed structural split (solid
full-colour + arrowhead vs dashed muted + no arrowhead; filled vs hollow/dashed
node), the pass/fail emphasis (heavier, same-hue, more-saturated stroke with the
largest head), the selected-stage invert, ntfy/custom/model kind tints, the
`error*` fallback label, the legend, the active halo/elapsed badge, the flow
dots and the screen-reader description are all kept. `graphColors` and
`outcomeColor` keep their field names, so the Timeline step chips that share
them still agree with the graph.
Verification (macOS, Homebrew JDK 25 `openjdk@25`, Gradle 9.7.1,
`ANDROID_HOME=/Users/alan/Library/Android/sdk`, `--offline`):
- `gradle --offline :app:testDebugUnitTest --rerun-tasks` → `BUILD SUCCESSFUL`;
the test-result XMLs aggregate to **207 tests, 0 failures, 0 errors, 0
skipped** (4 new: `WorkflowGraphTest` for the readable node labels, the
arrowhead proportional to its stroke and the corner-cut clamp, and
`GraphPaletteTest` for `tonalFill`). `compileDebugKotlin` emitted no warnings
(the deprecated `quadraticBezierTo` was replaced by `quadraticTo`).
- `gradle --offline :app:assembleDebug` → `BUILD SUCCESSFUL`; `app-debug.apk` is
**17,928,873 bytes**, sha256
`ba5bcc467989425b69aad2ae70799c0cf4d9eaf54be30243b4631fb7e94916b3`.
- On `emulator-5556` (`FoldB_API_36`, dark mode) against the live server
`ws://10.0.2.2:8080/connect`, driven with `adb shell input` and `uiautomator
dump`. Every capture was written with `android/scripts/capture_png.sh -s
emulator-5556` (validated PNG magic bytes, named display id) into
`~/.local/share/pipelines/data/artifacts/108/1/`. The three cases are a
definition-only graph (pipeline 3 "Plan, implement, review", 4 stages), a
partly executed run (run 94, failed at `committer`: `implementer`/`reviewer`/
`ui_reviewer` and the failed `committer` executed, `Success` not) and its
selected (current) stage. Widths: **wide** 2208x1840 @ density 420 (≈841dp) and **narrow**
1080x1920 @ density 480 (≈360dp); **2x** doubles the pixel size and density
(4416x3680 @840 and 2160x3840 @960), so the same dp layout is rendered at
double the pixels. "Before" is a clean `git archive 8b39c08` tree (never a
working-tree stash) built and installed; "after" is this tree.
- `{before,after}_wide_1x_definition.png`, `{before,after}_wide_2x_definition.png`,
`{before,after}_narrow_1x_definition.png`, `{before,after}_narrow_2x_definition.png`
— the definition graph; before shows `[planner]`/`[FAILURE]` rectangular
nodes with hard 90° routes and raw labels, after shows rounded, tonal nodes,
pill terminals and chipped labels.
- `{before,after}_wide_1x_run.png`, `{before,after}_wide_2x_run.png`,
`{before,after}_narrow_1x_run.png`, `{before,after}_narrow_2x_run.png` — run
94; `implementer`/`reviewer`/`ui_reviewer` were visited and the failed
`committer` was visited too (it was entered and then failed), so all four
stages are filled and the selected `committer` inverts (light `inverseSurface`
fill, solid primary border); the executed `success`/`error` routes are the
boldest lines, and the not-executed `Success` terminal is hollow with a dashed
border (the `Failure` terminal, reached by the executed `error` edge, is
filled). The invert applies only to an *executed* stage; a selected
*not-executed* stage is instead drawn hollow with a dashed primary border
(`drawNodes`' not-executed branch), so selection is legible in either state.
- `{before,after}_{wide,narrow}_{1x,2x}_selected.png` — a 2x crop of the
selected `committer` node (its primary border and rounded shape after vs the
sharper `[committer]` before).
- `compare_wide_1x_definition.png`, `compare_wide_1x_run.png`,
`compare_narrow_1x_definition.png`, `compare_narrow_1x_run.png` — stacked
before/after sheets for the 1x narrow and wide cases.
- `adb -s emulator-5556 logcat -d` contained 0 `FATAL EXCEPTION` and 0 `E
AndroidRuntime` lines after a fresh launch and a Runs/Graph sweep; no run was
started from the app. The emulator's display was reset to its native
2208x1840 @420 afterwards.
- **APK publish.** `app-debug.apk` was copied to
`~/.local/share/pipelines/data/artifacts/108/1/pipelines-debug-wip-8b39c08.apk`
(`8b39c08` = `git rev-parse --short HEAD`); `shasum -a 256` matched. `curl -I
http://10.0.0.249:8080/artifacts/108/1/pipelines-debug-wip-8b39c08.apk` (LAN
address from `ipconfig getifaddr en0`) returned `HTTP/1.1 200 OK`,
`Content-Type: application/vnd.android.package-archive`, `Content-Length:
17928873`, and a streamed `GET | shasum -a 256` returned the same `ba5bcc46…`
as the local file. At 17.1 MiB it exceeds the server's 8 MiB per-file inventory
cap, so it is served by direct URL only.
Not verified in this pass: `:app:lintDebug` (its only reported issues are the two
pre-existing `NewApi` errors for `android:windowLightNavigationBar`); the light
theme; the active/animating halo, elapsed badge and flow dots (the run 94 graph
is a finished run, so it renders settled — those live-run visuals are unchanged
by this pass and are covered by `GraphMotionTest`); a real hardware fold
(narrow/wide were produced with `wm size`/`wm density`); and a greyscale pass (the
executed/not-executed distinction is still structural, but only colour captures
were taken). The crops are derived from the full captures with PIL; the
full-size PNGs above are the primary evidence.
### Review follow-up and re-verification (16 Oct 2026)
A follow-up pass addressed the review findings on the code above. The rendered
surface is unchanged (the token conversion maps the former pixel literals onto the
same device-scaled geometry), and `android/` is still the only modified tree; the
untracked `.ui_review*/` scratch captures at the repo root are not part of it.
- **Duplication.** The two near-identical rounded tonal chips (the edge outcome
labels and the active-stage elapsed badge) are now one
`DrawScope.drawTonalChip(textTopLeft, textSize, color)` helper; both call sites
pass the accent tinted into `labelBackground`, so the chip geometry lives once.
- **Redundant geometry.** `cornerCutRadius` now takes the adjacent segment lengths
the caller has already measured (`cornerCutRadius(inLength, outLength, radius)`),
so `roundedRoutePath` computes each corner's two `hypot`s once instead of twice.
- **Redundant width.** The new pure `arrowHeadSizeFor(strokeWidth)` is the one
arrowhead-from-stroke mapping; `drawEdgePaths` passes the width it has just
computed (`arrowHeadSizeFor(width)`) instead of re-deriving it, and
`edgeArrowHeadSize` delegates to the same function.
- **Geometry tokens.** `ROUTE_CORNER_RADIUS` (`7.dp`) and the chip
`EDGE_CHIP_PAD_X`/`EDGE_CHIP_PAD_Y`/`EDGE_CHIP_CORNER` (`2.dp`/`1.dp`/`2.dp`) are
dp tokens like the rest of the new graph geometry, not raw pixel literals.
Re-run checks (same environment as above):
- `gradle --offline :app:testDebugUnitTest` → `BUILD SUCCESSFUL`; the test-result
XMLs aggregate to **207 tests, 0 failures, 0 errors, 0 skipped** (the
`cornerCutRadius` test now exercises the length-based clamp).
- `gradle --offline :app:compileDebugKotlin --rerun-tasks` → `BUILD SUCCESSFUL`
with no `w:` warnings.
- `gradle --offline :app:assembleDebug --rerun-tasks` → `BUILD SUCCESSFUL`;
`app-debug.apk` is **17,928,873 bytes**, sha256
`ab99e734b0b190294ebfad8d342caf599286cefda23a0faf39f0244496e3af1a`. (A full
`--rerun-tasks` rebuild is byte-reproducible — two consecutive runs produced
this same hash — whereas incremental packaging is not, so the published APK is
the `--rerun-tasks` one.)
- Smoke captures on `emulator-5556` (native 2208x1840 @420) with the rebuilt APK
(`adb -s emulator-5556 install -r app/build/outputs/apk/debug/app-debug.apk`),
written via `android/scripts/capture_png.sh -s emulator-5556`:
`followup_wide_1x_definition.png` (the pipeline 3 definition graph) and
`followup_wide_1x_run106.png` (run 106, all four stages visited) in
`~/.local/share/pipelines/data/artifacts/108/3/`. Both render the rounded tonal
nodes, pill terminals and chipped labels; run 106 shows the executed stages
filled, the selected `committer` inverted (light fill, solid primary border) and
the not-executed `Failure` terminal hollow with a dashed border — the same
structural executed/not-executed split, unchanged. `adb -s emulator-5556 logcat
-d | grep -cE 'FATAL EXCEPTION|E AndroidRuntime'` is `0`; the display was not
resized (still native 2208x1840 @420).
- **APK publish (this pass).** The rebuilt APK was copied to
`~/.local/share/pipelines/data/artifacts/108/3/pipelines-debug-wip-8b39c08.apk`
(`8b39c08` = `git rev-parse --short HEAD`). `curl -I
http://10.0.0.249:8080/artifacts/108/3/pipelines-debug-wip-8b39c08.apk` returned
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 17928873`, and a streamed `GET | shasum -a 256` returned the
same `ab99e734…` as the local file.
### Second review follow-up (16 Oct 2026)
Two remaining findings on the modernised graph were fixed. The rendered surface is
unchanged — the first is a same-value refactor, the second a doc-only correction —
so the before/after captures above still describe the output.
- **One label colour, not two.** `drawEdgeLabels` declared `accent` and
`textColor` holding the identical value (both `outcomeColor(...)` when the edge
executed, else `colors.labelText`); they are now the single `labelColor`, used for
both the label text and its chip tint. No pixel changes.
- **README cites the live arrowhead token.** The dated "Pass/fail edges" section
cited the removed `PASSFAIL_ARROW_HEAD_SIZE = 20f`; it now describes the current
mapping (`edgeArrowHeadSize` = `strokeWidth * ARROW_HEAD_SCALE`, i.e. 28f
pass/fail and 12f normal), matching `WorkflowGraph.kt`.
Re-verified (Homebrew `openjdk@25`, Gradle 9.7.1,
`ANDROID_HOME=/Users/alan/Library/Android/sdk`, `--offline`):
- `gradle --offline :app:compileDebugKotlin --rerun-tasks` → `BUILD SUCCESSFUL`
with no `w:` warnings.
- `gradle --offline :app:testDebugUnitTest --rerun-tasks` → `BUILD SUCCESSFUL`;
the test-result XMLs aggregate to **207 tests, 0 failures, 0 errors, 0 skipped**.
- `gradle --offline :app:assembleDebug --rerun-tasks` → `BUILD SUCCESSFUL`;
`app-debug.apk` is **17,928,873 bytes**, sha256
`c95fab884d392a2b3df6170ec2e16ccc4fdf6f1fef4e946425f5dcda56c881a7`, reproducibly
(two consecutive `--rerun-tasks` rebuilds matched).
- Smoke captures on `emulator-5556` (native 2208x1840 @420) with this APK, written
via `android/scripts/capture_png.sh -s emulator-5556`:
`followup2_wide_1x_launch.png`, `followup2_wide_1x_definition.png` (pipeline 3)
and `followup2_wide_1x_run.png` (run 109, partly executed) in
`~/.local/share/pipelines/data/artifacts/108/5/`. The definition graph renders
rounded tonal stages, pill terminals (filled `Failure`/`Success`) and chipped
labels; run 109 fills the visited stages, inverts the selected `committer`
(light fill, solid primary border) and leaves the not-executed `Failure` terminal
hollow with a dashed border. `adb -s emulator-5556 logcat -d | grep -cE 'FATAL
EXCEPTION|E AndroidRuntime'` is `0`.
- **APK publish (this pass).** The rebuilt APK was copied to
`~/.local/share/pipelines/data/artifacts/108/5/pipelines-debug-wip-8b39c08.apk`
(`8b39c08` = `git rev-parse --short HEAD`); `curl -I
http://10.0.0.249:8080/artifacts/108/5/pipelines-debug-wip-8b39c08.apk` returned
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 17928873`.
### Re-verification with a fresh before/after capture set (run 117, 16 Oct 2026)
The source is unchanged from the sections above; this pass re-ran every check on
it and produced a fresh, complete before/after capture set in
`~/.local/share/pipelines/data/artifacts/117/1/`. `android/` remains the only
modified tree (the untracked `.caps117/` scratch captures at the repo root and the
older `.ui_review*/` directories are not part of the change). No run was started
from the app, only `emulator-5556` was ever addressed, and its display was reset to
native 2208x1840 @420 at the end.
- `gradle --offline :app:assembleDebug --rerun-tasks` → `BUILD SUCCESSFUL`;
`app-debug.apk` is **17,928,873 bytes**, sha256
`c95fab884d392a2b3df6170ec2e16ccc4fdf6f1fef4e946425f5dcda56c881a7` (identical to
the "Second review follow-up" build above).
- `gradle --offline :app:testDebugUnitTest --rerun-tasks` → `BUILD SUCCESSFUL`;
the test-result XMLs aggregate to **207 tests, 0 failures, 0 errors, 0 skipped**
(the new `tonalFill`, `nodeDisplayLabel`, `arrowHeadScalesWithTheStrokeItTerminates`
and `cornerCutNeverExceedsHalfTheShorterSegment` tests included).
- **Captures.** The same four display configurations as the first pass
(`wm size`/`wm density`: wide 2208x1840 @420 and its 2x 4416x3680 @840; narrow
1080x1920 @420 and its 2x 2160x3840 @840), each for the pipeline 3
definition-only graph and the partly executed run 109 (the selected `committer`),
written with `android/scripts/capture_png.sh -s emulator-5556`:
`{before,after}_{wide,narrow}_{1x,2x}_{definition,run}.png`, the 2x-upscaled
`{before,after}_{wide,narrow}_{1x,2x}_selected.png` node crops, and the stacked
`compare_{wide,narrow}_1x_{definition,run}.png` sheets. The `before` images were
rebuilt from `HEAD` (the four tracked files stashed, `assembleDebug`, captured,
then the stash popped and the after build reproduced the same sha256); they show
the sharp-cornered flat fills, `[bracketed]` all-caps labels and thin raw-text
routes, while the `after` images show the rounded tonal stages, pill terminals
(`Failure` hollow/dashed when not executed, `Success` filled) and chipped labels.
`adb -s emulator-5556 logcat -d | grep -cE 'FATAL EXCEPTION|E AndroidRuntime'`
is `0`.
- **APK publish (this pass).** Copied to
`~/.local/share/pipelines/data/artifacts/117/1/pipelines-debug-wip-8b39c08.apk`;
`curl -I http://10.0.0.249:8080/artifacts/117/1/pipelines-debug-wip-8b39c08.apk`
returned `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 17928873`.
## Remembering the list scroll position (16 Oct 2026)
Returning from a pipeline or a run now restores the list to exactly where the
operator left it — the same item at the same offset, on either window width — and
the position also survives a configuration change, rotation and process death.
`android/` only; nothing in the Pipelines server, its Go source, the
Docker/compose files or the installer was touched, no dependency was added (the
declared `material-icons-extended` is unchanged), no run was started from the app
and no server field was added.
- **Root cause.** A covered pane is a different composition from an open one: when
a detail opens on a wide window, pane 0 stops drawing its list and draws its
compact identity in a strip instead, so the list screen (and any scroll state it
owned) was discarded, and backing out rebuilt it at the top. The runs
destination is additionally recreated by the `NavHost` when the app-level runs
selection changes. The fix owns each list's scroll state at the app shell, above
the `NavHost` (`PipelinesApp`), and passes it into the list screens, so it is
never inside the pane that comes and goes.
- **One scroll state per list.** `PipelinesApp` holds
`pipelineListState`/`runListState` with `rememberSaveable(saver = LazyListState.Saver)`
and passes them to `PipelineDestination`/`RunsDestination` and on to
`PipelineListScreen`/`RunHistoryScreen` (and `RunHistoryContent`), whose
`LazyColumn` now takes that state. The same two screens serve both window widths
and both entry points, so the runs list reached from a pipeline gets the same
treatment as one opened normally.
- **Restore and clamp rule.** `ui/components/ListScroll.kt` holds the pure
`ListScrollAnchor(index, offset)` and `restoredScrollAnchor(anchor, itemCount)`
(the saved index clamped to the nearest valid item, the offset kept only for the
item that survived) plus the `RestoreListScroll(state, itemCount)` composable,
which is keyed on the item count so it runs once when the list's size settles
and never on the operator's own scrolling. A list that changed underneath (a
filter, a sort, a refresh, items removed) therefore clamps to the nearest
sensible item instead of jumping to the top or throwing, a scroll after coming
back is never overridden, and a list that has not loaded yet is left alone so a
restored position is not reset to the top while the data is still arriving.
- **Runs list before it has loaded (fixed 16 Oct 2026).** The runs list has no
pane-level empty state, so its first frame — before `LaunchedEffect {
vm.refreshRuns() }` has set `loading` — was data-less, not-loading and classified
as content. `RunHistoryContent` then composed an empty list whose only slot was
the "no runs" line, and `RestoreListScroll` clamped the restored index to 0
before the real list arrived: the runs list always came back at the top after
process death (the pipelines list was spared only because its empty state was
classified as a distinct `LoadPhase.Empty`). `listLoadPhase` now takes the
pane's `loaded` signal (`LoadState.loaded`) and reads a data-less list that has
never loaded as loading rather than empty, so the list — and its restored
position — is not composed until the history is actually in hand. Both list
screens pass it.
- **One source for the runs list body.** `RunHistoryScreen` no longer maintains a
second, hand-written copy of the LazyColumn's item count. The pure
`runListEntries(...)` builds the slots (the usage block, the single
empty-or-grouped body and the optional inline error row) once, in layout order;
the column renders exactly that list and `RestoreListScroll` clamps to its size,
so the count can never drift from what is drawn. `RunListEntriesTest` pins the
slot order, the stable keys and the count.
Evidence (macOS, JDK 17 from Homebrew `openjdk@17`, cached Gradle 8.11.1
distribution, `ANDROID_HOME=~/Library/Android/sdk`, every Gradle command with
`--no-daemon --offline --console=plain`):
- `:app:clean :app:testDebugUnitTest :app:assembleDebug` → `BUILD SUCCESSFUL`;
the tests were then re-executed with `:app:testDebugUnitTest --rerun-tasks`
(not served from the build cache). The result XMLs total **292 tests, 0
failures, 0 errors, 0 skipped** across 34 files. `ListScrollTest` (6 cases)
pins the restore/clamp rule (in-range item keeps its index and offset, the last
item keeps its offset, a shrunken list clamps to its last item and drops the
offset, a negative index clamps to the top, an empty list stays at the top); the
two new `LoadPhaseTest` cases pin that a data-less list that has never loaded
reads as loading while the default keeps the old rule; and `RunListEntriesTest`
(5 cases) pins the runs body's slot order, stable keys and count.
`app/build/outputs/apk/debug/app-debug.apk` is 18,011,393 bytes, sha256
`13b8d2871e9ad522e0d5a826642cdf467a95939408bed519d952e83d5c8dbb02`.
- `:app:lintDebug` aborts on only the two pre-existing `NewApi` errors for
`android:windowLightNavigationBar` (minSdk 26) in `res/values/themes.xml` and
`res/values-night/themes.xml`, which this change did not modify; no error or
warning points at the scroll change.
- **APK publish.** `app-debug.apk` was copied to
`~/.local/share/pipelines/data/artifacts/157/1/pipelines-debug-wip-c700b28.apk`
(`c700b28` = `git rev-parse --short HEAD`; the tree is uncommitted WIP on top of
it); `shasum -a 256` matched the built file (`13b8d287…`). `curl -I
http://10.0.0.249:8080/artifacts/157/1/pipelines-debug-wip-c700b28.apk` returned
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18011393`.
- **Device evidence (operator's Pixel 10 Pro Fold, `adb -s 58281FDCG000JF`, inner
2076x2152 at the 330 density override ≈1006dp; narrow override `wm size
1080x1920`).** The build was installed with `adb -s 58281FDCG000JF install -r`,
driven against the live LAN server (`curl http://127.0.0.1:8080/healthz` →
`{"healthy":true}`), and captured with `android/scripts/capture_png.sh -s
58281FDCG000JF` (device-side `screencap` to a file, then `pull` — never
`exec-out`), written to `~/.local/share/pipelines/data/artifacts/157/1/`. The
scroll position is read from `uiautomator dump` as the first `run «id» · …` line
(the runs list) or the first `id «n» · v…` line (the pipelines list):
| case | how driven | result |
| --- | --- | --- |
| pipelines, wide, open→back | scroll down (first row `id 6`), tap the pipeline, Back | same first row; `01_list_scrolled.png` vs `03_list_restored.png` differ in **no pixel** (`bbox None`) |
| runs, wide, open→back | scroll down (first row `run 32 · 13 Oct 17:21`), tap the run, Back | same first row; `05_runs_scrolled.png` vs `06_runs_restored.png` differ in **no pixel** (`bbox None`) |
| **runs, process death** | HOME, `adb -s 58281FDCG000JF shell am kill net.awan.pipelines` (`pidof` empty), restore the task from Recents | back on the Runs destination with the same first row `run 41 · 15 Oct 14:35`; `30_runs_before_death.png` vs `31_runs_after_death.png` differ only in the status bar (`bbox (138,67)-(289,95)`) |
| runs, rotation | `user_rotation 1`, then `0` | same top row `run 10 · 11 Oct 16:01` after both |
| pipelines, rotation | `user_rotation 1`, then `0` | same top row in landscape; the first flip re-laid the anchor onto the adjacent row (`id 6`→`id 11`) and was stable on the second and later flips — the list never returned to the top |
| density, config change | `wm density 330`→`340`→`330` | same top row `run 10 · 11 Oct 16:01` |
| pipelines, narrow | `wm size 1080x1920`; scroll, open a pipeline, Back | same first row `id 4`; `70_narrow_pipelines_before.png` vs `72_narrow_pipelines_after.png` differ in **no pixel** (`bbox None`) |
| runs, narrow | `wm size 1080x1920`; scroll, open a run, Back | same first row `run 8 · 11 Oct 14:44`; only the status bar differs |
| list shrank while open | pipelines scrolled to the bottom, then search `quick` | the two matches (`id 9`, `id 10`) are shown — clamped, not blank and not reset to the top — and the process stayed alive with no `FATAL EXCEPTION` in `logcat` |
For the open→back cases the top row and its pixel offset matched exactly (the
screenshot diff isolates only the status-bar clock); rotation, the density
change and process death restored the same destination and top row. `device.lock`
was held for every `adb` command and released afterwards, and no run was started
from the app.
- **Not exercised.** `onOpenRun` from a pipeline detail is only reached through
`StartRunDialog.onStarted` (after starting a run), which the task forbids, so the
runs list reached that way is kept compiling and functional but not driven; it
shares the one `runListState`, so it gets the same treatment as the normally
opened runs list. A real hardware fold to the cover display was not exercised
(narrow was produced with `wm size`).
## The covered edge is measured, not budgeted (16 Oct 2026)
The covered panes used to spend the fixed `PEEK_BUDGET_DP` (`224.dp`) whatever the
window width was, so on a folded window the covered area was over half the screen
and the active pane was left with a fixed, small width. The stack now derives the
covered region from what a covered edge actually has to show and takes the active
pane's width from what remains. `android/` only; no dependency was added, no run
was started from the app, the Pipelines server/Go source/installer/Docker files
were not touched, and the operator's Pixel 10 Pro Fold was not used at all
(implementation verified with the build and the unit tests, per the brief).
- **The region is measured, not budgeted.** `rememberCompactIdentityWidth`
(`ui/components/PaneIdentity.kt`) measures the width one covered edge needs for
its compact identity — an icon plus the shortest label that identifies the pane
— at runtime, with the app's own type role and the platform's font metrics, and
floors it at the platform minimum touch target
(`LocalMinimumInteractiveComponentSize`). `SlidingPaneStack` adds the leading
system-gesture inset (`systemBars ∪ systemGestures`) and uses that as the whole
covered region. No percentage of the window, budget token or new dp constant
stands in for it; the only fixed values left are platform ones (the minimum
touch target and the leading gesture inset) plus the identity's own existing
`SPACING_S` padding and the icon's own default size.
- **The active pane's width is the same at every depth — the invariant.**
`coveredEdgesDp` (`ui/components/SlidingPaneStack.kt`) always returns edges that
sum to exactly the region, so `activeStart` is the region and the active pane
measures `hostWidth - region` at depth 1, 2, 3 and 4 alike. Opening another
level only adds an edge *inside* the region; it never widens the region or
resizes or reflows a pane already there. `SlidingPaneStackTest` asserts the sum
is constant across depths (`theCoveredRegionIsTheSameAtEveryDepthSoTheActiveWidthNeverChanges`).
- **The stack reads as a stack, and depth does not consume width.** The nearest
covered level shows its identity. One older level is shown as a thinner edge —
the platform minimum touch target, the thinnest edge that stays tappable after
the leading inset — and every level older than that folds into that edge's
count (`"<n> more"`) instead of spending width on each. When the region cannot
fit the thin older edge as well as a full touch target for the nearest identity
(one identity width is usually less than two touch targets), the older levels
fold into the nearest edge's count rather than being squeezed: nothing is
derived below the platform minimum. Tapping an edge still calls the same
`onPopTo(level)`, closing everything above it.
- **The old token and what replaced it.** `PEEK_BUDGET_DP` was `224.dp` and is
removed, together with `MIN_ACTIVE_PANE_WIDTH_DP` (`320.dp`) and the
`peekBudgetDp`/`peekStripsDp` split of a fixed budget. What replaced it is the
measured compact-identity width above. `PEEK_WIDTH_DP` (`56.dp`) and
`MIN_COVERED_PANE_WIDTH_DP` (`112.dp`) no longer place anything either: they now
only bound which statistics a covered identity shows (see
`paneStatTier`/`visiblePaneStats`) and are documented as such in `Dimens.kt`.
- **The identity carries an icon.** `PaneIdentity` gained an `icon` parameter
drawn above the title at the vector's own default size, so the drawn identity
matches the width that was measured for it. The list, pipeline-detail,
run-detail and stage panes each pass their own glyph.
Evidence (macOS, JDK 17 from Homebrew `openjdk@17`, the cached Gradle 8.11.1
distribution, `ANDROID_HOME=~/Library/Android/sdk`, `--offline`, every command
with `--no-daemon`):
- `gradle :app:testDebugUnitTest :app:assembleDebug --no-daemon --offline
--console=plain` → `BUILD SUCCESSFUL`. The result XMLs total **293 tests, 0
failures, 0 errors, 0 skipped** across 34 files. The rewritten
`SlidingPaneStackTest` pins the invariant and the fold rules: a narrow window
spends nothing, the edges sum to the region at every depth (so the active width
is constant), one covered level keeps the whole identity edge, two covered
levels show the nearest identity plus one thinner older edge, beyond two the
older levels fold into one count edge, a region too small to fit both a thin
edge and the nearest touch target collapses to a single counted edge, the
nearest edge keeps its touch target after the gesture inset, and the edges stay
monotonic and deterministic.
- `app/build/outputs/apk/debug/app-debug.apk` is 18,247,412 bytes, sha256
`77db131cdb2737da64286384e5f7387540b1c87588b89c36bf4c34821f091372`; it was
copied to `~/.local/share/pipelines/data/artifacts/166/1/pipelines-debug-wip-b003872.apk`
(`b003872` = `git rev-parse --short HEAD`; the tree is WIP on top of it).
`curl -I http://10.0.0.249:8080/artifacts/166/1/pipelines-debug-wip-b003872.apk`
returned `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18247412`.
Not verified in this pass: the derived widths on a real window, the stacked look
and the identifiers on the left, the covered area's share of the window, and the
two- and four-level screenshots — all of that is runtime/visual evidence for the
review stages, and the device policy for this brief keeps the implementation to
the build and the unit tests. Four levels are also unreachable in the app itself
(`MasterPane.List/Detail/Stage`, `MAX_PANE_DEPTH = 2`), so the four-level fold is
covered by the pure `coveredEdgesDp` cases rather than by a screenshot.
## Stage sections open as their own pane, not inline (16 Oct 2026)
The reported stage-screen defect was real and, once reproduced, exactly as
described: expanding a section stacked its rows at the top of the section. It is
fixed by opening every stage section as its own pane and by laying a collapsible
body out in one column. `android/` only; nothing in the Pipelines server, its Go
source, the Docker/compose files or the installer was touched, no run was started
from the app, no dependency was added, and every `adb`/emulator command targeted
`emulator-5554` only (never `emulator-5556` or the attached Pixel).
- **The defect and its cause.** Expanding `Stage definition` on the stage screen
drew its fields stacked at the top: the last field's card (`Memory`) sat
directly under the header and every other row (`Type`, `Prompt`, `Outcomes`,
`Model`, …) was hidden underneath it. The section's content lambda emitted one
composable per field (`definition.forEach { StageFieldRow(it) }`) straight into
`CollapsibleSectionBody`'s `AnimatedVisibility`, which lays out a *single*
child: several children were placed on top of each other (all at the section's
origin) instead of one below the next, so the body had the height of its tallest
single row and showed only the last one. Reproduced on the pre-change tree
(below).
- **Sections are panes.** A stage section is no longer expanded in place. The
stage screen keeps a **compact list** of section rows (`Artifacts`, `Output`,
`Input`, `This run`, `Stage definition`) and tapping one opens that section as
the next pane of the stack — a full-window screen on a narrow window, a panel
to the right of the stage pane on a wide one — with its own `Scaffold`/
`TopAppBar` named for the section, its own scroll and its own top spacing.
Back (the app bar, the gesture or a peek) returns exactly one level, to the
stage screen. `MasterPane` gained the `Section` level (`MAX_PANE_DEPTH = 3`)
and `PaneSelection.sectionKey` (a primitive saved with the pane selection), so
the open section survives rotation and process death and the wide covered peeks
fold (`"2 more"`) as the fourth pane is added.
- **No trivial inline exceptions.** None of the five sections is kept inline.
Each can hold an arbitrarily long value — the definition's prompt/output
contract, the input/output maps, the run evidence and the artifacts gallery —
so an inline body would both risk the layout with many rows and push the
operator's run context off screen; one uniform rule keeps the screen
predictable.
- **The shared body fix.** `CollapsibleSectionBody` now lays its content out in a
single full-width `Column`, so *any* collapsible section with more than one row
(it also backs the run/pipeline detail `collapsibleSection` lists) stacks its
rows under the header instead of overlapping them.
- **Semantics kept.** Sections start collapsed; the operator's choice (which
section is open, and the visit) is saved with the pane selection; and each
section's content is derived from the same `stageSectionSpecs`
(`runStepFields`, `stageDefinitionFields`, `ArtifactsSection`) as before, so
nothing shown changed — the stage screen just lists the sections and the
section pane shows one.
- **Shared derivation.** `stageSectionSpecs(stageKey, graph, runSteps,
visitIndex, runContext)` is the one pure list of sections (key, title, fields,
artifacts) the stage screen and the section pane both read, so the two can
never disagree; `StageVisitTabs` is the one visit tab row both use; and
`StageSectionPane`/`StageSectionBody` render a section (the artifacts section
keeps the shared `ArtifactSelectionScaffold`, so its gallery retains
long-press selection, the contextual bar and Back-leaves-selection-first).
Evidence (macOS, Homebrew JDK 17 `openjdk@17`, Gradle 9.7.1,
`ANDROID_HOME=~/Library/Android/sdk`, `--offline`):
- `gradle :app:assembleDebug :app:testDebugUnitTest --offline --console=plain` →
`BUILD SUCCESSFUL`; the 30 result XMLs aggregate to **262 tests, 0 failures, 0
errors, 0 skipped** (the updated `PaneStateTest` section-level/`backStep`/
`popTo` cases and the `StageDetailSheetTest` `stageSectionSpecs` cases
included). `app/build/outputs/apk/debug/app-debug.apk` is **18,011,393 bytes**,
sha256 `5912d38fef80aa8aad53132ac5bb1e05fd42fdb9d0ae778e7dc0a1af732e4019`.
- `gradle :app:lintDebug --offline` → the same **2 pre-existing** `NewApi` errors
for `android:windowLightNavigationBar` in `res/values/themes.xml` and
`res/values-night/themes.xml` (unchanged by this pass); no error is attributed
to a changed file.
- On `emulator-5554` only (fold AVD; wide `wm size reset` = 2076x2152 / 390dpi ≈
852dp, narrow `wm size 1080x1920` / `wm density 480` ≈ 360dp; never the
attached Pixel, never `emulator-5556`) against the live server, driving run
145's `implementer` from a Timeline row; every frame was captured and validated
with `scripts/capture_png.sh -s emulator-5554` into
`~/.local/share/pipelines/data/artifacts/144/1/`:
- **Before** (the pre-change tree rebuilt from `HEAD`): `before-wide-stage-sections.png`
then `before-wide-definition-inline.png` — tapping `Stage definition` shows the
overlap defect (the `Memory` card under the header, the other rows hidden).
- **After**: `after-wide-stage-sections.png` (the compact list, every row
chevron-right/collapsed), `after-wide-section-opened.png` (the `Stage
definition` panel to the right of the stage pane, peeks `Back to run`/
`Back to stage`), `after-wide-artifacts-opened.png` (the `Artifacts` pane from
the same list), `after-narrow-section-opened.png` (full-window `Stage
definition`, its own title/scroll/spacing) and `after-narrow-stage-sections.png`
(Back returned to the compact stage screen). The narrow section pane was
reached by opening it wide and folding the window, which exercises the saved
section surviving the configuration change.
- `adb -s emulator-5554 shell input keyevent 4` from the section pane returned to
the stage screen (the compact rows reappear, no `Back to stage` strip); no run
was started from the app; `wm size`/`density` were reset afterwards.
- **APK publish.** `app-debug.apk` copied to
`~/.local/share/pipelines/data/artifacts/144/1/pipelines-debug-wip-c700b28.apk`
(`c700b28` = `git rev-parse --short HEAD`; the working tree is uncommitted WIP on
top of it). `curl -I
http://10.0.0.249:8080/artifacts/144/1/pipelines-debug-wip-c700b28.apk` returned
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18011393`; a streamed `GET | shasum -a 256` returned the same
`5912d38f…`. At 17.2 MiB it exceeds the 8 MiB per-file inventory cap, so it is
served by direct URL only.
Not verified in this pass: a clean `logcat` sweep was not conclusive because the
emulator was shared — installs this pass did not issue appeared in the log during
the sweep and the UI moved between commands. The one `FATAL EXCEPTION` present was
the `uiautomator` dump tool itself (`com.android.commands.uiautomator`), never
`net.awan.pipelines`. The artifacts section was captured for a visit that recorded
none (`Artifacts · not recorded for this visit`) rather than the populated
gallery (the same gallery branch is covered by the run-summary grid); the wide
fold indicator (`"2 more"`) was present but is not separately cropped.
## One artifacts gallery everywhere, with a type icon for non-media (16 Oct 2026)
The gallery was already a grid, but only for images: non-image artifacts fell
through to a plain one-per-row list beneath it, so the same run rendered two
different ways. This pass makes `ArtifactGallery` the single rendering path for
every artifact (the run summary and the stage pane's per-visit section already
both use it) and gives non-media files a tile too. `android/` only; no
dependency was added (the new glyphs are `material-icons-extended`), no run was
started from the app, and every `adb` command targeted `emulator-5554` (never
`emulator-5556` or the attached Pixel).
- **One tile, two shapes.** `ui/graph/Artifacts.kt`'s `ArtifactTile` replaces the
old `ArtifactTile` + `ArtifactRow` split. An image fills the cell with its
thumbnail; a video shows its still/poster frame with a centred play marker on
top; anything else shows its file-type icon with the artifact's name and
human-readable size beneath it, all in the same width-derived grid. The grid is
still built from non-lazy chunked `Row`s, so it never nests a scrollable inside
the Summary `LazyColumn` or the pane's scroll.
- **Type-to-icon mapping.** The new pure `ui/graph/ArtifactType.kt` classifies an
artifact from its content type (parameters tolerated) and, when the server's
sniff is generic, its name's extension, into `ArtifactKind`
(Image/Video/Audio/Pdf/Json/Archive/Spreadsheet/Log/Code/Document/Other), and
`artifactIcon(kind)` gives each kind a distinct shape (PDF, JSON, archive,
spreadsheet, log, code, document, audio, generic file). `Format.kt` gained the
companion `isVideoContentType` predicate beside `isImageContentType`.
- **Video poster frame.** `ui/graph/ArtifactImage.kt` gained
`ArtifactVideoFrame`/`rememberArtifactVideoFrame`: the artifact's bytes are
fetched through the same bounded cache as an image and the representative sync
frame is extracted with the platform `MediaMetadataRetriever` over an in-memory
`MediaDataSource` (no temp file, no new dependency, no inline playback). The
full-screen viewer takes a `video` flag and shows that frame (its open action
plays the clip externally); a fetch/extraction failure falls back to the video
glyph rather than a fabricated image.
- **Actions kept.** Tap opens the viewer for an image/video and the existing
external-open action for anything else; every tile keeps its share control, a
non-media tile adds the copy-link control, and long-press / multi-select, the
contextual bar, bulk copy/share and the selection semantics are unchanged.
The capture summary and partial-capture notes are byte-for-byte unchanged.
- **Geometry from tokens, not literals.** `ui/theme/Dimens.kt` gains
`ARTIFACT_TYPE_ICON_DP` (28dp), `ARTIFACT_PLAY_BADGE_DP` (32dp) and
`ARTIFACT_TILE_ACTION_DP` (32dp); the tile still stretches `ARTIFACT_TILE_DP`
cells across the measured width via the unchanged pure `artifactGrid`.
Review follow-up (same pass, no UI change): the two preview state-holders
duplicated the whole memoize-through-caches scaffold, so it is now one private
`rememberArtifactPreview(url, maxDim, keyTag, fetchBytes, derive)` that both
`rememberArtifactBitmap` and `rememberArtifactVideoFrame` delegate to (the
`keyTag` keeps the two cache entries apart); the video fallback draws
`artifactIcon(ArtifactKind.Video)` instead of a hardcoded `Icons.Filled.Movie`;
and the now-unused `Format.kt` `artifactMetaLine` helper (its last caller was the
deleted non-image row) was removed with its `FormatTest` cases.
Verified on this tree (macOS, Homebrew `openjdk@25`,
`JAVA_HOME=/opt/homebrew/opt/openjdk@25/libexec/openjdk.jdk/Contents/Home`,
Gradle 9.7.1, `ANDROID_HOME=/Users/alan/Library/Android/sdk`, `--offline`):
- `gradle --offline :app:testDebugUnitTest --rerun-tasks` → `BUILD SUCCESSFUL`;
the 31 test-result XMLs aggregate to **265 tests, 0 failures, 0 errors, 0
skipped** (the new `ui/graph/ArtifactTypeTest` has 6 cases: the media kinds
from the content type, the named kinds, the extension fallback for a generic
sniff, the never-crash `Other` fallback, the explicit type-to-icon mapping, and
that no two kinds share a glyph). `ArtifactGalleryTest` still covers the grid
sizing (narrow → fewer, larger cells; wider → more preferred-shaped columns;
degenerate inputs). `compileDebugKotlin` emits no warnings.
- `gradle --offline :app:assembleDebug --rerun-tasks --no-build-cache` succeeded
→ `app-debug.apk` **18,011,393 bytes**, sha256
`faa9df077c960b23eef4afbac1b7effa1a50180eabcee2d638cabb232974cfa8`.
- On `emulator-5554` (native 2076x2152 @390; `wm size`/`wm density` used for the
narrow pass and reset afterwards) against the live server
`ws://10.0.2.2:8080/connect`, driven with `adb shell input` and `uiautomator
dump`; every capture was written with
`android/scripts/capture_png.sh -s emulator-5554` (validated PNG, named display
id) into `…/artifacts/140/1/`. Run 136's `implementer` visit 1 is a real mixed
set: five `image/png` screenshots plus `chat_stub_approval.py`
(`text/plain`, code glyph) and `stub.log` (`text/plain`, log glyph).
- **Wide** (2076x2152 ≈ 532dp): `evidence_wide_run136_summary_gallery.png`
shows the five thumbnails with their share controls and, in the same grid,
the `.py` tile with the `<>` code glyph and the `.log` tile with the log
glyph, each with its name and `9.3 KiB` / `220 B` beneath it and the copy +
share actions; `evidence_wide_run136_stage_pane.png` shows the same gallery in
the stage pane under the unchanged `Artifacts · 7 recorded · partial capture`
wording and the `1 files excluded from artifact capture.` note.
- **Narrow** (1080x2340 @480 ≈ 360dp):
`evidence_narrow_run136_summary_gallery.png` and
`evidence_narrow_run136_stage_pane.png` show three cells per row with the
thumbnails and the code/log type tiles still legible.
- Tapping a thumbnail opened the full-screen viewer
(`evidence_wide_run136_image_viewer.png`; `uiautomator dump` reported the
`01_approval_pending.png` image plus `Open … externally`, `Copy link …` and
`Close viewer`), and the non-media tiles' `Copy link to …` / `Share …`
controls are present in the accessibility tree.
- `adb -s emulator-5554 logcat -d | grep -cE 'FATAL EXCEPTION|E
AndroidRuntime'` returned 0; the emulator display was reset to native
2076x2152 @390 afterwards.
- **APK publish.** `app-debug.apk` copied to
`…/artifacts/140/1/pipelines-debug-wip-c700b28.apk` (`c700b28` = short
`HEAD`); `shasum -a 256` matched. `curl -I
http://10.0.0.249:8080/artifacts/140/1/pipelines-debug-wip-c700b28.apk`
returned `HTTP/1.1 200 OK`, `Content-Type:
application/vnd.android.package-archive`, `Content-Length: 18011393`, and a
streamed `GET | shasum -a 256` returned the same `faa9df07…` as the local file.
At ~17.2 MiB it exceeds the server's 8 MiB per-file inventory cap, so it is
served by direct URL only.
Not verified in this pass: a **video** artifact does not exist on the live server
and starting a run is forbidden, so the play-marker/poster-frame render is
covered only by the `artifactKind` unit test (`video/mp4 → Video`) and the code
path, not by a device capture; the non-media external-open tap was not driven
(no handler is guaranteed on the emulator); multi-select/bulk share were not
re-exercised on device (their code is unchanged from the previous pass); the
light theme and `:app:lintDebug` were not run (the only known lint issues are the
two pre-existing `NewApi` errors for `android:windowLightNavigationBar`).
### Review fixes (same pass)
The review's three findings were addressed with no intended UI change, and the
two build checks were re-run on the resulting tree:
- `gradle --offline :app:testDebugUnitTest --rerun-tasks` → `BUILD SUCCESSFUL`;
the 31 result XMLs again aggregate to **265 tests, 0 failures, 0 errors, 0
skipped** (the removed `artifactMetaLine` assertions were replaced by
`isVideoContentType` coverage in the same `FormatTest` method).
- `gradle --offline :app:assembleDebug --rerun-tasks --no-build-cache` succeeded
→ `app-debug.apk` **18,011,393 bytes**, sha256
`2adaf03e5ac0bdb29b012d1487a0e10917f8ebabda973ddc63c7315b6df25dda`; it was
published to `…/artifacts/140/3/pipelines-debug-wip-c700b28.apk` and
`curl -I http://10.0.0.249:8080/artifacts/140/3/pipelines-debug-wip-c700b28.apk`
returned `HTTP/1.1 200 OK`, `Content-Length: 18011393`, with a streamed
`GET | shasum -a 256` matching the local `2adaf03e…`.
The device render was **not** re-captured: `emulator-5554` is shared and, while
this pass ran, another lane replaced the installed app with a build whose dex has
no `ArtifactType` class (`dumpsys package … lastUpdateTime` moved from this pass's
`16:24:02` install to `16:24:20`, and the installed `base.apk` sha no longer
matched `2adaf03e…`), so any capture could not be attributed to this build. The
wide/narrow captures above predate the refactor; the refactor changes no UI
pixels, so they remain representative of the gallery this code renders.
## Collapsible artifacts gallery in the run summary (16 Oct 2026)
The artifacts gallery led the run summary but was always open, so a long run's
grid pushed the run's own facts below the fold. It is now one
collapsed-by-default section in the same place. `android/` only; no dependency
was added (the chevron is the existing `material-icons-extended`
`KeyboardArrowDown` the shared `SectionHeader` already uses), no run was started
from the app, and every device command targeted the operator's Pixel 10 Pro Fold
(`58281FDCG000JF`), never an emulator.
- **One collapsed section, same place.** `RunDetailScreen.kt`'s `RunSummaryTab`
renders the gallery through the shared `LazyListScope.collapsibleSection`,
keyed `"artifacts"` and seeded with `rememberSectionExpansion(run.id)`, so a
run opened fresh starts collapsed and the operator's expand/collapse choice
survives Summary↔tab switches, configuration changes and rotation exactly like
every other section. The order is unchanged: the artifacts section still leads
the summary and the facts item follows it.
- **A self-describing header.** The new pure `runArtifactsHeader(steps,
executing)` (`ui/ArtifactGroups.kt`) builds the header text — the title (its
singular form for exactly one artifact), how many the run recorded, and
`· partial capture` when any visit excluded or omitted files; with no artifacts
it reuses the shared `artifactsEmptyMessage`. Its count is exactly
`runArtifactGroups`'s tile total, so the header and the expanded gallery can
never disagree.
- **The gallery itself is unchanged.** Expanding composes the same
`ArtifactGallery` (the width-derived thumbnail grid, tap for full size, the
non-media tiles with name, size and content type plus their open/copy/share
actions); collapsing composes nothing. The stage pane's per-visit artifacts
section and every other summary section are untouched.
Evidence (macOS, JDK 17 from Homebrew `openjdk@17`, Gradle 8.11.1 from the
wrapper cache, `ANDROID_HOME=/Users/alan/Library/Android/sdk`, `--offline`,
every Gradle command with `--no-daemon`):
- `gradle --no-daemon --offline :app:testDebugUnitTest` → `BUILD SUCCESSFUL`; the
test-result XMLs aggregate to **269 tests, 0 failures, 0 errors, 0 skipped**.
`ArtifactGroupsTest` gained `headerReportsTheCountWithASingularTitleForOne`,
`headerAddsPartialCaptureOnlyWhenFilesWereExcludedOrOmitted`,
`headerEmptyCaseUsesTheSharedEmptyWording` and
`headerCountMatchesTheGalleryRecordedTotal`.
- `gradle --no-daemon --offline :app:assembleDebug` → `app-debug.apk`
**18,011,393 bytes**, sha256
`c5655269e490db34cbacccf68eaec468a3a41c46c661b41e6ad2d92295235247`; installed
with `adb -s 58281FDCG000JF install -r`, and the pulled `base.apk` sha matched
the local build, so the captures below are attributed to this exact build.
- Run **136** (pipeline id 11 v1, `succeeded`, 17 artifacts) on the Pixel:
- **Wide** (inner display, 2152×2076 @330 ≈ 1043dp):
`summary_wide_collapsed.png` shows the summary led by a lone collapsed
`Artifacts · 17 recorded · partial capture` header (right chevron) with the
run's facts immediately below and no gallery; `summary_wide_expanded.png`
shows the same header expanded to the unchanged gallery — the
`implementer · visit 1` and `ui_reviewer · visit 1` groups of image
thumbnails plus the `chat_stub_approval.py` (`<>` code glyph) and `stub.log`
(log glyph) tiles with their names, `9.3 KiB`/`220 B` sizes and share/copy
actions.
- **Narrow** (`wm size 1080x2152` on the inner display ≈ 524dp, reset to the
native size afterwards): `summary_narrow_collapsed.png` and
`summary_narrow_expanded.png` show the same collapsed header and, expanded,
the same gallery re-flowed to four cells per row (wide uses five).
- **Persistence.** `uiautomator dump` reported `Artifacts · 17 recorded ·
partial capture, collapsed` on a freshly opened run; toggling it and
round-tripping Summary → Graph → Summary, and a `wm size` configuration
change, both kept the operator's expanded/collapsed choice.
- `adb -s 58281FDCG000JF logcat -d | grep -cE 'FATAL EXCEPTION|E
AndroidRuntime'` returned 0; the screen stayed awake (`svc power stayon usb`
+ `KEYCODE_WAKEUP`) and every capture used `screencap -p -d <display-id>` +
`adb pull`. Screenshots, `uiautomator` dumps and the APK are in
`…/artifacts/155/1/`.
- **APK publish.** `app-debug.apk` copied to
`…/artifacts/155/1/pipelines-debug-wip-95150c7.apk` (`95150c7` = short `HEAD`;
the working tree is uncommitted WIP on top of it); `shasum -a 256` matched.
`curl -I http://10.0.0.249:8080/artifacts/155/1/pipelines-debug-wip-95150c7.apk`
returned `HTTP/1.1 200 OK`, `Content-Type:
application/vnd.android.package-archive`, `Content-Length: 18011393`.
Not verified in this pass: no device capture exercises the empty or the
single-artifact header wording (both are covered by the `runArtifactsHeader`
unit tests); the narrow window was produced with a `wm size` override on the
inner display rather than a physical fold, then reset; `:app:lintDebug` was not
re-run (its only known findings remain the two pre-existing `NewApi` errors for
`android:windowLightNavigationBar`).
## Run title beside the pipeline name (16 Oct 2026)
A run now shows the operator's title for the goal, with the pipeline it ran on as
the secondary line, so two runs of the same pipeline are distinguishable.
`android/` only; no dependency was added, no run was started from the app, and no
device command was run (build + unit tests only).
- **Protocol.** `data/protocol/Message.kt` gains an optional `title` on both
`RunSummary` and `RunDetail` (the server's `RunSummary.title`). It is nullable
and defaults to absent, so a server that does not send it degrades cleanly.
- **One shared fallback.** New `ui/RunIdentity.kt` holds `runLabel(title, name)`
(mirroring the server's `RunSummary.Label`) and `runIdentity(title, name)`: the
label is the title, or the pipeline name when the title is absent/blank, and the
pipeline is a second line only when a title exists — never an empty line.
- **Runs list.** `RunHistoryScreen.RunRow` shows the label as the primary line and,
only for a titled run, the pipeline name plus its version chip on a second line;
an untitled run keeps the pipeline name and version chip as its single identity
line. The status chip, progress, id/start/duration line and diagnostic are
unchanged.
- **Run detail + stage panes.** The run detail app bar and the Summary lead with
the label and, when titled, name the pipeline (`name · vN`) on a second line; the
covered peek uses the label too. `StageDetailPane` takes an optional `runLabel`
and shows it under the stage name, so a stage/visit pane keeps the run context.
- **Renaming is not offered.** The authoritative server does not expose it: it has
no `set_run_title` command and `list_runs`/`get_run` return no `title` field, so
the app does not fake a rename. The protocol field is parsed for the server that
does send it; until then the title falls back to the pipeline name.
Evidence (macOS, JDK 17 from Homebrew `openjdk@17`, Gradle 8.11.1 from the wrapper
cache, `ANDROID_HOME=/Users/alan/Library/Android/sdk`, `--offline`, `--no-daemon`):
- `:app:testDebugUnitTest` → `BUILD SUCCESSFUL`; the 32 result XMLs aggregate to
**276 tests, 0 failures, 0 errors, 0 skipped**. The new `RunIdentityTest` (5
cases) covers the title/fallback/trim logic, and `ProtocolModelTest` gained a
case for a present and one for an absent title on both the run summary and the
run detail.
- `:app:assembleDebug` → `app-debug.apk` **18,257,214 bytes**, sha256
`bce661069b2bd013f0802545402766a3ae8fed97e1bbe0109f81a4bfb6233601`.
- Server capability probe (read-only, through the installed CLI):
`pipelines runs` and `pipelines rpc '{"type":"get_run","run_id":155}'` return no
`title` field, and the running `pipelines-server` binary contains no
`set_run_title` string. So renaming is deliberately not offered and the title
falls back to the pipeline name until a server carrying the field is deployed.
- **APK publish.** `app-debug.apk` copied to
`…/artifacts/162/1/pipelines-debug-wip-e1c531a.apk` (`e1c531a` = short `HEAD`;
the working tree is uncommitted WIP on top of it); `shasum -a 256` matched.
`curl -I http://10.0.0.249:8080/artifacts/162/1/pipelines-debug-wip-e1c531a.apk`
returned `HTTP/1.1 200 OK`, `Content-Type:
application/vnd.android.package-archive`, `Content-Length: 18257214`.
Not verified in this pass: device captures of the runs list and run detail (the
visual review owns the device); no server that actually sends `title` was
available, so the titled layout is exercised by the unit tests and the fallback
path only.
## Stage verdict atop the stage pane, with clickable artifacts (16 Oct 2026)
A completed run visit now leads its stage pane with the server's derived verdict:
the chosen option as a badge, the concise reason in ordinary body text, and the
recorded artifacts the reason names as inline, tappable references plus the same
references as compact chips. `android/` only; nothing in the Pipelines server, its
Go source, the installer or the Docker files was touched, no run was started from
the app, and no device command was run (build + unit tests only).
- **Protocol.** `data/protocol/Message.kt` gains `StageVerdict` and an optional
`verdict` on `RunStep`, mirroring `internal/protocol/verdict.go`
(`{option, reason, reason_source, artifacts}` under the `verdict` wire name). It
is nullable and defaults to absent, so a running step or a pre-verdict server
parses cleanly to null.
- **One block.** New `ui/graph/StageVerdict.kt` holds the pure helpers and the
composable. `StageVerdictBlock` is rendered at the top of the run pane, below the
visit tabs and above the facts, only when the server reported a verdict; a null
verdict (or one with neither option nor reason) draws nothing — never an empty
heading or placeholder.
- **Badge.** The option is a `ColoredChip` in the *stage outcome's* existing colour
(`outcomeColor(step.outcome)`, the graph's palette the Timeline chips already
use), so the badge agrees with the graph rather than a new colour vocabulary.
- **Reason.** Rendered with `pipelinesText().body`, so it is readable plain
language, never a monospace JSON dump, and it wraps with no `maxLines` clip.
- **References.** `referencedVerdictArtifacts` resolves the verdict's referenced
names to the visit's recorded artifacts (recorded order, deduplicated, an
unrecorded/invented name dropped). `verdictReasonSegments` splits the reason
around those names — by full recorded name or basename, longest match first — and
the segments become inline `LinkAnnotation.Clickable` references coloured
`primary` with an underline. An image/video reference opens the shared
`ArtifactViewer`; anything else goes through the existing `openArtifact` action.
The same references are `FlowRow` chips (`VerdictArtifactChip`) with their type
glyph, so they can be tapped without hunting in the sentence.
- **Geometry.** Only existing tokens (`SPACING_M`/`SPACING_S`/`SPACING_XS`,
`ICON_STATUS_DP`); no new `dp`/`sp` literal and no new dependency.
Evidence (macOS, JDK 17 from Homebrew `openjdk@17`, Gradle 8.11.1 from the wrapper
cache, `ANDROID_HOME=/Users/alan/Library/Android/sdk`, `--no-daemon`):
- `:app:testDebugUnitTest` → `BUILD SUCCESSFUL`; the result XMLs aggregate to
**282 tests, 0 failures, 0 errors, 0 skipped**. New `StageVerdictTest` (5 cases:
split around every referenced name, basename for a slashed path, longest match
wins, a reason with no references, and name→recorded-artifact resolution) and
`ProtocolModelTest#runStepVerdictParsesWithItsReasonSourceAndReferencedArtifacts`.
- `:app:assembleDebug` → `app-debug.apk` **18,270,824 bytes**, sha256
`85847c6fe32498f38464741ca1b8f592dbbd7a9e1f34dd649121e723836b0903`.
- **APK publish.** `app-debug.apk` copied to
`~/.local/share/pipelines/data/artifacts/167/1/pipelines-debug-wip-8b0d7b1.apk`
(`8b0d7b1` = short `HEAD`); `shasum -a 256` matched. The LAN URL
`http://10.0.0.249:8080/artifacts/167/1/pipelines-debug-wip-8b0d7b1.apk` returned
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18270824`.
Not verified in this pass: device captures of the stage pane at a narrow and a wide
window (the visual review owns the device, per the brief's device policy), so the
verdict layout is exercised by the unit tests and the compile only. No server that
actually sends `verdict` was available to the implementer, so the block's live
rendering against real data is deferred to visual review.
## One search: the pipelines list drops its inline field (16 Oct 2026)
The pipelines list carried its own "Search pipelines" text field while the app
also has the omni search (the destination pill's Search entry point), so the list
offered a second, narrower way to do the same job. The inline field is gone and
name narrowing moved into the list's filter control, keeping "filters narrow one
list" separate from "search finds things across the system".
- **One field removed.** `PipelineListScreen` no longer owns a `query` state or
draws the `OutlinedTextField`; the list is now the first thing under the app
bar, so no spacer stands in for the field that used to sit there.
- **Name is a filter.** `PipelineFilters` gained a free-text `name` facet beside
`presence`/`lastRunStatuses`, applied by `filterPipelines` through the new
`pipelineMatchesName` (case-insensitive `contains`, blank means any). Unlike the
run facets it needs no run history, so it narrows as soon as the pipelines load
while the run facets still wait for `runsKnown`.
- **In the menu.** `PipelineFilterControl` opens with a `Name` section holding a
single-line `PipelineNameFilter` (label "Pipeline name contains") that keeps the
menu open while typing; the shared Clear filters resets it with the run facets
and the active-count badge counts it.
- **Persisted.** `SettingsRepository`/`AppViewModel` store the name under
`pipeline_filter_name` like the other facets, so a restart remembers it.
- **Runs list unchanged.** The runs list never had an inline search field, so
nothing was removed there.
- **Geometry.** No new `dp`/`sp` literal and no percentage: the field reuses
`SPACING_M`/`SPACING_S` and fills the filter menu's own width, and the reclaimed
vertical space comes from the removed field's layout, not a replacement
constant.
Evidence (macOS, JDK 17 from Homebrew `openjdk@17`, Gradle 8.11.1 from the wrapper
cache, `ANDROID_HOME=/Users/alan/Library/Android/sdk`, `--no-daemon --offline`):
- `:app:testDebugUnitTest` → `BUILD SUCCESSFUL`; the 35 result XMLs aggregate to
**312 tests, 0 failures, 0 errors, 0 skipped**. `ListFilterTest` now has 20 cases
(+4: name substring/blank, name before the run history, name AND the run facets,
active count/`hasRunFacets`; `pipelineFiltersFromStorageParsesAndFallsBack` now
covers the name).
- `:app:assembleDebug` → `app-debug.apk` **18,164,618 bytes**, sha256
`375be755d03d17c7721fe5b4ea23f637c928fd48acc300b4aec9f3d3cf2d4e50`.
- **APK publish.** `app-debug.apk` copied to
`~/.local/share/pipelines/data/artifacts/171/1/pipelines-debug-wip-e7c4b8f.apk`
(`e7c4b8f` = short `HEAD`); `shasum -a 256` matched. The LAN URL
`http://10.0.0.249:8080/artifacts/171/1/pipelines-debug-wip-e7c4b8f.apk` returned
`HTTP 200`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18164618`.
Not verified in this pass: device captures (the visual review owns the device, per
the brief's device policy), so the filter-menu name field's on-screen layout is
exercised by the compile and the pure filter tests only.
## Omni-search results panel (16 Oct 2026)
The results panel above the omni-search field was already on the tree (it landed
with the entry point and pill morph, commits `80f7b0a` and `e2147b0`); this pass
verified it against the brief and documents it, because the entry point/pill
section left the panel itself undocumented.
- **Above the input, above the keyboard.** `PipelinesApp` puts the panel and the
destination bar in one bottom-anchored `Column` that clears `paneSafeArea()`
(`WindowInsets.safeDrawing`, which carries the IME and the navigation bar); the
panel takes the remaining height with `weight(1f, fill = false)` and scrolls
its `LazyColumn` inside it, so it is never under the field or the keyboard. The
activity declares `adjustResize` and the app is edge-to-edge, so the Compose
window inset is the only source of the IME geometry and it is applied once,
here (the chat composer likewise reads it once, through `imePadding`).
- **Badge, title, secondary line.** `OmniSearchResults.searchRow` gives every hit
a `pipeline`/`run`/`step`/`artifact`/`match` badge (`searchBadge`, a version hit
reads as `pipeline`), a title and a secondary line; a text ("field") hit's
secondary line is its snippet, split by `snippetSpans` and rendered
bold+underlined for the matched span, so the match is legible without colour.
- **Debounced, no flicker, no stale overwrite.** `AppViewModel` debounces
keystrokes through the pure `SearchSequencer`: a burst collapses to one request
for the last edit, `SearchUiState.editing` keeps the previous results (a thin
progress bar marks the refresh), and `accepts` gates every reply on the newest
sent token, so an older query can never land on top of a newer one.
- **Loading, empty, error.** The first load shows a "Searching…" row; the empty
state names the query (`No matches for "<query>".`); a failure is shown in place
of the results without discarding what was already loaded.
- **Navigation.** Selecting a result resolves through `searchTarget` and closes
the search: a pipeline/version opens the pipeline detail, a run opens the run
detail, a step or artifact opens the recorded visit's stage pane (whose leading
section is the visit's Artifacts gallery), and a text match opens the run-detail
section holding it (`searchFieldSection`). A kind with no known payload resolves
to no target and is shown read-only rather than dropped.
- **Tests.** `OmniSearchResultsTest` covers the badge/row mapping, the snippet
split, the result-to-target mapping for every kind, the run-target resolution
(visit index and section) and the debounce/stale/panel-state transitions;
`OmniSearchTest` covers the field state and its Saver.
Evidence (macOS, JDK 17 from Homebrew `openjdk@17`, Gradle 8.11.1 from the
wrapper cache, `ANDROID_HOME=/Users/alan/Library/Android/sdk`, `--no-daemon
--offline`):
- `gradle :app:testDebugUnitTest :app:assembleDebug --no-daemon --offline
--console=plain --rerun-tasks` → `BUILD SUCCESSFUL in 14s` (41 actionable tasks:
41 executed). The 39 result XMLs aggregate to **349 tests, 0 failures, 0 errors,
0 skipped**.
- `app/build/outputs/apk/debug/app-debug.apk` is **18,126,113 bytes**, sha256
`69e61b9564b5958e21e9b56465a7f1c9c60e29d5767b53fe7549ecfd67db6f8b`.
- **APK publish.** `app-debug.apk` copied to
`~/.local/share/pipelines/data/artifacts/186/1/pipelines-debug-wip-9b9f12f.apk`
(`9b9f12f` = `git rev-parse --short HEAD`); `shasum -a 256` matched. The LAN URL
`http://10.0.0.249:8080/artifacts/186/1/pipelines-debug-wip-9b9f12f.apk`
returned `HTTP/1.1 200 OK`, `Content-Type:
application/vnd.android.package-archive`, `Content-Length: 18126113`.
Not verified in this pass: device frames of the populated panel, the empty result
and a selection navigating (the visual review owns the device, per the brief's
device policy); the panel's pure logic is exercised by the unit tests and the
compile only.
## Chat destination and multiple conversations (16 Oct 2026)
The first Chat slice: the destination, the server session list and several
conversations held open at once. `android/` only; no new dependency (the
`material-icons-extended` icon is the declared one), no Pipelines server/Go/
installer/Docker file touched, no run started from the app, and the operator's
physical device was never used (`emulator-5556` only).
- **Pill.** The floating destination pill gains a Chat icon between Runs and
Settings (icons only, 48dp targets via the named `DESTINATION_ITEM_SIZE`/
`DESTINATION_ITEM_GAP` tokens, one non-wrapping `Row`), so it stays narrow and
clear of the reserved 88dp bottom inset however many destinations it holds.
The Search destination is owned by another lane and is not present on this
base; the pill is built to take it.
- **Brokered protocol.** `data/protocol/Chat.kt` mirrors `internal/protocol/chat.go`
field-for-field (sessions, create, query, prompt, messages/parts, event frames,
permission, reply); `Message` gains the optional `chat_*` payloads and
`PipelinesClient` now forwards *unsolicited* frames (chat_event/chat_permission)
to `events` instead of dropping them. `PipelinesRepository` exposes the typed
chat calls.
- **Multi-chat model.** `ui/chat/ChatStore.kt` is an Android-free state holder:
every open chat keeps its own conversation, running flag, composer draft and
scroll position; `open`/`activate` report when history must be (re-)fetched so
a running session re-syncs on return instead of showing a stale copy; a
server frame is applied to its chat whether or not it is on screen. `busy`
sessions render read-only and the composer refuses to write to them.
- **Surface.** `ui/chat/ChatScreen.kt` reuses the shared adaptive
`SlidingPaneStack` (session list → conversation): the list shows each session's
running/busy/read-only status, an open-chat strip switches between several
conversations in one tap (with an optional X to close one), and the
conversation is a bottom-anchored transcript of user bubbles, secondary
reasoning, assistant text and tool-call chips that expand to INPUT
(pretty-printed JSON) / OUTPUT (monospace, via the shared `CodeBlock`).
"New chat" creates a server session and opens it. Closing a chat *is* provided
(the chip X); it removes only that chat.
- **Messages sent to a chat are optimistic** (the bubble shows immediately); the
live delta/streaming pass is the next slice.
Evidence (macOS, JDK 17, Gradle 9.7.1 `--offline`,
`ANDROID_HOME=/Users/alan/Library/Android/sdk`):
- `gradle :app:assembleDebug :app:testDebugUnitTest --rerun-tasks` →
`BUILD SUCCESSFUL`, **229 tests, 0 failures** (new `MultiChatStateTest`:
switching preserves each conversation, a running session re-syncs on return,
drafts and scroll are per chat, a busy session is read-only, background events
land on their own chat; new `ChatProtocolTest` for the wire shapes; new
`ChatFormatTest`).
- The debug APK was installed on `emulator-5556` (`FoldB_API_36`, narrow
`wm size 1080x2340` @420) and driven with `uiautomator dump`/`input tap`;
captures were validated with `android/scripts/capture_png.sh -s emulator-5556`:
the pill with the Chat destination (`01_pill_chat`), the session list
(`02_chat_list`, `05_chat_list_one_open`, `07_chat_list_two_open`), two chats
with different conversations (`03_chat_alpha` and `06_chat_beta`), a tool chip
expanded to INPUT/OUTPUT (`04_chat_alpha_tool_expanded`), a read-only busy
session with a disabled composer (`08_chat_readonly`) and a per-chat draft
preserved across a switch (`10_draft_preserved`). `adb -s emulator-5556 logcat
-d` held 0 `FATAL EXCEPTION` and 0 `E AndroidRuntime` during the sweep.
- **The deployed Pipelines server predates chat** (verified: a `chat_sessions`
request answers `unknown command: chat_sessions`), and the server-side chat
broker is a separate lane. The on-emulator sweep therefore drove the client
against `chat_stub.py`, a minimal `/connect` WebSocket double that speaks the
exact `internal/protocol/chat.go` JSON, so the screenshots show real client
rendering of the documented wire contract, not the production service.
- **APK publish.** `app-debug.apk` (18,261,008 bytes, sha256
`aa167617c830fd7249eedf457959ef7e99b553769ed4ab82a3af6b4e8cb98ed3`) copied to
`~/.local/share/pipelines/data/artifacts/119/1/pipelines-debug-wip-e5bde98.apk`;
`curl -I http://10.0.0.249:8080/artifacts/119/1/pipelines-debug-wip-e5bde98.apk`
returned `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18261008`; a streamed `GET | shasum -a 256` matched.
Not verified in this pass: the live brokered server (not deployed and out of
this lane's scope), a genuinely running session's re-sync against OpenCode
(covered by the model test, not live), and streaming/stop/approval/attachments,
which are later slices.
### Review follow-ups (16 Oct 2026, implementer pass)
Addressing the reviewer's findings on the slice above, still `android/` only.
- **Shared part upsert (duplication blocker).** `ChatStore.applyDelta` and
`applyTool` were the same message/part upsert twice. Both now call one private
`upsertPart(frame, partId) { existing -> … }`; the delta appends to the existing
text, the tool replaces the part, and neither can drift. `event()` and the new
`permission()` share one `ensureThread()` placeholder creator.
- **Diff cards (task gap).** The research report's edit view (`_CodeRun` /
`_DiffView`, §1.3) is now reproduced: an `edit`-family tool call renders a diff
card. `ChatFormat.toolEditDiff` derives an LCS line diff from the arguments'
`oldString`/`newString` — the brokered protocol has **no** diff field (research
§2.5), so it is synthesised, never silently dropped. The collapsed chip shows
the file and the `+N -M` stat; expanding shows the green/red monospace lines
(the app's own success/failure hues, not new literals).
- **One read-only rule (divergent code).** `sessionReadOnly` was dead (only its
own test called it) and disagreed with the UI's `ChatThread.readOnly = busy` for
a locally-running busy session. The helper is deleted and `ChatThread.readOnly`
is now `busy && !running`, the same precedence `sessionStatusLabel` uses: a turn
we started is `Running` and writable, not read-only.
- **`chatReply` / approval now reachable (unused API).** `observeChatEvents`
forwards `chat_permission` into `ChatStore.permission` instead of dropping it,
the conversation shows an approval bar (action, resources, Allow once / Always /
Deny) and `AppViewModel.replyChatPermission` answers through `chatReply`.
- **Stop control fixed (found while tracing read-only).** While a turn ran the
composer's red stop button was wired to `onSend`, so it sent the draft instead
of interrupting; it now calls `stopChat`.
- **Evidence gap closed.** The previous checklist cited `09` (new chat) but no
`09_*` file existed; this pass captures `09_new_chat.png` (the New-chat
conversation), plus `11_diff_card.png` and `12_permission_bar.png` for the two
new surfaces.
Evidence (macOS, JDK 17, Gradle 9.7.1 `--offline`,
`ANDROID_HOME=/Users/alan/Library/Android/sdk`):
- `gradle :app:assembleDebug :app:testDebugUnitTest --offline` → `BUILD
SUCCESSFUL`; the JUnit XML totals **233 tests, 0 failures, 0 errors, 0
skipped** (new `toolEditDiffMarksOnlyChangedLinesAndCountsThem`,
`toolEditDiffIsNullForNonEdits`, `locallyRunningBusyChatStaysWritable`,
`permissionIsStoredUntilAnswered`).
- The debug APK was installed on `emulator-5556` only and driven with
`uiautomator dump`/`input tap`; captures validated with
`android/scripts/capture_png.sh -s emulator-5556`: the new-chat conversation
(`09_new_chat`), the derived diff (`11_diff_card`, showing
`context / - val gap = 4.dp / + val gap = 6.dp / + val inset = 2.dp` under a
`src/layout.kt +2 -1` chip) and the approval bar (`12_permission_bar`). Tapping
**Allow once** cleared the bar through `chat_reply`. `adb -s emulator-5556
logcat -d` held 0 `FATAL EXCEPTION` and 0 `E AndroidRuntime`. Driven against the
test-double stub (the deployed server still predates chat).
- **APK publish.** `app-debug.apk` (18,228,844 bytes, sha256
`db240fc2fc295c5ab50530f9d8cefae908f307a3115b54ce9f6d713e05643b87`) copied to
`~/.local/share/pipelines/data/artifacts/119/3/pipelines-debug-wip-e5bde98.apk`.
Still not verified: the live brokered server (separate lane), streaming against
real OpenCode, and attachments — unchanged from the pass above.
## Conversation markdown rendering (16 Oct 2026)
The assistant's `text` part was rendered as one plain `Text`; it is now rendered
as markdown, matching the reference experience (research report Part 1 §1.2).
`android/` only; no new dependency (still just the declared
`material-icons-extended`), no Pipelines server/Go/installer/Docker file touched,
no run started from the app, and `emulator-5556` only (lane A's `emulator-5554`
was never addressed).
- **Parser.** `ui/chat/Markdown.kt` adds a small, dependency-free CommonMark
subset. It is pure Kotlin (no Compose, no transport) so it is unit-testable:
paragraphs (soft-wrapped lines join with a space), `#`..`######` headings,
fenced code (``` ``` / `~~~`, with the info string as the language), block
quotes, bullet and ordered lists, `|` tables (with a `---` delimiter row),
thematic rules, and inline code / bold / italic / `[label](url)` /
bare-`http(s)://` autolinks. Underscore emphasis needs word boundaries so
`snake_case` is never italicised. Anything outside the subset renders as plain
text, never dropped.
- **Renderer.** The same file turns the blocks into themed, selectable Compose
content: fenced code reuses the shared `CodeBlock`, so the whole-block copy
action is the existing one (label = the fence language, `code` when absent);
tables are a bordered grid with a bold header and equal-weight wrapping cells;
links use `LinkAnnotation.Url`, so they are tap-openable and styled from the
scheme; inline code and headings use the shared type roles
(`pipelinesText()`), not ad-hoc sizes. `ChatScreen.MessagePart` now calls
`MarkdownText(part.text)` for `PART_TEXT`; the assistant message stays one
`SelectionContainer`, so all of it remains selectable and the bounded code
block/table keep long content inside the bubble. Geometry reuses the chat
tokens (`CHAT_ITEM_GAP`, promoted from `private` to `internal`); only the
quote-bar width and table border, which had no token, are new named constants.
Evidence (macOS, JDK 17, Gradle 9.7.1 `--offline`,
`ANDROID_HOME=/Users/alan/Library/Android/sdk`):
- `gradle :app:assembleDebug :app:testDebugUnitTest --offline` → `BUILD
SUCCESSFUL`; the JUnit XML totals **243 tests, 0 failures, 0 errors, 0
skipped** (new `MarkdownTest`: fences keep their language, an unterminated
fence still yields code, soft-wrapped paragraphs join, headings/rules parse by
level, bullet/ordered lists, table header/rows, inline code/bold/italic/link,
bare-URL autolink trims trailing punctuation, `snake_case` is not emphasis,
empty source → no blocks).
- The debug APK was installed on `emulator-5556` only and driven against a
stdlib `/connect` WebSocket double serving a fixed history; capture was
validated with `android/scripts/capture_png.sh -s emulator-5556`:
`chat_markdown_conversation.png` shows the bottom-anchored transcript with the
user bubble, the secondary reasoning line, body markdown with inline code and
an underlined link, a `kotlin` fenced code block with its copy action, and the
bordered `Surface | Role` table. `adb -s emulator-5556 logcat -d` held 0
`FATAL EXCEPTION` and 0 `E AndroidRuntime` during the sweep.
- **APK publish.** `app-debug.apk` (18,076,412 bytes, sha256
`bb290a7f42a3b28e613098dfffea438c34a5332081cffc6a2fbc0d275c207f68`) copied to
`~/.local/share/pipelines/data/artifacts/124/1/pipelines-debug-wip-0718f5b.apk`;
`HEAD` is `0718f5b` and a streamed `curl | shasum -a 256` of
`http://10.0.0.249:8080/artifacts/124/1/pipelines-debug-wip-0718f5b.apk`
matched.
Not verified: the live brokered server (separate lane), streaming against real
OpenCode, and attachments — unchanged from the passes above. The markdown subset
is intentionally smaller than full CommonMark (no HTML, no reference links, no
nested lists, no strikethrough).
## Streaming replies (16 Oct 2026)
The live delta/streaming pass promised by the first slice. `android/` only; no new
dependency (still just the declared `material-icons-extended`), no Pipelines
server/Go/installer/Docker file touched, no run started from the app, and
`emulator-5556` only (lane A's `emulator-5554` was never addressed).
- **Turn lifecycle in the model.** `ChatStore` now owns `ChatThread.runningSince`
and one private `setRunning` transition, so a turn that begins is stamped with
the wall clock and settling clears it; `ChatThread.elapsedMillis(now)` is the one
pure derivation the indicator and its test share. `event` already appended
`text`/`reasoning` deltas to the target part and upserted tool parts, wherever the
frame's chat sits in the open order.
- **Running indicator.** The transcript's indicator shows the spinner, `Working…`
and the live elapsed time (ticked once a second, never per frame, through the
shared `formatDuration`). Its tick loop is keyed on the turn's start and stops the
moment the turn settles, and the elapsed value keeps counting across a chat
switch because it lives on the thread, not the composable.
- **Follow the stream.** The transcript hard-jumps to the newest item while a turn
runs — a fast-growing reply outruns an animation — unless the operator has
scrolled up to read; returning to the end resumes following. Consuming the list
state's `interactionSource.interactions` (`DragInteraction.Start`/`Stop`/`Cancel`)
distinguishes a user drag from the programmatic jump, so the jump never un-sticks
the view.
- **Reconnect resync.** `AppViewModel.observeConnection` re-fetches every open
chat's history whenever the socket transitions to `Connected`, after
`ChatStore.streamResumed()` settles each running thread (a still-live stream
re-asserts `running` on its next frame, so no stale `Working…` sticks). The
resync *replaces* the conversation wholesale, so a gap can neither duplicate nor
drop text.
- **Failure settle.** A server-pushed `error` frame carries no session id (the
brokered protocol cannot attribute it), so `ChatStore.streamError` settles the
sole running chat — or the active one when several are in flight — and keeps the
server's text; with nothing running it is ignored. The prompt-call failure path
already settled the turn and is unchanged.
- **Non-blocking.** Unsolicited frames reach the UI through the client's bounded
`SharedFlow` (`tryEmit` from the socket thread, `DROP_OLDEST` capacity 256), so a
slow collector never blocks the read loop; each mutation touches only its chat and
the `LazyColumn` keys limit recomposition to the changed item.
Evidence (macOS, JDK 17 target, Gradle 9.7.1,
`ANDROID_HOME=/Users/alan/Library/Android/sdk`):
- `gradle :app:assembleDebug :app:testDebugUnitTest` → `BUILD SUCCESSFUL`; the JUnit
XML totals **248 tests, 0 failures, 0 errors, 0 skipped** (new `ChatStreamTest`:
a delta sequence grows the rendered text and toggles the running indicator, the
elapsed time comes from the turn's own start and a repeated start keeps it,
`streamResumed` settles every open chat and returns them for re-fetch,
`streamError` settles the running turn with the server's text and is ignored with
nothing running).
- The debug APK was installed on `emulator-5556` only and driven with
`uiautomator dump`/`input tap` against `.stream_check/stream_stub.py` (a stdlib
`/connect` WebSocket double that streams `chat_event` frames; test scaffolding,
not the app — the deployed server still predates chat). Captures were validated
with `android/scripts/capture_png.sh -s emulator-5556`: a mid-stream reply with
the growing transcript and the indicator at `Working… · 1s`
(`chat_stream_01_early`) and `Working… · 4s` with the list followed to the newest
line (`chat_stream_02_mid`); the settled turn with the completed `bash 340ms`
tool chip, no indicator and the send control restored (`chat_stream_03_settled`);
and, after a mid-stream drag up, the transcript **staying** where the operator
left it while the turn still ran (`chat_stream_04_scrolled_up`). `adb -s
emulator-5556 logcat -d` held 0 `FATAL EXCEPTION` and 0 `E AndroidRuntime`
during the sweep.
- **APK publish.** `app-debug.apk` (18,262,465 bytes, sha256
`ef435b662e6f7e7467b5ae25b69fb24f8904334af204224aad00bfd76879a84e`) copied to
`~/.local/share/pipelines/data/artifacts/126/1/pipelines-debug-wip-d7f6500.apk`;
`curl -I http://10.0.0.249:8080/artifacts/126/1/pipelines-debug-wip-d7f6500.apk`
returned `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18262465`, and a streamed `GET | shasum -a 256` matched.
Not verified in this pass: the live brokered server (separate lane), streaming
against real OpenCode, and attachments — unchanged. `:app:lintDebug` could not run
in this environment: the Gradle JVM reports `25.0.4.1`, a version string the AGP
8.7.2 lint (IntelliJ `JavaVersion`) rejects, so lint fails before analysing the
tree; this is environmental and unrelated to the change.
## Tool-call chips and the expandable panel (16 Oct 2026)
The tool-call surface now matches the reference chat's `_ToolCalls`/`_ToolChip`
and `_buildPanel` (research §1.3) more closely. `android/` only; no new
dependency (still just the declared `material-icons-extended`), no Pipelines
server/Go/installer/Docker file touched, no run started from the app, and
`emulator-5556` only (lane A's `emulator-5554` was never addressed).
- **Grouped chips.** A run of consecutive `tool` parts in one assistant turn is
now one `FlowRow` of compact chips (`ToolCalls`/`ToolChip`), so the turn's calls
sit together and wrap instead of each taking a full-width row. Each chip keeps
its kind icon, label (the edited file for an `edit`), `+N -M` diff stat,
duration and running spinner.
- **Overlay panel, scroll preserved.** Tapping a chip opens its INPUT/OUTPUT
panel as a `Popup` anchored to that chip, not as inline content. The former
inline panel re-flowed the transcript (a short chat visibly jumped); the popup
is outside the list layout, so opening, failing or dismissing it never moves the
conversation's scroll anchor. `ToolPanelPositionProvider` places it below the
chip, flips it above when there is no room, and keeps it inside the window
margins. The panel is dismissible by its own X or by tapping outside, and its
INPUT and OUTPUT blocks carry the shared `CodeBlock` copy action.
- **Visible failure.** An `error` tool call is now unmistakable: an
error-tinted chip with an `ErrorOutline` icon (`toolFailed`), and its panel
shows an ERROR block with the tool's error text (`ChatFormat.toolFailed`).
- **Diff cards preserved.** An `edit`-family chip still expands to the synthesised
green/red diff (`toolEditDiff`/`DiffView`), unchanged.
Evidence (macOS, Gradle 9.7.1 `--offline`, `ANDROID_HOME=/Users/alan/Library/Android/sdk`):
- `gradle :app:assembleDebug :app:testDebugUnitTest --offline` → `BUILD
SUCCESSFUL`; the JUnit XML totals **252 tests, 0 failures, 0 errors, 0
skipped** (new `toolFailedOnlyForTheErrorStatus`, and
`ToolPanelPositionProviderTest`: below-the-chip, flip-above and margin-clamp
placement).
- The debug APK was installed on `emulator-5556` only and driven against
`.tool_calls_check/chat_stub_tools.py` (a stdlib `/connect` WebSocket double
serving the documented `internal/protocol/chat.go` JSON; test scaffolding, not
the app). Captures were validated with `android/scripts/capture_png.sh -s
emulator-5556`: `01_tools_collapsed.png` (the completed `bash 340ms` and
`src/layout.kt +2 -2 300ms` chips grouped), `02_tools_expanded.png` (the bash
chip expanded to INPUT pretty JSON + OUTPUT monospace with the transcript behind
it unmoved — the chips keep the same on-screen position), and
`03_error_chip_collapsed.png`/`04_error_chip_expanded.png` (the failed `shell`
chip in the error container and its panel INPUT + ERROR text). Tapping outside
the panel dismissed it with the chips still in place. `adb -s emulator-5556
logcat -d` held 0 `FATAL EXCEPTION` and 0 `E AndroidRuntime` during the sweep.
- **APK publish.** `app-debug.apk` (18,262,465 bytes, sha256
`160f10ea8a2dc80364bb7f38596d50d08557ccce01f99705b93a8b9bc9216c27`) copied to
`~/.local/share/pipelines/data/artifacts/129/1/pipelines-debug-wip-d7f6500.apk`;
`curl -I http://10.0.0.249:8080/artifacts/129/1/pipelines-debug-wip-d7f6500.apk`
returned `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18262465`, and a streamed `GET | shasum -a 256` matched.
Not verified in this pass: the live brokered server (separate lane), streaming
against real OpenCode, and attachments — unchanged from the passes above.
## Tool-call review fixes (16 Oct 2026)
Two findings from the tool-call slice review, both in `android/`, under the same
constraints as above (no new dependency beyond the declared
`material-icons-extended`, no Pipelines server/Go/installer/Docker file touched,
no run started from the app, `emulator-5556` only).
- **One elapsed derivation.** `ChatScreen.rememberElapsedMillis` re-derived the
running turn's elapsed time by subtracting the start itself, duplicating the
tested `ChatThread.elapsedMillis` and contradicting the two KDocs that claimed
the indicator shared the model's derivation. The composable now ticks a
`rememberElapsedNow(runningSince)` wall clock (once a second, and only while
the turn lives) and reads `thread.elapsedMillis(now)`, so the model and the UI
cannot drift.
- **No per-frame allocation.** `ToolCalls` keyed its open-panel `remember` on
`parts.map { it.id }`, allocating a list on every streaming recomposition. The
key is unnecessary — an id no longer among the calls simply matches nothing —
so `openId` is plain remembered state and a streaming rebuild no longer
allocates a key list.
Evidence (macOS, Gradle 9.7.1 `--offline`,
`ANDROID_HOME=/Users/alan/Library/Android/sdk`):
- `gradle :app:assembleDebug :app:testDebugUnitTest --offline` → `BUILD
SUCCESSFUL`; the JUnit XML totals **252 tests, 0 failures, 0 errors, 0
skipped**.
- The rebuilt debug APK was installed on `emulator-5556` only and driven against
`.tool_calls_check/chat_stub_tools.py` and `chat_stub_error.py` (stdlib
`/connect` WebSocket doubles serving the documented `internal/protocol/chat.go`
JSON; test scaffolding, not the app). Captures were validated with
`android/scripts/capture_png.sh -s emulator-5556` into `.tool_calls_fix/`:
`01_tools_collapsed.png` (the completed `bash 340ms` and `src/layout.kt +2 -2
300ms` chips grouped), `02_tools_expanded.png` (the bash chip's INPUT pretty
JSON + OUTPUT monospace), `04_diff_card.png` (the edit chip's synthesised
green/red diff card), `03_dismissed_outside.png` (tapping outside dismissed the
panel with both chips at the same on-screen bounds), and
`05_error_chip_collapsed.png`/`06_error_chip_expanded.png` (the failed `shell`
chip in the error container, with a `Failed tool call` description, and its
panel INPUT + ERROR text). `adb -s emulator-5556 logcat -d` held 0 `FATAL
EXCEPTION` and 0 `E AndroidRuntime` during the sweep.
- **APK publish.** `app-debug.apk` (18,219,766 bytes, sha256
`b607a879ce2f2ac324fe6fa254918a456337c678abc1781bb79a05d88d539984`) copied to
`~/.local/share/pipelines/data/artifacts/129/3/pipelines-debug-wip-d7f6500.apk`;
`curl -I http://10.0.0.75:8080/artifacts/129/3/pipelines-debug-wip-d7f6500.apk`
returned `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18219766`, and a streamed `GET | shasum -a 256` matched. This
supersedes the `129/1` publish above: it is built from the current source, so
the change is in the served artifact (a fresh rebuild can still differ in
`classes5.dex` — the reproducibility caveat recorded in review stands).
Not verified in this pass: the live brokered server (separate lane), streaming
against real OpenCode, and attachments — unchanged from the passes above.
`:app:lintDebug` still cannot run here (the Gradle JVM's `25.0.4.1` version
string is rejected by AGP 8.7.2 lint), unchanged from the slice above.
## Tool-call review fixes, second pass (16 Oct 2026)
Three findings from the tool-call slice's second review, all in `android/` under
the same constraints (no new dependency beyond the declared
`material-icons-extended`, no Pipelines server/Go/installer/Docker file touched, no
run started from the app, `emulator-5556` only).
- **A failed edit call shows its error.** The panel only rendered the diff for an
`edit`-family call, because the `diff != null` branch sat above the `failed`
check, so a *failed* edit showed no error text. The ERROR block is now emitted
whenever `toolFailed`, alongside the diff when one exists; a failed non-edit call
keeps INPUT + ERROR, and a successful edit still shows the diff alone.
- **The error message, not the partial output.** `ChatFormat.toolOutputText`
returned non-blank `state.content` before it considered `state.error`, and that
text fed the ERROR block, so a failed call carrying both showed its partial
output under the ERROR heading. The failed call's text now comes from the new
`toolErrorText`, which prefers the server's message and falls back to the output
text only when the failure carries none; `toolOutputText` is the OUTPUT
derivation again.
- **README mechanism corrected.** The follow-the-stream bullet claimed a
`snapshotFlow` on the list's scroll state; the code consumes
`listState.interactionSource.interactions` (`DragInteraction.Start`/`Stop`/`Cancel`),
as the bullet now says.
Evidence (macOS, Gradle 9.7.1, `ANDROID_HOME=/Users/alan/Library/Android/sdk`):
- `gradle :app:testDebugUnitTest :app:assembleDebug` → `BUILD SUCCESSFUL`; the
JUnit XML totals **253 tests, 0 failures, 0 errors, 0 skipped** (the failed-text
helper split into `toolOutputFallsBackToNoOutput` and
`toolErrorPrefersTheMessageOverPartialOutput`, which asserts the message wins over
a failed call's partial output).
- The rebuilt debug APK was installed on `emulator-5556` only and driven against
`.tool_calls_fix2/chat_stub_failed_edit.py` (the review tool stub plus a failed
`edit` call with `oldString`/`newString` and a failed `bash` call carrying both
partial output and an error; stdlib `/connect` WebSocket double, test
scaffolding, not the app). Captures were validated with
`android/scripts/capture_png.sh -s emulator-5556` into `.tool_calls_fix2/`:
`04_failed_edit_expanded.png` shows the failed edit chip's diff *and* its ERROR
block (`oldString not found in src/layout.kt`), and
`06_failed_bash_expanded.png` shows the failed bash call's INPUT + ERROR
(`exit status 2: src/nope.kt: No such file`), the error text — not the partial
output — under the ERROR heading. `uiautomator dump` confirms the same nodes;
`adb -s emulator-5556 logcat -d` held 0 `FATAL EXCEPTION` and 0 `E
AndroidRuntime` during the sweep.
- **APK publish.** `app-debug.apk` (18,219,360 bytes, sha256
`4522aa62c8a3a59033aa2cca8b7fba65267dbdde473284585eaae47f03aeda2f`) copied to
`~/.local/share/pipelines/data/artifacts/129/5/pipelines-debug-wip-d7f6500.apk`;
`curl -I http://10.0.0.249:8080/artifacts/129/5/pipelines-debug-wip-d7f6500.apk`
returned `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18219360`, and a streamed `GET | shasum -a 256` matched. This
supersedes the `129/3` publish above: it is rebuilt from the current source, so
the fix is in the served artifact (the `classes5.dex` reproducibility caveat
recorded in review stands).
Not verified in this pass: the live brokered server (separate lane), streaming
against real OpenCode, and attachments — unchanged from the passes above.
## Edit diffs: file name, stat and large-edit summarisation (16 Oct 2026)
The edit diff card already derived its lines, but three things the task calls for
were missing or wrong. `android/` only; no new dependency (still just the declared
`material-icons-extended`), no Pipelines server/Go/installer/Docker file touched,
no run started from the app, and `emulator-5556` only (lane A's `emulator-5554`
was never addressed).
- **The file name and `+N -M` are on the card, not just the chip.** The expanded
panel header showed the tool name (`edit`); it now shows the edited file (as the
chip already did) and the shared green/red `DiffStat`, so the diff names its file
and its counts wherever it is read.
- **Very large edits are summarised, not flooded.** A diff longer than
`MAX_RENDERED_DIFF_LINES` (200) kept *every* line — the >400-line fallback
rendered `old + new` in full, thousands of `Text` nodes in a scrolling `Column`
on a phone. `ChatFormat.toolEditDiff` now keeps the first 200 lines and carries
the rest in the new `ToolDiff.omitted`; `DiffView` prints
`… N more changed lines not shown` **first**, so the truncation is visible
without scrolling. The `+N -M` counts still describe the whole edit, never the
rendered prefix.
Evidence (macOS, JDK 17, Gradle 9.7.1 `--offline`,
`ANDROID_HOME=/Users/alan/Library/Android/sdk`):
- `gradle :app:testDebugUnitTest :app:assembleDebug` → `BUILD SUCCESSFUL`; the
JUnit XML totals **254 tests, 0 failures, 0 errors, 0 skipped** (new
`toolEditDiffSummarisesAnOversizedEditInsteadOfRenderingEveryLine`, which
asserts the true `+250 -250` counts, the 200-line render cap and
`omitted = 300`; the small-edit test now also pins `omitted = 0`).
- The rebuilt debug APK was installed on `emulator-5556` only and driven against
`.diff_check/chat_stub_diff.py` (the `.tool_calls_check/chat_stub_tools.py`
`/connect` WebSocket double plus a 300-line edit whose intersection with the
cap must summarise; stdlib double, test scaffolding, not the app). Captures were
validated with `android/scripts/capture_png.sh -s emulator-5556`:
`03_diff_small.png` shows the small edit card — `src/layout.kt +2 -2 300ms`,
then red `- val gap = 4.dp` / `- val inset = 1.dp` and green
`+ val gap = 6.dp` / `+ val inset = 2.dp` in monospace — and
`05_diff_summarised.png` shows `src/big.kt +100 -100 150ms` over
`… 200 more changed lines not shown` and the interleaved context/`-`/`+` lines.
`uiautomator dump` confirms the same nodes; `adb -s emulator-5556 logcat -d`
held 0 `FATAL EXCEPTION` and 0 `E AndroidRuntime` during the sweep.
- **APK publish.** `app-debug.apk` (18,220,501 bytes, sha256
`7cfca9c40361d4f1871bc61da20aec8c918637f8e085b8eb534d134b3cb8fe00`) copied to
`~/.local/share/pipelines/data/artifacts/133/1/pipelines-debug-wip-291cec2.apk`;
`curl -I http://10.0.0.75:8080/artifacts/133/1/pipelines-debug-wip-291cec2.apk`
returned `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18220501`, and a streamed `GET | shasum -a 256` matched.
Not verified in this pass: the live brokered server (separate lane), streaming
against real OpenCode, and attachments — unchanged from the passes above.
`:app:lintDebug` still cannot run here (the Gradle JVM's `25.0.4.1` version
string is rejected by AGP 8.7.2 lint), unchanged from the slices above.
## Stopping a running turn (16 Oct 2026)
The composer already swapped its send control for a red `Icons.stop` while a turn
ran and `AppViewModel.stopChat` already sent `chat_interrupt`; the slice was
missing the proof the task asks for — a unit test pinning the interrupt frame —
so this pass adds that seam and the on-device capture. `android/` only; no new
dependency (still just the declared `material-icons-extended`), no Pipelines
server/Go/installer/Docker file touched, no run started from the app, and
`emulator-5556` only (lane A's `emulator-5554` was never addressed).
- **One interrupt frame.** `ChatProtocol.interruptRequest(sessionId)` builds the
single `chat_interrupt` frame (a `ChatQuery` carrying the session id);
`PipelinesRepository.chatInterrupt` sends it, so the wire shape is no longer
constructed inline where only production can see it.
- **The stopped state is honest.** On a successful interrupt the thread settles
(`running = false`, no error) and the composer's send control returns; only a
failing call (or a server-pushed error frame) sets the conversation's error, so
a stop the server accepted is never shown as a failure.
Evidence (macOS, JDK 17, Gradle 9.7.1 `--offline`,
`ANDROID_HOME=/Users/alan/Library/Android/sdk`):
- `gradle :app:assembleDebug :app:testDebugUnitTest --offline` → `BUILD
SUCCESSFUL`; the JUnit XML totals **255 tests, 0 failures, 0 errors, 0
skipped** (new `chatInterruptRequestCarriesTheRunningSession`, which asserts the
frame the stop control sends is `chat_interrupt` for the running session and
survives the client's JSON round-trip).
- The debug APK was installed on `emulator-5556` only and driven against
`.stop_check/chat_stub_hold.py` (a stdlib `/connect` WebSocket double that holds
the turn open until `chat_interrupt`; test scaffolding, not the app) with
`uiautomator dump`/`input tap`; captures validated with
`android/scripts/capture_png.sh -s emulator-5556`:
`stop_control_running.png` shows the running turn (`Working… · 11s`) with the
composer's send control replaced by the red stop control (bottom-right, in thumb
reach) and the top-bar stop action; `stop_control_stopped.png` shows the same
chat after the stop was pressed — the indicator gone, the send control back, and
no error text (the server acknowledged the interrupt). The stub log recorded
exactly one `chat_interrupt`. `adb -s emulator-5556 logcat -d` held 0
`FATAL EXCEPTION` and 0 `E AndroidRuntime` during the sweep.
- **APK publish.** `app-debug.apk` (18,240,566 bytes, sha256
`56abfb2c59a9c09fabbe32d7de4f0164cdc852cece4b7df3655dd0c233256248`) copied to
`~/.local/share/pipelines/data/artifacts/135/1/pipelines-debug-wip-e2f306b.apk`;
`curl -I http://10.0.0.249:8080/artifacts/135/1/pipelines-debug-wip-e2f306b.apk`
returned `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18240566`, and a streamed `GET | shasum -a 256` matched.
### Follow-up: one tested composer action (16 Oct 2026, run 143)
The stop control was still chosen by an inline `if (thread.running)` in the
composer, and the text field's keyboard send action only checked `canSend`, so a
prompt could still be sent from the IME while a turn was in flight even though the
visible control had become stop. `ChatFormat.composerAction(thread)`
(`ComposerAction.Send`/`Stop`) is now the single pure derivation the trailing
button and the keyboard action both read, so the two controls can no longer
disagree; `ChatFormatTest.composerControlIsStopWhileARunIsInFlightAndSendOtherwise`
covers it. `android/` only; no new dependency.
- Re-verified: `gradle :app:assembleDebug :app:testDebugUnitTest --offline` →
`BUILD SUCCESSFUL`, **266 tests, 0 failures** (the new composer-action case).
- **APK publish.** `app/build/outputs/apk/debug/app-debug.apk` (18,249,033 bytes,
sha256 `a9ce0cc8829513ee37fa5abaafa765307d5574f7cbd2b9cf0bc32392d0c1461e`) copied
to `~/.local/share/pipelines/data/artifacts/143/1/pipelines-debug-wip-609721d.apk`.
`curl -I http://10.0.0.249:8080/artifacts/143/1/pipelines-debug-wip-609721d.apk`
returned `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18249033`; a streamed `GET | shasum -a 256` matched.
- Not driven on a device in this pass: the constraint that the stop control be
exercised on an emulator only conflicts with this run's device note that only the
operator's Pixel (adb serial `58281FDCG000JF`) is available and no emulator may be
run, so the evidence here is the unit tests and the build rather than a fresh
screenshot. The earlier `emulator-5556` captures
(`.stop_check/stop_control_running.png`, `.stop_check/stop_control_stopped.png`)
still show the running/stopped control states.
Not verified in this pass: the live brokered server (separate lane), streaming
against real OpenCode, and attachments — unchanged from the passes above.
## Approvals in the conversation, answered in place (16 Oct 2026)
The brokered protocol already carried `chat_permission`, but the phone only showed
it as a bar above the composer and removed it the moment it was answered. This
pass makes a pushed approval a card in the conversation: the reference app's amber
risk framing, once/always/reject actions wired to `chat_reply`, an in-place settle
on answer, and a resolved state for a request the server reports as already
settled. `android/` only; no new dependency (still just the declared
`material-icons-extended`), no Pipelines server/Go/installer/Docker file touched,
no run started from the app, and `emulator-5556` only (lane A's `emulator-5554`
was never addressed).
- **The card is in the transcript.** `ApprovalCardItem` is the transcript's last
item, so the request sits with the conversation rather than floating above the
composer. It shows the action (`Approve edit`), the affected resources in
monospace, the amber `RISK REVIEW` panel carrying the server's risk summary
(falling back to a neutral sentence naming the action when the server sends
none), and `Allow once` / `Always allow` / `Reject`. The amber `tertiary` role
at 12% fills the review panel and its shield glyph, and at 50% outlines a
pending card — the same amber `shield_outlined` framing the reference app uses.
Geometry reuses the existing chat tokens; the only new constants are the two
alpha strengths.
- **Findable without scrolling the whole chat.** The conversation's top bar shows
a gold `PanTool` "Waiting for your approval" action while a request is open;
tapping it jumps the transcript to the card, and the same glyph marks the chat's
chip in the open-chat strip. A newly arrived request is also scrolled into view
by the existing bottom-follow, and the running indicator stands down while the
turn waits (the clock would otherwise tick on work that is not happening).
- **Answered in place.** `ChatStore.answerPermission` records the decision
optimistically, so the card settles to `Allowed once` / `Always allowed` /
`Rejected` and drops its actions instead of disappearing; a failed `chat_reply`
reopens the same request (`permissionReplyFailed`) with the error, so a decision
the server never received is never shown as accepted. `ChatProtocol.replyRequest`
is the one builder `PipelinesRepository.chatReply` sends, so the card's actions
and the wire frame cannot drift.
- **Already resolved is honest.** `ChatPermissionFrame` gained optional `resolved`
and `decision` fields. A frame for a request the server reports as settled
renders as `Rejected`/`Always allowed`/`Already resolved` with no controls, so a
stale once/always/reject is never offered for a closed request; a frame for a
new request replaces a settled card. Those fields are the additive contract the
server sends when it reports an already-settled request (both are omitted by an
older peer, which simply leaves every request pending).
Evidence (macOS, JDK 17, Gradle 9.7.1 `--offline`,
`ANDROID_HOME=/Users/alan/Library/Android/sdk`):
- `gradle :app:testDebugUnitTest :app:assembleDebug` → `BUILD SUCCESSFUL`; the
JUnit XML totals **267 tests, 0 failures, 0 errors, 0 skipped** (new
`ChatApprovalTest`: a pushed frame yields a pending card with the request's
action/resources/risk and its three actions, answering once/always/reject settles
the card in place, a server-resolved frame offers no actions, a failed reply
reopens the request, and the missing-summary fallback; new
`ChatProtocolTest.chatPermissionFrameCarriesTheServerResolution`; the reply
builder is asserted for `once`, `always` and `reject` through one shared
encode/decode round trip, so no decision is asserted more weakly than another).
- The rebuilt debug APK was driven on `emulator-5556` against
`.approval_check/chat_stub_approval.py` (a stdlib `/connect` WebSocket double
that pushes a pending `chat_permission` after a prompt and a server-resolved one
for a second session; test scaffolding, not the app). Fresh captures this pass,
validated with `android/scripts/capture_png.sh -s emulator-5556` into
`~/.local/share/pipelines/data/artifacts/147/3/`:
`01_approval_pending.png` (the `Approve edit` card with `src/layout.kt`, the
amber `RISK REVIEW` panel and the three actions, the top-bar pan-tool and the
chat-chip marker) and `02_approval_answered.png` (the same card settled to
`Always allowed`, no actions, the amber risk panel retired). The stub log
recorded the `chat_reply` with `decision=always request=req_pending_1`. The
already-resolved path was reached too — the `Already resolved` session rendered
`Rejected` with the server's note and no controls — but `emulator-5556` shut
down before that frame could be captured, and it is not restarted here, so its
evidence is the `uiautomator` dump (`uiautomator_server_resolved.xml`) rather
than a second screenshot.
- **APK publish.** `app-debug.apk` (18,109,180 bytes, sha256
`5f58ac6e92a7fbeb2fd023b5604fd7876e9d2546cc7cadf3d871aa7a4b7cce43`) copied to
`~/.local/share/pipelines/data/artifacts/147/3/pipelines-debug-wip-305714c.apk`
(`305714c` = `git rev-parse --short HEAD`); the running artifacts server serves
`curl -I http://10.0.0.75:8080/artifacts/147/3/pipelines-debug-wip-305714c.apk`
as `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18109180`, and a streamed `GET | shasum -a 256` matched.
Not verified in this pass: the live brokered server (separate lane), streaming
against real OpenCode, and attachments — unchanged from the passes above. The
`resolved`/`decision` frame fields are the additive contract the server must send
when it reports an already-settled request; the live server does not emit them
yet, so only the unit test and the stub exercise that path. `:app:lintDebug` still
cannot run here (the Gradle JVM's version string is rejected by AGP 8.7.2 lint),
unchanged from the slices above. `emulator-5556` — this lane's standing device,
already running when the pass began and never started or restarted here — shut
down after the second capture, so the resolved frame was confirmed from the
accessibility tree rather than a screenshot. The run's device note (all device work
through the attached Pixel, no emulator) conflicts with the task constraint
(emulator only, never install on the person's device); this pass resolved it by
using the already-running emulator and never installing on the Pixel.
## The covered region is sized for the statistics it shows (16 Oct 2026)
Review of the statistics block found three blocking problems, all rooted in the
same cause: the covered region was measured too small for the statistics it was
supposed to carry. First, the region was measured from the destination's bare
`compactLabel` (`"Runs"` measured `~48.9dp`, `"Pipelines"` `~76dp`) plus the touch
target floor, so `PaneIdentity`'s width-derived tier never reached the statistics
it was supposed to carry: `"Runs"` fell below `PEEK_WIDTH_DP` and rendered the
title alone (the runs list showed no counts and no most-recent run), and even
`"Pipelines"` only reached the `Counts` tier because the `Full` tier needs
`MIN_COVERED_PANE_WIDTH_DP + PEEK_WIDTH_DP` (`168dp`). Second, even after the
region was floored at the block, a pipeline-scoped identity is only ever the
nearest covered pane at depth 2, where the thin older edge (`startInset +
minTouch`) narrows it below `168dp`, so its last-run/age and average lines stayed
unreachable — `avg` was dead in the UI. Third, the title broke mid-word in a
narrow strip (`"Complete a Task"` → `"Complet"`/`"e a Task"`). `android/` only; no
dependency was added, no run was started from the app, no server field was added,
and the server/Go source/installer/Docker files were not touched.
- **The measured region carries the statistics, and the nearest edge keeps
them.** `coveredIdentityWidthDp` (`ui/components/PaneIdentity.kt`) is the pure
width rule: the measured content (title or icon) plus the identity's own
padding, floored at the platform touch target and — when the identity carries
statistics — one touch target above the full block's width
(`MIN_COVERED_PANE_WIDTH_DP + PEEK_WIDTH_DP + minTouch`). That extra touch
target is the thin older edge the nearest identity gives up when a second level
is covered (`coveredEdgesDp`; the leading gesture inset cancels against the
region's own), so the nearest edge — the only pipeline-scoped pane that is ever
covered — now clears the `Full` boundary and renders its last-run/age and
average lines instead of only the counts. `rememberCompactIdentityWidth` gained
a `withStats` flag, and `SlidingPaneStack` a `compactStats` parameter; the
Pipelines and Runs stacks both pass `true`, since every covered pane in either
is a list or a detail and both carry a statistics block (the stage pane is never
a covered level: `covered = level < depth` and it is the third level). The active
pane's width stays the same at every depth, because the region does not depend
on depth. At depth 1 a single covered pane measures the full block width and
shows every line; at depth 2 the nearest covered identity still reaches `Full`,
while the older level shows its title alone in the thin edge.
- **The title breaks at whole words rather than mid-word.** `wholeWordTitle`
packs the title greedily onto whole-word lines and, once its lines are full,
drops the remaining words and ellipsizes the last line at a word boundary; the
only exception is a word wider than the whole strip, which is ellipsized to the
width rather than wrapped (there is no internal boundary to break at). The
helper takes an injected `measure`, so the packing rule is unit-testable, and
`PaneIdentity` measures with the same `cardTitle` role and `TextMeasurer` it
draws with.
- **The fixes are pure and unit-tested.** `coveredIdentityWidthDp`'s round trip
through `paneStatTier` (a stats-bearing identity shows the full block),
`theNearestEdgeOfAStatisticsBearingStackStillShowsTheFullBlock` (the region fed
to `coveredEdgesDp` yields a nearest edge that clears the block at depth 2 — the
geometry that was wrong) and `wholeWordTitle`'s
packing/ellipsis/oversized-word/no-room cases are asserted in
`PaneIdentityTest` without a device. The nearest-edge case fails when the
`+ minTouch` reserve is removed, so it pins the defect rather than restating it.
Evidence (macOS, JDK 17 from Homebrew `openjdk@17`, the cached Gradle 8.11.1
distribution, `ANDROID_HOME=~/Library/Android/sdk`, `--offline`, every command
with `--no-daemon`):
- `gradle clean :app:testDebugUnitTest :app:assembleDebug --no-daemon --offline
--console=plain` → `BUILD SUCCESSFUL in 6s` (41 actionable tasks; the clean
evicted nothing cached, so `compileDebugKotlin` and `testDebugUnitTest` were
`FROM-CACHE` for the fixed source and `packageDebug`/`assembleDebug` ran). The
result XMLs total **300 tests, 0 failures, 0 errors, 0 skipped** across 34
files; `PaneIdentityTest` has 12 cases, including
`aStatisticsBearingIdentityIsNeverSizedForItsBareTitle`,
`theNearestEdgeOfAStatisticsBearingStackStillShowsTheFullBlock` (run alone
against the pre-fix floor it failed at `PaneIdentityTest.kt:96`, so it pins the
defect), `theTitleWrapsAtWholeWordsAndNeverSplitsOne` and
`theTitleEllipsizesWholeWordsWhenTheLinesAreFull`.
- `app/build/outputs/apk/debug/app-debug.apk` is 18,046,987 bytes, sha256
`9c2735c8e07db6a04a85616a85a88f2828ef8a551d5b6281a3993b9ea6be9ea7`; it was copied
to `~/.local/share/pipelines/data/artifacts/198/4/pipelines-debug-wip-af68a62.apk`
(`af68a62` = `git rev-parse --short HEAD`; the tree is WIP on top of it).
`curl -sI http://10.0.0.75:8080/artifacts/198/4/pipelines-debug-wip-af68a62.apk`
returned `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18046987`, matching the local file's size.
Not verified in this pass: the on-device wide/narrow renders and the
one/two/four-level screenshots — the brief keeps implementation verification to
the build and the unit tests, and visual review owns the device. The title
wrapping is asserted against an injected measurer, not rendered pixels; the
whole-word guarantee therefore rests on `TextMeasurer` and the drawn `Text`
using the same role and width, which is why both read `text.cardTitle` and the
identity's own `SPACING_S` padding.
## Stage sections open as their own pane, not inline (17 Oct 2026)
The reported stage-screen defect is reproducible and this pass fixes it by
opening every stage section as its own pane and by laying a collapsible body out
in one column. `android/` only; nothing in the Pipelines server, its Go source,
the Docker/compose files or the installer was touched, no dependency was added
and no run was started from the app.
- **The defect and its cause.** Expanding a stage section drew its rows stacked
at the top of the section: the section's content lambda emits one composable
per field (`fields.forEach { StageFieldRow(it) }`) straight into
`CollapsibleSectionBody`'s `AnimatedVisibility`. `AnimatedVisibility` lays out
a *single* child, so several siblings were placed on top of each other at the
section's origin instead of one below the next; the body took the height of its
tallest single row and showed only the last one, so the content did not sit
cleanly under — or under all of — its header.
- **Sections are panes.** The stage screen now keeps a **compact list** of its
section rows (`Artifacts`, `Output`, `Input`, `This run`, `Stage definition`)
and tapping one opens that section as the next pane of the stack — a
full-window screen over the stage on a narrow window, a panel to the stage
pane's right on a wide one — with its own `Scaffold`/`TopAppBar` named for the
section, its own scroll and its own top spacing. Back (the app bar, the gesture
or a peek) returns exactly one level, to the stage screen. `MasterPane` gained
the `Section` level (`MAX_PANE_DEPTH = 3`) and `PaneSelection.sectionKey` (a
primitive saved with the pane selection), so the open section survives rotation
and process death.
- **No trivial inline exceptions.** None of the five sections is kept inline:
each can hold an arbitrarily long value (the definition's prompt/output
contract, the input/output maps, the run evidence, the artifacts gallery), so
an inline body would both risk the layout with many rows and push the run
context off screen; one uniform rule keeps the screen predictable.
- **Rows read as navigation, not as disclosures.** The stage screen's section
rows go through the shared `SectionHeader` with `navigation = true`: the
chevron becomes the static forward arrow (`Icons.AutoMirrored.Filled
.KeyboardArrowRight`, mirrored for RTL) instead of a rotating disclosure
chevron, and the row announces as `Artifacts` with an `Open Artifacts` action
instead of `Artifacts, collapsed` / `Expand Artifacts`. Assistive tech is
therefore never told the row expands in place after it started opening a pane.
The disclosure rows (the run/pipeline detail lists) are unchanged. The
`rememberSectionExpansion` seed that existed only to start the stage pane's
definition expanded (`initiallyExpanded`) is gone with its last caller, so the
shared component no longer carries docs or a parameter for the removed inline
stage behaviour.
- **The shared body fix.** `CollapsibleSectionBody` now lays its content out in a
single full-width `Column`, so *any* collapsible section with more than one row
(it also backs the run/pipeline detail `collapsibleSection` lists) stacks its
rows under the header instead of overlapping them.
- **Semantics kept.** Sections start collapsed; the operator's choice — which
section is open, and the visit — is saved with the pane selection; and each
section's content is derived from the same pure `stageSectionSpecs`
(`stageDefinitionFields`/`runStepFields`/`evidenceFields`), so nothing shown
before is lost. The artifacts section keeps the shared
`ArtifactSelectionScaffold`.
Verification (macOS, JDK 17 from Homebrew `openjdk@17`,
`ANDROID_HOME=/Users/alan/Library/Android/sdk`, cached Gradle 8.11.1,
`--no-daemon --offline`):
- `gradle :app:testDebugUnitTest :app:assembleDebug --no-daemon --offline` →
`BUILD SUCCESSFUL` (`compileDebugKotlin` and `compileDebugUnitTestKotlin`
executed on the edited sources); the test-result XMLs aggregate to **303 tests,
0 failures, 0 errors, 0 skipped** across 34 classes (`PaneStateTest` gained the
Section-level backStep, popTo, encode/decode and depth cases;
`StageDetailSheetTest` replaced the definition-expansion seed with the
`stageSectionSpecs` order/blank-section cases). The `navigation` affordance is
Compose UI semantics, which this module has no unit harness for, so it is
covered by compilation only, not by a test.
- `app/build/outputs/apk/debug/app-debug.apk` is 18,272,941 bytes, sha256
`dccce3ca1a3c5acc724dec376709f694e11a29b68ffd85eae4d5114c4f8989a1`; it was
copied to
`~/.local/share/pipelines/data/artifacts/216/1/pipelines-debug-wip-dcd58b8.apk`
(`dcd58b8` = `git rev-parse --short HEAD`; the tree is uncommitted WIP on top
of it). `curl -sSI
http://10.0.0.249:8080/artifacts/216/1/pipelines-debug-wip-dcd58b8.apk`
returned `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18272941`, matching the local file's size.
Not verified in this pass: the on-device narrow/wide renders (a section opening
over the stage and returning, and the wide panel beside the stage pane) and any
screenshot of the former inline case — the brief keeps implementation
verification to the build and the unit tests, and visual review owns the device.
## Templates: a gallery and a detail view (17 Oct 2026)
The server's template catalog (`list_templates`, which `pipelines templates` and
`pipelines template <key> --source` already print) is now a first-class surface in
the app; before this change the app showed nothing for it. `android/` only:
nothing in the Pipelines server, its Go source, the Docker/compose files or the
installer was touched, no dependency was added (the destination glyph is the
already-declared material-icons-extended `Widgets`) and no run is started from the
app.
- **The destination.** `PipelinesApp`'s destination list gains a `Templates`
entry between `Pipelines` and `Runs` (`TemplatesIcon`, `Icons.Filled.Widgets`,
deliberately not the Pipelines workflow tree), and `TemplatesDestination` uses
the same shared `SlidingPaneStack` the other destinations use: pane 0 the
gallery, pane 1 the selected template's detail, with the selected key in
`rememberSaveable` so the open template survives rotation and process death.
- **The gallery.** `TemplateGalleryScreen` shows one card per template from
`vm.templates` (loaded by a new `AppViewModel.refreshTemplates`, backed by
`PipelinesRepository.listTemplates`): the name, the short description and the
stage count, with the card's own leading glyph. `templateGridColumns` decides
the layout — a single column on a narrow window, and on a wide one as many
`WIDE_RAIL_WIDTH_DP`-shaped cards as fit `SPACING_S` apart via the shared
`galleryGrid` fitting — so no new geometry constant is introduced.
- **Stage counts come from a parsed source, not a guess.** `list_templates`
carries only the source, so `refreshTemplates` parses each template's source on
the server (`validateSource`, the `validate` command) once and caches the graph
per key+source. A template whose source does not parse keeps a null graph: its
card reads `stage count unavailable` (never `0 stages`), its Graph tab says the
source could not be parsed, and its Source tab shows the raw markdown — the
template stays fully viewable.
- **The detail view reuses the pipeline-detail idiom.** `TemplateDetailScreen`
uses the same `DetailTabs` (`pipelineDetailTabs`: Summary / Graph / Source) and
the same tab body/width handling as `PipelineDetailScreen`: Summary lists the
stages, Graph renders the `WorkflowGraph` (with an explicit note when the source
did not parse), and Source renders the definition through the shared
`PipelineSourceView`.
- **One rendered-definition view, not two.** `PipelineSourceTab` moved out of
`PipelineDetailScreen` into `ui/graph/SourceView.kt` as `PipelineSourceView`, so
the pipeline detail and the template detail render a definition through exactly
one composable (per-stage collapsible sections, the Raw toggle, the copy action).
- **One gallery fitting, not two.** The artifact gallery's private
`ArtifactGrid`/`artifactGrid` fitting moved to the shared
`ui/components/GalleryGrid.kt` (`GalleryGrid`/`galleryGrid`), so the templates
gallery and the artifacts gallery share one measured-column rule and the
artefact gallery tests now exercise the shared function.
- **Create from a template.** A top-bar action on the detail opens a dialog that
submits the template's source as a create-only draft pipeline
(`AppViewModel.createFromTemplate` → `PipelinesRepository.createPipeline`, the
`submit` command with `create_only`): the app's equivalent of the CLI's
`pipelines new --template KEY` (that path writes a local draft file; the app has
no filesystem, so it stores the draft on the server, where it appears in the
Pipelines list). An existing name is never overwritten and no run is started.
- **States.** Empty, loading and error states reuse the shared `StateCrossfade`
state components; a covered pane shows only its compact identity.
Verification (this run's review stage, macOS, cached Gradle, `--no-daemon`): the
offline build and unit tests pass at **35 suites / 309 tests / 0 failures / 0
errors**, including the new `TemplatesTest` (the card/stage-count mapping, the
`stage count unavailable` label for an unparsed source, and the narrow-column /
wide-grid decision) and the relocated artifact-gallery cases now running against
the shared `galleryGrid`. The app's create path was checked against the repo's own
Go test for the server submit-with-`create_only` behaviour.
Visual review (this run, operator's Pixel 9 Pro XL, adb `47241FDAS00DLK`, built
from this tree and installed over the existing package) confirmed the gallery
renders 5 cards — a single column at the phone's ~448dp width and a 4-column
measured grid at `wm size 2000x2244` — and that each card opens a Summary / Graph
/ Source detail with the create dialog, consistent with the app's Material 3
language. The empty, loading, error and unparseable-source states were built from
the app's shared state components but could not be produced live without mutating
the operator's server.
### Live run updates from the socket (17 Oct 2026)
`android/` only. The runs list, each pipeline row's last-run line, the run header
and the run detail (status, timeline, stages, artifacts) now advance from the
server's pushes; the one-second poll is gone.
- **Wire.** `data/protocol/Message.kt` mirrors `internal/protocol/runevents.go`:
the `subscribe`/`unsubscribe`/`run_event` types, the optional `run_ids` scope
and the `run_event` payload (`RunEventFrame`/`RunStepDelta`). The frames are
unsolicited (no request id), so they already flowed through the client's
`events` stream; `PipelinesRepository.subscribeRuns`/`unsubscribeRuns` add the
typed command. `subscribe` is sent with `PipelinesClient.sendOnly` (it does not
hold the send lock waiting for the ack) because the running server does not
reliably ack it; any ack/error still lands on `events` with the request id.
- **One pure fold.** `ui/RunEvents.kt` folds one frame into the runs list (in
place, order preserved) and into the open run detail (status, timestamps,
current stage, completed count, and at most one step by sequence). It is
monotonic: a stale `running` delta after a settled run, or a late step delta,
is dropped whole, so an out-of-order or duplicate frame never regresses or
duplicates a visit. A frame for a run the list does not hold reports
`needsResync` rather than inventing a row the compact delta cannot describe.
The row and the detail share one run-field merge and one status ladder
(`RunStateFields`/`advanceStatus`), so their monotonic rules cannot drift.
- **Wiring.** `AppViewModel` subscribes once per (re)connect and per workspace
(a reconnect clears the watch and re-subscribes). Every (re)subscribe then
re-reads the list — and the open run, if any — *once*, because the running
server's subscribe snapshot is not guaranteed complete; the pushes that follow
fold on top of that authoritative read. `applyRunEvent` folds the frame into
`runs` and `runDetail`; an unknown run or a terminal transition triggers one
coalesced `list_runs` re-read, and a settled step or terminal run triggers one
coalesced full `get_run` so the artifacts/output the compact delta omits fill
in. Both re-reads are push/connect-driven, coalesced and loop only if a newer
frame arrives while the read is in flight (the open detail discards and retries
a fetch that a newer frame overtook, keyed by run id so switching runs mid-fetch
is not dropped), so nothing is stale and no timer polls.
- **Honest status.** `RunStreamState` (live/reconnecting/not live) is confirmed
by the subscribe ack, the first push, or a successful (re)connect read (the
running server's ack is unreliable, so a push and the connect read also confirm
it) and shown by the small `LiveBadge` in the runs list and the run detail. A
failed list/detail read is *not* swallowed: it drops the badge to
reconnecting and retries with a bounded backoff, so the badge never keeps
saying "live" over state that failed to update. A manual refresh stays but is
never required.
- **No fighting the operator.** Rows update in place under stable LazyColumn
keys, so scroll, the selected row and an open pane do not jump and the list
does not reshuffle while it is read.
Evidence (macOS, JDK 17, Gradle 9.7.1 `--no-daemon --offline`,
`ANDROID_HOME=/Users/alan/Library/Android/sdk`):
- `gradle --no-daemon --offline :app:assembleDebug :app:testDebugUnitTest` →
`BUILD SUCCESSFUL`; the JUnit XML totals **446 tests, 0 failures, 0 errors, 0
skipped**. New `RunEventsTest` (16 cases) pins the delta sequence: a created run
not in the list (resync), a step started, a step finished (with completed
count), a run finished, a delta for an unknown run (resync), a
duplicate/out-of-order list and step delta (no regression, no duplicate visit),
a settled step keeping its word against a later terminal delta, a reconnect
resync that ignores a later older delta, and the full-sync heuristic.
- **The push path was confirmed on the running server** (`ws://10.0.0.75:8080`,
build `v0.0.0-20261017013542-7875762b9a2c`, i.e. this tree's `7875762`) by
dialling `/connect`, sending `list_runs` (241 runs) then
`subscribe {workspace:/Users/alan/repos/pipelines}`, and reading back
`run_event` frames (`run_id=239 … status=failed finished=…`,
`run_id=230 … succeeded`). Server-side push is a separate lane and is present;
no client-side stream was invented. **Observed limitation of that running
(dirty) server:** its subscribe snapshot was partial and its `subscribe` ack
did not arrive within 30s. The client therefore does not depend on the ack to
read live or to update: pushes confirm the stream and a delta for a run the
list does not hold re-reads `list_runs`. This is the server lane's to fix; the
client is correct against both the acked snapshot defined in
`internal/protocol/runevents.go` and the deployed behaviour.
- **APK publish.** `app-debug.apk` (18,754,221 bytes, sha256
`dbddf756b5eb26f87ba4e2083fb979829b5d349d9cf1b114941e9ceeb137ddf1`) copied to
`~/.local/share/pipelines/data/artifacts/240/3/pipelines-debug-wip-7875762.apk`;
`curl -I` (to `http://10.0.0.75:8080/artifacts/240/3/pipelines-debug-wip-7875762.apk`)
returned `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18754221`. This republishes the artifact with its actual hash:
the earlier `240/1` copy's recorded sha256 did not reproduce from this tree.
Not verified in this pass (device work belongs to the visual-review stage, which
owns the operator's Pixel 9 Pro XL): the on-device status change with no refresh
and the live/reconnecting badge rendering. The captures and the phone's
main-revision restore are that stage's evidence.
## Operator chat sessions: choose the directory, list only your own (17 Oct 2026)
The Chat destination now starts a chat by asking where it should live, and its
list is the operator's own sessions only. Before this change "New chat" created a
session with no directory of its own choosing (it passed the workspace, so the
session landed wherever the server happened to be) and the list was whatever
`chat_sessions` returned with no way to tell an operator chat from anything
run-related. The server change this builds on (operator sessions tagged
`operator`, `chat_sessions` returning exactly those with their directory and
recency, and a `chat_directories` request) is already in this revision; nothing in
the Pipelines server, its Go source, the installer or the Docker files was
touched, no dependency was added beyond the already-declared
material-icons-extended, and no run is started from the app.
- **Starting a chat asks where first.** `ChatScreen`'s level-1 pane is now the
directory picker while a create is in flight: the server's
`chat_directories` reply (the operator's home first, then the directories of
previous operator sessions, most recently used first) rendered through the
shared `ListRow`, each with its full path, home shown as `Home (~)` with its
absolute path beneath it. It is a normal pane of the chat stack, so Back, the
app bar's back control, the footer's Cancel and the predictive-back gesture all
leave it without creating anything — not a modal dead end.
- **The directory is always sent.** The picker starts on the operator's home
(`directoryChoices`/`defaultDirectoryChoice`) and `chat_create` is sent the
chosen directory — `~` for home, the absolute path for a recent — so a session
is never created in the server's own working directory. The server resolves or
rejects it, and its error is shown in the pane.
- **The list is the server's, and says so.** The list renders
`ChatState.visibleSessions`: exactly the server's `chat_sessions` (operator
sessions only — the app never guesses which session belongs to a run) with the
operator's own local changes applied. Each row carries its directory and the
kind chip derived from the server's own tag (`sessionTagLabel`, `operator` →
`Operator`), so an operator chat is tellable at a glance.
- **Managing a session, honestly.** The brokered protocol has no rename and no
delete for a chat session (there is no `chat_rename`/`chat_delete` type and the
native session endpoint is not exposed), so both are the operator's own,
device-local changes, persisted with the other settings
(`SettingsRepository.chat_overrides`, `ChatSessionOverrides`): rename stores a
local title that wins over the server's on every later list load, and "Remove
from list" hides the row and closes its conversation while a snackbar reports
it as a local, undoable change ("Removed from this list; the chat stays on the
server.") with an Undo action. Nothing is deleted on the server, and a refresh
cannot bring a removed row back.
- **Everything else is unchanged.** Multi-chat drafts/scroll/running, streaming,
tool chips, diff cards, approval cards, stop and the reconnect path are
untouched; the picker only reuses the stack's second level the conversation
already used.
Tests (`app/src/test`): `ChatDirectoriesTest` (home first and the default, the
recents' order and their full-path create value, an empty/blank reply still
yielding home), `ChatSessionManagementTest` (the chip from the server's tag, the
create flow's home default and chosen directory, rename winning over the server
title and surviving a refresh, removal hiding until undone and leaving the
server's list intact, the override encode/decode round trip) and the new
`ChatProtocolTest` cases for the `tag` field and the `chat_directories`
request/reply.
Not verified in this pass: the on-device picker, the tagged list and a session
open in a chosen directory — the brief keeps implementation verification to the
build and the unit tests, and visual review owns the device. The chip, menu and
dialog are Compose UI, which this module has no unit harness for; they are
covered by compilation only.
## A conversation opens at the newest message, and follows it (17 Oct 2026)
Opening a conversation used to start at the top of the transcript, so the first
thing the operator did was scroll down past everything already said to find the
current turn. This item is the scroll and follow behaviour plus a jump-to-latest
affordance; the transcript rendering, streaming, tool chips, diff cards and
approval cards are unchanged. `android/` only; nothing in the Pipelines server,
its Go source, the installer or the Docker files was touched, no dependency was
added beyond the already-declared material-icons-extended, and no run is started
from the app.
- **Opening at the newest message.** The transcript's list state is now created
the moment the conversation first has content, with its first visible item set
by `chatFirstScroll` (`ui/chat/ChatScroll.kt`): a conversation the operator has a
position of their own in is restored, and every other conversation — i.e. every
freshly opened chat — starts at its newest message. "A position of their own" is
explicit now: `ChatThread.scroll` is nullable, null meaning the operator has
never left a position here, so a chat they deliberately left at the very top
(`ChatScrollPosition(0, 0)`) is restored rather than mistaken for "new". The
restore/clamp rule is the app's existing shared one (`restoredScrollAnchor`,
`ui/components/ListScroll.kt`): the saved index is clamped to the messages that
still exist and the offset is kept only when the saved message survived, so a
conversation that shrank underneath neither throws nor draws part-way down an
unrelated message. Placement happens on the list's *first* measure — it waits
for the viewport to be measured — so opening a chat never shows the top first,
and it goes through the same `scrollToEnd(itemCount, animated = false)` the
follow uses, never animated: a fresh conversation is placed at its newest item
(and a last message taller than the viewport has the part still below the fold
closed in the same settling), and a position the operator left is restored.
Because placement and follow share the one path, they cannot disagree about what
the newest item is — the earlier split (placement closed the gap directly) left a
conversation that grew between state creation and first measure showing the older
anchor with the newest item below the fold. Leaving a chat still persists its
position (a list state that never held content saves nothing), so returning to it
restores where the operator was. The placement flag and the follow state are
`rememberSaveable` too, so a rotation or process death while the operator is
reading history does not re-place the transcript and yank them back to the
bottom.
- **One scroll path, changed deliberately.** The existing follow scroll, the app
bar's approval jump and the new jump-to-latest all go through one helper:
`LazyListState.scrollToEnd(itemCount, animated)`. When the newest item sits
entirely below the fold — an item appended exactly at the viewport edge, with no
pixel on screen, so the distance to the end cannot be measured — it is brought
into view first (`animateScrollToItem`/`scrollToItem`); any part of it still
below the fold (a message taller than the viewport) is then closed by exactly
that distance (`closeBottomGap`). An item that is already partly visible is only
gap-closed, never moved up first, so following a growing stream never bounces.
There is no second scroll mechanism beside it. The distance is measured against
the transcript's *content* count (`bottomDistancePx(itemCount)`), not the count
the layout has measured: the follow effect is dispatched ahead of the measure
that appends the new item, so on that frame the layout still describes the
previous items and its own last visible item reads as the end — a stale
`totalItemsCount` makes an appended item look like the already-visible end, no
gap is detected and the item is never brought in. Reconciling the two counts is
what makes an arriving message, the local prompt plus running indicator appended
together, or an approval card actually arrive in view.
- **Follow while reading the newest part.** Following is the operator's position,
not only their intent: only their own drag changes it (a `DragInteraction.Start`
stops it, and a `Stop`/`Cancel` resumes it when the scroll settles at — or
within `CHAT_FOLLOW_THRESHOLD_DP` of — the bottom, `chatFollowsAt`), and it is
settled at placement from the live distance so a position restored away from the
bottom does not follow. While it holds, an arriving message (including one that
lands entirely below the fold), a streamed delta, a tool chip, a freshly arrived
approval card, a grown composer or the appearing keyboard re-follows smoothly;
the whole viewport height is an input to the follow effect, so the newest
message is never left hidden behind the composer or the IME. Programmatic
scrolls never touch the list's `interactionSource`, so they cannot un-stick the
view. The item count the decisions measure against is read at use time
(`rememberUpdatedState`): the drag collector and the affordance's derived state
outlive a recomposition, so a captured count would go stale as messages arrive
and the follow would measure against how many items there used to be.
- **Threshold.** `CHAT_FOLLOW_THRESHOLD_DP` (`ui/theme/Dimens.kt`) is **32dp**:
about one comfortable line of text, so the operator can be slightly off the
exact bottom (the list's own bottom gutter included) and still be pulled along,
while a deliberate scroll up stops the view moving under them.
- **Jump to latest.** A small Material 3 `SmallFloatingActionButton` (the
already-declared `KeyboardArrowDown` icon, at the transcript's bottom-end on the
shared gutter token) is offered while the view is *not* following and there is
genuinely something below the fold (`chatShowJumpToLatest`), and hidden at the
bottom or for an empty transcript. Tapping it re-engages the follow and returns
to the newest message. A pending permission/approval is still brought into view
the way the existing code did — it is the transcript's last item, so the follow
brings it in when the operator is reading the newest part, and the app bar's
approval action still jumps straight to it on demand.
- **Tests.** `ChatScrollTest` (11 cases) pins the pure decisions: the distance to
the end (overflow past the viewport, 0 once in view, null when a whole item is
below the fold — the case an item appended at the viewport edge creates, which
the follow must bring into view rather than only gap-close — or the list is
unmeasured), the same distance reconciled against the content count while the
layout still lags it by one item (the stale frame the follow runs on: read
against the layout's own count it is 0 and nothing moves; read against the
content count it is unknown and the item is brought in), the follow resuming
at/within the threshold but not beyond it, the jump-to-latest visibility (offered
only while away from the bottom, hidden at the bottom and for an empty
transcript), and the first placement (a fresh conversation — no position of its
own — at its newest message, a left position restored and clamped, a position at
the very top kept distinct from "new", and nothing to place when empty).
Evidence (this run's implementer pass, macOS, Kotlin `jvmTarget` 17, Gradle 9.7.1
launcher on JVM 25.0.4.1, `ANDROID_HOME=/Users/alan/Library/Android/sdk`,
cached/offline): `gradle --no-daemon --offline :app:testDebugUnitTest
:app:assembleDebug` → `BUILD SUCCESSFUL`, and `:app:testDebugUnitTest
--rerun-tasks` re-executed every test: the JUnit XMLs total **50 suites / 458
tests / 0 failures / 0 errors / 0 skipped**, including the new `ChatScrollTest`
(11 cases) and the existing chat suites (`ChatStreamTest`, `ChatApprovalTest`,
`MultiChatStateTest`, `ChatSessionManagementTest`, `ChatDirectoriesTest`,
`ChatFormatTest`, `ChatProtocolTest`) green. The APK was published to this run's
artifacts directory as `pipelines-debug-wip-311a015.apk` (18,601,229 bytes, sha256
`a3b45c3518e524f53719de243916fe4fcf120a82fad7c2de09b634bff717b1b6`; `311a015` is
`git rev-parse --short HEAD`, the tree being uncommitted WIP on top of it) and is
served at
`http://10.0.0.75:8080/artifacts/247/1/pipelines-debug-wip-311a015.apk`
(`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18601229`).
Not verified in this pass: the follow/affordance behaviour on a device and every
claim about first-display smoothness — the brief keeps implementation
verification to the build and the unit tests, and visual review owns the device.
The composable's frame timing (placing the list before its first draw, the
instant correction for a last message taller than the viewport, and the fallback
that brings an item appended below the fold into view) is argued from the pinned
Compose BOM (2024.10.00) and the pure decisions it delegates to, not observed.
## Attaching files to a message (17 Oct 2026)
A chat message could only be text even though the prompt already belongs to a
turn the phone builds. This slice lets the operator attach one or more files to
the next message, shows them with a name and an image thumbnail, lets one be
removed, carries them on the prompt, and clears them once the message is sent.
`android/` only; nothing in the Pipelines server, its Go source, the installer or
the Docker files was touched, no dependency was added beyond the
already-declared material-icons-extended, and no run is started from the app.
- **Attaching never transmits.** The picker (`ActivityResultContracts
.OpenMultipleDocuments`, the platform picker) returns content URIs; the app
resolves only each file's name, size and MIME and confirms it can be opened
(`resolveChatAttachment`, `ui/chat/ChatAttachments.kt`). The bytes are not read
here, so nothing leaves the device until the message carrying them is sent.
- **What is attached.** `ChatThread.attachments` holds `ChatAttachment` values
(uri/name/mime/size and an optional error), kept per chat exactly like the
draft, so switching chats never loses them. Each gets a store-assigned id
(`ChatStore.attach`) so it can be keyed and removed individually; the composer
strip shows an image thumbnail (a downsampled local decode, off the main
thread) or a file glyph, the name, the size, and a remove action.
- **The prompt carries them.** The send builds the request through one builder,
`ChatProtocol.promptRequest(sessionId, text, files)`: `files` is the attached
URIs from `attachmentFiles`, in attachment order, and is omitted entirely for a
text-only prompt (so the wire shape a text-only prompt always sent is
unchanged). `PipelinesRepository.chatPrompt` takes the same `files` list.
- **The transcript shows them.** A sent user turn carries each attachment as a
`ChatProtocol.PART_FILE` part (`attachmentPart`), which `MessageItem`'s
existing parts rendering draws (`UserParts` → `FilePart`): an image as a
preview, anything else as an icon and its name. There is no second attachment
list under the bubble.
- **Honest failures.** A file that cannot be queried or opened, or is over
`MAX_ATTACHMENT_BYTES` (25 MiB), is attached with the reason set against it
(`attachmentError`), never dropped. `ChatThread.canSend` is false while any
attachment is flagged, so the message is not sent without it; a server
rejection (`sendChatPrompt`) takes the optimistic bubble back out, returns the
files flagged with the server's message, and keeps the draft, so nothing is
silently lost.
- **Cleared after send.** `sendChatPrompt` clears the draft and the attachments
once the prompt is built, while the optimistic turn still shows them.
**Known server-side gap (verified by reading the tree, not live).** The brokered
server stores a user turn as text and does not forward the prompt's `files`
(`internal/server/chat.go` calls `broker.Prompt(ctx, sessionID, prompt.Text)`,
and `internal/opencode/chat.go` posts only `{"text": …}`), and the deployed
server predates chat. So the attachment the phone sends is not yet echoed back in
history; the transcript shows it from the app's own optimistic turn, and an
end-to-end file round-trip needs the server-side lane. This slice is the client
capability the request field and the display path already allow.
Tests (`ChatAttachmentTest` 5 cases, `ChatAttachmentStateTest` 5 cases, and a new
`ChatProtocolTest` case): the request built with attachments (and omitted for a
text-only prompt), removing one, the unreadable and oversized paths (reported by
name, blocking the send), which files travel with the prompt, the optimistic
turn's file parts, clearing after send, and the rejected path putting the files
back flagged.
Evidence (this run's implementer pass, macOS, JDK 17.0.20.1,
`ANDROID_HOME=/Users/alan/Library/Android/sdk`, Gradle 8.11.1 `--offline
--no-daemon` — a single-use daemon is forked for the JVM settings):
`gradle --offline --no-daemon :app:assembleDebug :app:testDebugUnitTest` →
`BUILD SUCCESSFUL`; the JUnit XMLs total **485 tests / 0 failures / 0 errors / 0
skipped**. The APK was published to this run's artifacts directory as
`pipelines-debug-wip-d1a859e.apk` (18,470,240 bytes, sha256
`378e7e8f03ca7e75108db1217aba3b81efca396fecfcbf9dec2a6bf964319dfa`; `d1a859e` is
`git rev-parse --short HEAD`, the tree being uncommitted WIP on top of it) and is
served at
`http://10.0.0.75:8080/artifacts/249/1/pipelines-debug-wip-d1a859e.apk`
(`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18470240`).
Not verified in this pass: the picker, thumbnails, composer strip and sent
message on a device — the brief keeps implementation verification to the build
and the unit tests, and visual review owns the device; and the live file
round-trip, which the server-side gap above makes unavailable.
### Review follow-ups (same slice, 17 Oct 2026)
A code-review pass found four concrete items, all fixed without changing the
request shape or the display path:
- The composer's own byte formatter duplicated `ui/Format.kt`'s documented
`humanBytes`. `attachmentError` and the chip's size line now call `humanBytes`,
so a size reads the same in the composer as on the artifact screens (a sub-MiB
size now keeps its one decimal, e.g. `900.0 KiB`).
- Optimistic user-turn ids come from a monotonic counter instead of the count of
live local turns. Removing a rejected turn no longer lets the next append mint
the id it held, so the transcript's per-id keys can never duplicate.
- `restoreAttachments` keeps a file attached between sending and the rejection
(it previously replaced the whole list and silently dropped it).
- The thumbnail decode catches `Exception`, not `Throwable`, so an `Error`-level
failure is no longer swallowed into a null glyph.
Re-verified with `gradle --offline --no-daemon :app:testDebugUnitTest
:app:assembleDebug` → `BUILD SUCCESSFUL`; the JUnit XMLs total **487 tests / 0
failures / 0 errors / 0 skipped** (two new `ChatAttachmentStateTest` cases cover
the counter and the kept file). The APK was republished for this stage as
`pipelines-debug-wip-d1a859e.apk` (18,470,240 bytes, sha256
`fbd640af7749cb483e5c01cd1ca06c074fc9db620049ab07d63c5a03c5298f63`) and is served
at `http://10.0.0.75:8080/artifacts/249/3/pipelines-debug-wip-d1a859e.apk`
(`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18470240`).
## New activity in the session list (17 Oct 2026)
With several operator sessions open the list gave no sign of where a reply
arrived: an idle chat and one streaming a reply right now looked the same, so the
operator lost the conversation they were in. A row now signals a transcript the
operator has not read, and a turn streaming right now, distinctly from each other
and from an idle chat; opening a chat clears its mark; and the marks survive a
restart, not only a reconnect. The signal is derived from what the app already
receives — the sessions' own `updated_at` recency and the message ids/timestamps
of pushed chat events and history — so no server request is added for it.
`android/` only; nothing in the Pipelines server, its Go source, the installer or
the Docker files was touched, no dependency was added beyond the already-declared
material-icons-extended, and no run is started from the app.
- **Read state, persisted.** `ui/chat/ChatSeen.kt` adds `ChatSeenState`: a
per-session recency watermark (`seenAt`, the newest `updated_at` the operator
has read) plus the ids that moved on while the app was open (`unseen`). It is
stored as one opaque JSON preference (`SettingsRepository.chat_seen`, observed
by `AppViewModel.observeChatSeen`), exactly like `ChatSessionOverrides`, so a
mark is still there after a restart.
- **Unseen, derived not requested.** `ChatState.isUnseen` marks a session that is
not on screen and either carried a live mark (a pushed frame arrived for it
while it was backgrounded — `ChatStore.event`/`permission` mark any activity for
a chat that is not active) or, if it has never been opened on this device, is
newer than its stored watermark. First sight of a session is seeded to its
current recency (`ChatSeenState.seeded`), so a chat that predates the feature is
not reported as new; a reply that arrived while the app was closed is newer than
the watermark and reads as unseen after a restart. An **open** thread is judged
by its live mark alone, so a conversation the operator has been in is never
re-flagged by a later list refresh — only by activity after they leave it.
- **Opened means read.** `ChatStore.open`/`activate` advance the watermark to the
session's recency and clear its live mark; `history` for the active chat also
advances it to the newest message the server reports; `close` clears a live mark
because a chat the operator had open was read.
- **Three distinguishable states.** `ChatFormat.sessionActivity(running, unseen)`
is the one pure derivation (streaming outranks finished-unseen, which outranks
idle) and `SessionActivityBadge` renders it as a labelled dot: `Streaming`
(tertiary) while a turn is in flight, `New` (primary) once it settles unseen,
and the existing `Open` (outline) otherwise. The kind chip and the directory
line are unchanged beside it — this adds a signal, it does not replace them.
- **Ordering untouched.** The list is still the server's most-recently-used order;
nothing here reorders it.
Tests (`ChatActivityTest`, 5 cases): an unseen session is marked (a pushed frame
for a background chat, and a session newer than the stored watermark with no frame
at all), opening clears the mark from the persisted state too, the pure activity
derivation distinguishes streaming/finished-unseen/idle and the store agrees
across a background turn, and the seen state survives an encode/decode into a
fresh store.
Evidence (this run's implementer pass, macOS, Gradle 9.7.1 `--offline
--no-daemon`, `ANDROID_HOME=/Users/alan/Library/Android/sdk`): `gradle --offline
--no-daemon :app:testDebugUnitTest` → `BUILD SUCCESSFUL`; the JUnit XMLs total **54
suites / 492 tests / 0 failures / 0 errors / 0 skipped** (5 new in
`ChatActivityTest`). `gradle --offline --no-daemon :app:assembleDebug` → `BUILD
SUCCESSFUL`; the APK was published to this run's artifacts directory as
`pipelines-debug-wip-5adc961.apk` (18,470,240 bytes, sha256
`0866b7c2c1cfbd51f55bd8a81e3550437553ff542a04de605d7f994060ee63ea`; `5adc961` is
`git rev-parse --short HEAD`, the tree being uncommitted WIP on top of it) and is
served at
`http://10.0.0.75:8080/artifacts/270/1/pipelines-debug-wip-5adc961.apk`
(`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18470240`).
Not verified in this pass: the badge on a device, the wide/narrow layouts, and a
mark surviving a real process restart — the brief keeps implementation
verification to the build and the unit tests, and visual review owns the operator's
Pixel 9 Pro XL. Known limitation: a reply streamed and watched while the chat was
active carries no wall-clock stamp on its pushed frames, so its exact recency is
only learned from the server's history/`updated_at` on a later read; if the app is
killed before that, a restart can conservatively re-flag that chat until it is
opened again. Opening always clears the mark.
## Finding a session among many: search and directory grouping (17 Oct 2026)
The chat list is the operator's own sessions in recency order, but as a day's work
accumulates it is a flat, unsearchable wall and the session that is wanted is the
one that cannot be found. The list can now be narrowed by typing over each chat's
title and directory, sessions of one repository are grouped together, and a
narrowing that matches nothing says so and offers to clear it.
`android/` only; no dependency was added beyond the already-declared
material-icons-extended, nothing in the Pipelines server, its Go source, the
installer or the Docker files was touched, and no run is started from the app.
- **The search control reuses the list-filter pattern.**
`ChatListSearchControl` is the shared `FilterMenu` (the same top-bar icon with
an active-count badge used by the pipelines and runs lists), carrying one
`OutlinedTextField` and a `Clear search` reset. It is not a new control: the
field narrows the list as the operator types and the menu stays open behind it,
exactly like the pipelines name filter.
- **The match rule is one pure derivation.** `ui/chat/ChatListFilter.kt`
adds `sessionMatchesQuery` / `filterChatSessions`: a case-insensitive substring
over the session's title (the local rename included, since it is applied to the
visible list first) and its directory. A blank or whitespace query narrows
nothing, and the survivors keep their incoming order — so the search composes
with the recency order rather than re-sorting it.
- **Same repository, together.** `groupChatSessionsByDirectory` groups the
narrowed sessions by directory, each group keeping the recency order inside it
and the groups ordered by their first (most recent) session, so the top of the
list still leads with the newest activity. The list pane renders a directory
heading per group only when there is more than one directory; a single directory
(or none) stays the flat list, which is already together. Every row still shows
its directory as before.
- **Empty result and the create path.** A narrowing that matches nothing renders
the shared `EmptyState` — `No chats match "<query>".` with a `Clear search`
action — the same empty-state pattern the other lists use. The trailing
`New chat` action is never hidden while the list is narrowed, so creating stays
one tap away.
- **State and marks untouched.** `ChatState.sessionQuery` (set through
`ChatStore.searchSessions` / `AppViewModel.setChatSessionQuery`) is a display
narrowing only: it never touches the server's list or an open conversation, and
the activity marks derive from the same session ids as before.
Tests (`ChatListFilterTest`, 9 cases): the match rule over title and directory
(case-insensitive, blank matches all, a miss is empty), that filtering preserves
the recency order, grouping by directory (order by the first session, order kept
inside a group, a single directory yields one group, a blank directory groups
too), and — through the store — that searching narrows `filteredSessions`,
clearing restores the full list, the server's list is untouched, and a filtered
session still reports its activity mark.
Evidence (this run's implementer pass, macOS, Gradle 8.11.1 at
`~/.gradle/wrapper/dists/gradle-8.11.1-bin/bpt9gzteqjrbo1mjrsomdt32c/gradle-8.11.1/bin/gradle`
with `JAVA_HOME="/Applications/Android Studio.app/Contents/jbr/Contents/Home"`
(JDK 17) and `ANDROID_HOME=/Users/alan/Library/Android/sdk`):
`gradle --offline --no-daemon :app:testDebugUnitTest` → `BUILD SUCCESSFUL`; the
JUnit XMLs total **55 suites / 501 tests / 0 failures / 0 errors / 0 skipped** (9
new in `ChatListFilterTest`). `gradle --offline --no-daemon :app:assembleDebug` →
`BUILD SUCCESSFUL`; the APK was published to this run's artifacts directory as
`pipelines-debug-wip-bb486ac.apk` (18,486,624 bytes, sha256
`d276f7be66501c7becdd83628e3407f955ec982552a87a6a5146d4f44cb5598d`; `bb486ac` is
`git rev-parse --short HEAD`, the tree being uncommitted WIP on top of it) and is
served at
`http://10.0.0.75:8080/artifacts/271/1/pipelines-debug-wip-bb486ac.apk`
(`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18486624`).
Not verified in this pass: the search field, the directory sections and the
empty state on a device, and the narrow/wide layouts — the brief keeps
implementation verification to the build and the unit tests, and visual review
owns the operator's Pixel 9 Pro XL.
## Conversation reading: markdown, collapsed reasoning, one identity (17 Oct 2026)
Making the conversation readable on a phone. `android/` only; no new dependency
(the declared `material-icons-extended` only), no Pipelines server/Go/installer/
Docker file touched and no run started from the app.
- **Markdown reaches the transcript (tested).** The assistant `text` part was
already rendered through `MarkdownText`, but the transcript's decision was
buried in a private composable. `ChatFormat.partRendering(part)` now names the
one decision the transcript makes (`MARKDOWN` / `REASONING` / `PLAIN` /
`HIDDEN`), `MessagePart` consumes it, and `ChatTranscriptTest` drives a sample
covering the whole documented subset (headings, paragraph, bullet and ordered
lists, quote, table, fenced code, rule, inline code/bold/italic/link) from a
`ChatPart` into `parseMarkdown`/`parseInline`. Text outside the subset (raw
HTML, `~~strike~~`) still parses to a paragraph and renders verbatim; an
unknown part kind still renders its text, never drops it.
- **Reasoning collapsed by default.** `ReasoningBlock` is now one compact,
muted line per part — a `Psychology` icon, a label (`Thinking…` while the
newest turn streams, `Reasoning` once settled) and a chevron — that expands on
tap to the full, still-muted text. Expansion is a pure
`ReasoningExpansion` set hoisted to the conversation pane (not the lazy
transcript), so a part keeps its state while the operator scrolls and its item
is disposed, and every part starts collapsed in a freshly opened chat. The
choice for a running turn: its streaming reasoning stays collapsed and keeps
following the stream under the live `Thinking…` label, so it signals progress
without competing with the answer.
- **One identity in the header.** `ChatFormat.conversationHeader(thread)` builds
the app-bar title plus the only extra context — the labelled kind chip
(`Operator`) from the server's own tag, the activity (`Running` /
`Busy · read-only` / `Idle`), the directory and the model — and the app bar and
context line read the same value. The conversation's active chip is omitted
from the open-chat strip (`openChatsBeside`), so the session's title is shown
once; every *other* open chat is still one tap away, and the session list is
unchanged.
Tests (`ChatTranscriptTest`, 7 cases, plus the existing `ChatFormatTest`): the
markdown subset reaches the renderer from a `ChatPart`; text outside the subset
and an unknown part kind still render; reasoning starts collapsed, toggles per
part and never expands on a blank key; the header names the session once with
only kind/activity/directory/model beside it; and the conversation strip offers
only the other open chats.
Evidence (macOS, JDK 17, Gradle 9.7.1 `--offline`, `--no-daemon`,
`ANDROID_HOME=/Users/alan/Library/Android/sdk`):
- `gradle :app:assembleDebug --no-daemon --offline --rerun-tasks` → `BUILD
SUCCESSFUL` (35 tasks executed).
- `gradle :app:testDebugUnitTest --no-daemon --offline --rerun-tasks` →
`BUILD SUCCESSFUL`; the JUnit XMLs total **508 tests, 0 failures, 0 errors, 0
skipped** (7 new in `ChatTranscriptTest`).
- **APK publish.** `app-debug.apk` copied to this run's artifacts directory as
`pipelines-debug-wip-5ac196c.apk` (18,486,624 bytes, sha256
`0df6899429a8f5632ec568340dddb63a5617b1a04af19f52c6ebb793470a0b23`; `5ac196c`
is `git rev-parse --short HEAD`, the tree being uncommitted WIP on top of it).
It is served at
`http://10.0.0.75:8080/artifacts/274/1/pipelines-debug-wip-5ac196c.apk`
(`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18486624`).
Not verified in this pass: the conversation, the collapsed/expanded reasoning
and the header on a device — the brief keeps implementation verification to the
build and the unit tests, and visual review owns the operator's Pixel 9 Pro XL
(captures: headings/list/fenced code/table, reasoning collapsed then expanded,
and the header).