986a62b09f
The search results panel replaces each row's text type badge (LabelChip,
removed) with a glyph derived from the result kind and, for an artifact,
from its content type. The artifact branch reuses the gallery's own
artifactKind/artifactIcon mapping in ui/graph/ArtifactType.kt instead of
a second table, and the glyph's contentDescription carries the kind in
words so a screen reader hears what the icon cannot show.
The panel's header gains the runs list's FilterMenu and SortMenu: a kind
filter (All kinds, Pipelines, Runs, Steps, Fields, Artifacts, Versions)
that sends the server's SearchRequest.kind verbatim, and Relevance /
Newest / Name sorting. The server's search takes no sort, so Newest and
Name order the results in hand and say so ("Sort results in hand", the
collapsed summary's "(in hand)"); no Prompts option is offered because
the server's search kinds cannot produce one. The chosen kind and order
persist via SettingsRepository, surviving query changes and streaming.
Tests: OmniSearchResultsTest covers the per-kind and per-content-type
glyph (checked against the gallery mapping), the kind label, filter
narrowing, Relevance/Newest/Name ordering with ties, and the empty-state
line; ArtifactTypeTest covers artifactKindLabel.
Checked before committing:
- Packaged templates: none describes the app's search panel; unchanged.
- README/topic docs: android/README.md gains the "Search type icons, a
kind filter and sorting" section; docs/cli.md and docs/ui-ux-review.md
describe only the TUI/server search, so they stay accurate and are
unchanged.
- Packaged authoring skill references: internal/author/skill/references/
contains no Android search-panel documentation (operations.md's "omni
search" is the TUI), so none needs updating; install.go's inventory is
untouched.
Evidence: gradle :app:testDebugUnitTest --rerun 433 tests 0 failures;
:app:assembleDebug successful, APK published to the run artifacts; the
API-27 NewApi lint errors are pre-existing and unrelated.
(cherry picked from commit b808158d499912e09872c31b5259205ee6cd8838)
6327 lines
411 KiB
Markdown
6327 lines
411 KiB
Markdown
# 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 colour comes from the
|
||
one status source, so a word that is a run state (`success`/`error`/`blocked`/
|
||
`skipped`/`waiting`/…) is the same colour the runs list draws; only a graph-only
|
||
flow outcome (`approved`, `retry`, …) keeps its curated graph colour. A visit's
|
||
*outcome* is still distinguished from the run's *status* by the chip's own label
|
||
and the row's state glyph, never by a second colour. 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/waiting/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.
|
||
*(Superseded 17 Oct 2026: the graph's terminal roles and the Timeline chip now
|
||
also take the one run-status colour, so "the graph outcome palette is unchanged"
|
||
no longer holds — see "One status colour everywhere" below. `RunStatusPalette`
|
||
stays the single status source.)*
|
||
- **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.
|
||
|
||
## One status colour everywhere (17 Oct 2026)
|
||
|
||
A successful stage in the Timeline read amber, because a visit's chip was coloured
|
||
from the graph's outcome palette while every other surface used the run-status
|
||
palette, so the same word meant two colours. `android/` only; nothing in the
|
||
Pipelines server, its Go source, the Docker/compose files or the installer was
|
||
touched, no dependency was added beyond the already-declared
|
||
`material-icons-extended`, and no run was started from the app.
|
||
|
||
- **One source of truth.** `ui/components/RunStatusPalette.kt`, with `RunState` /
|
||
`runStateOf` / `runStateColor` / `runStateIcon` in `ui/components/RunStatus.kt`,
|
||
owns a status colour. `RunState` gained the server's own `Waiting`/`Blocked`/
|
||
`Skipped` words (`waiting` corroborated by `internal/tui/run_progress.go`), each
|
||
with a deliberate palette entry, a distinct material glyph
|
||
(`HourglassEmpty`/`Block`/`SkipNext`) and a label, so status is never colour
|
||
alone.
|
||
- **The graph and timeline route through it.** `graphColors(scheme)` sets
|
||
`success`/`error` from `runStateColor(Succeeded/Failed)`, and `outcomeColor`
|
||
returns the shared status colour for any word that resolves to a `RunState`,
|
||
falling back to `GraphPalette` only for the graph-only flow outcomes
|
||
(`rejected`, `exhausted`, `retry`, `approved`, `fast`, `missing`; `blocked`/
|
||
`skipped`/`done` were removed from the graph palette). The Timeline's
|
||
`TimelineRow` uses the same factory, so a successful visit is green and a failure
|
||
red. A visit's *outcome* stays distinct from the run's *status* by the chip's own
|
||
label and the row's state glyph, never a second colour. The runs list's failure
|
||
diagnostic uses `runStateColor(Failed)` rather than a scheme role that could
|
||
drift from the chip above it, and the list's status filter gained `waiting`.
|
||
- **Tests.** `GraphPaletteTest` asserts every status word's graph colour equals the
|
||
runs-list colour and that the graph-only outcomes stay distinct and borrow no
|
||
status colour; `ui/graph/StatusColorConsistencyTest` asserts the timeline maps
|
||
through the same source and that every state maps to exactly one colour, the one
|
||
deliberate alias being Running/Active.
|
||
|
||
Evidence obtained on this tree (macOS, JDK 17 from Homebrew `openjdk@17`, Gradle
|
||
8.11.1, `ANDROID_HOME=/Users/alan/Library/Android/sdk`, `--offline`,
|
||
`--no-daemon`):
|
||
|
||
- `gradle :app:testDebugUnitTest --rerun-tasks` → **516 tests, 0 failures, 0
|
||
errors, 0 skipped** (including the new `StatusColorConsistencyTest`, 2 cases, and
|
||
the extended `GraphPaletteTest`, 12 cases, and `RunStatusTest`, 3 cases).
|
||
- **APK publish.** The run's debug APK is
|
||
`…/artifacts/282/1/pipelines-debug-wip-d13f359.apk` (18,486,624 bytes, sha256
|
||
`b11481889b2894efb5fb6b17bcb62af819fe4b6ffb0196f5e27834b4736a5e1c`).
|
||
|
||
## 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.
|
||
|
||
## Search type icons, a kind filter and sorting (17 Oct 2026)
|
||
|
||
The omni-search results panel replaces each row's text type badge with a glyph and
|
||
gains the runs list's filter and sort controls. `android/` only; no new dependency
|
||
(the glyphs and the `FilterList`/`Sort` menu icons are from the already-declared
|
||
`material-icons-extended`), no Pipelines server/Go/installer/Docker file touched,
|
||
no run started from the app, and the operator's phone was never used.
|
||
|
||
- **Type glyph per result.** `OmniSearchResults.searchResultIcon` maps a hit to a
|
||
glyph: pipeline → the app's pipeline icon (`AccountTree`), run → `History`,
|
||
version → `Commit`, step → `Segment`, field → `Subject` (text lines, distinct
|
||
from the gallery's `Description` document glyph), and an unknown kind →
|
||
`HelpOutline`. An artifact reuses the gallery's own
|
||
classification (`artifactKind`/`artifactIcon` in `ui/graph/ArtifactType.kt`)
|
||
rather than a second mapping, so a search artifact and a gallery tile never
|
||
disagree. The glyph replaces the `LabelChip` badge (the chip is removed); the
|
||
payload decides the branch exactly as `searchRow` does.
|
||
- **Kind in words.** The glyph's `contentDescription` is `searchResultKindLabel`
|
||
("Pipeline", "Run", "Pipeline version", "Step", "Field", or "<Type>
|
||
artifact", e.g. "PDF artifact" via the new `artifactKindLabel`), so a screen
|
||
reader hears the type the icon alone cannot carry. The row and the filter use
|
||
the same kind vocabulary ("Fields").
|
||
- **Kind filter, narrowing server-side.** `SearchKindFilter` lists the filter
|
||
options - All kinds, Pipelines, Runs, Steps, Fields, Artifacts, Versions - and
|
||
each carries the server's own `SearchRequest.kind` value, sent verbatim
|
||
(`PipelinesRepository.search(query, kind)`). There is deliberately no "Prompts"
|
||
option: the server's search kinds are pipeline/version/run/step/field/artifact
|
||
only (`internal/protocol/search.go`), so a prompts filter could never match and
|
||
would visibly do nothing.
|
||
- **Sort, honest about its reach.** `SearchSort` offers Relevance (the server's
|
||
own score/recency/tie-break order, left untouched), Newest first (by `recency`)
|
||
and Name (by the displayed title). The server's search command takes no sort, so
|
||
Newest and Name order the results already in hand; the sort menu carries a
|
||
"Sort results in hand" caption, the collapsed summary appends " (in hand)" for
|
||
those two orders, and the icon's description reads "Sort results in hand". A
|
||
server-side sort would need a `sort` field on `SearchRequest`/the search
|
||
command.
|
||
- **Shared controls, remembered choice.** The panel header uses the same
|
||
`FilterMenu` and `SortMenu` the runs list uses (no new pattern), plus a one-line
|
||
`searchControlsSummary` ("All kinds · Relevance") so the collapsed controls show
|
||
the active choice. The header row carries a top inset so the filter's count badge
|
||
stays inside the panel's rounded surface. The kind and order persist as `search_filter_kind`/
|
||
`search_sort` in `SettingsRepository`, so they survive a query change, the
|
||
results streaming in, and a restart.
|
||
- **Tests.** `OmniSearchResultsTest` now covers the glyph per kind and per
|
||
artifact content type (checked against the gallery's
|
||
`artifactIcon(artifactKind(...))`), the kind-in-words label, the kind filter
|
||
narrowing a mixed list, the Relevance/Newest/Name ordering including a recency
|
||
tie and a title tie, the in-hand summary suffix, the filter-aware empty-state
|
||
line (`searchPanelEmptyMessage`, which replaced the panel's now-orphaned
|
||
`isEmptyResult` and names the active kind filter), and the stored-value
|
||
fallbacks; `ArtifactTypeTest` covers `artifactKindLabel`.
|
||
|
||
Evidence (macOS, JDK 17 from Homebrew `openjdk@17`,
|
||
`ANDROID_HOME=/Users/alan/Library/Android/sdk`, Gradle 8.11.1 from the wrapper
|
||
cache, every command `--no-daemon --offline --console=plain`; this build includes
|
||
the visual-review fixes: the header's badge inset, the visible in-hand sort
|
||
caption/summary, and the consistent "Field" vocabulary with a distinct glyph):
|
||
|
||
- `gradle :app:testDebugUnitTest --rerun` → `BUILD SUCCESSFUL`; the 47 result XMLs
|
||
aggregate to **433 tests, 0 failures, 0 errors, 0 skipped**
|
||
(`OmniSearchResultsTest` 28, `ArtifactTypeTest` 7).
|
||
- `gradle :app:assembleDebug` → `BUILD SUCCESSFUL`;
|
||
`app/build/outputs/apk/debug/app-debug.apk` is **18,715,466 bytes**, sha256
|
||
`f4cee0d4949ac587601f01a96733b3d865431bd5376ac6d7d182222a40999bf5`.
|
||
- **APK publish.** Copied to
|
||
`~/.local/share/pipelines/data/artifacts/231/4/pipelines-debug-wip-f31f150.apk`
|
||
(`f31f150` = `git rev-parse --short HEAD`). The LAN URL
|
||
`http://10.0.0.75:8080/artifacts/231/4/pipelines-debug-wip-f31f150.apk` returned
|
||
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
|
||
`Content-Length: 18715466`, and the downloaded bytes' sha256
|
||
`f4cee0d4949ac587601f01a96733b3d865431bd5376ac6d7d182222a40999bf5` matched the
|
||
local file.
|
||
- `gradle :app:lintDebug` fails on two pre-existing `NewApi` errors
|
||
(`res/values{,-night}/themes.xml`: `windowLightNavigationBar` requires API 27,
|
||
min is 26), unrelated to and not introduced by this change; the report names no
|
||
file touched by this change.
|
||
- No packaged template and no packaged authoring skill reference
|
||
(`internal/author/skill/references/*`, `internal/author/install.go`'s inventory)
|
||
documents the app's search panel - the only "omni search" reference describes
|
||
the TUI - so none needed updating.
|
||
|
||
Not verified in this pass: device frames of the panel and the open controls (the
|
||
visual review owns the device, per the brief's device policy); the 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.
|
||
|
||
## The conversation header names the session's model (17 Oct 2026)
|
||
|
||
A chat session's model was only visible in the session list row; inside a
|
||
conversation there was nothing saying what was answering. The conversation header
|
||
now shows the session's model beside its `Operator` tag and its directory, read
|
||
from the session the server already reports. `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.
|
||
|
||
- **One derivation, server-reported only.** `ui/chat/ChatFormat.kt` adds
|
||
`chatHeaderMeta(thread)`: the model id, the session's kind tag (through the
|
||
shared `sessionTagLabel`, refactored to a tag-value overload so the list row
|
||
and the header cannot label a tag differently) and the directory, joined with
|
||
` · `. Every part is a value the server reported; a blank part is omitted, so a
|
||
session the server reported without a model (or an older server that omits the
|
||
field) shows no model claim at all — never a guess and never a catalogue.
|
||
- **The open thread carries what the server reports.** `ChatThread` gains the
|
||
`tag` field (it already mirrored title/directory/model/agent/busy), and
|
||
`ChatStore` now folds the server's `model`/`agent`/`tag` into an already-open
|
||
thread on `sessionsLoaded` (not only on first `open`), and seeds them in the
|
||
`ensureThread` placeholder. So the header never shows a stale or missing model
|
||
after a list refresh or for a background chat.
|
||
- **The header surface.** `ChatScreen.ChatConversationPane`'s top bar title
|
||
becomes a two-line `Column`: the existing title, then the meta line in the
|
||
shared `pipelinesText().meta` role with `onSurfaceVariant`, ellipsised — no new
|
||
geometry literal.
|
||
|
||
**No model chooser is shipped, and why.** The brief asks to let the operator
|
||
choose a session's model and report the exact server change if the server has no
|
||
request for it. It does not: `ChatPromptRequest` carries `model`/`agent` on the
|
||
wire (`internal/protocol/chat.go`), but the endpoint drops them —
|
||
`handleChatPrompt` calls `broker.Prompt(ctx, sessionID, prompt.Text)` and
|
||
`opencode.Chat.Prompt` posts only `{"text": ...}` — and there is no request that
|
||
sets a session's model, nor any request that lists the endpoint's models or
|
||
agents to offer a choice from. Shipping a picker would be a control that does
|
||
nothing, so the create flow instead says so plainly ("This server has no request
|
||
for choosing a chat's model, so a new chat uses the server's default.") and the
|
||
header shows the model the server does report once the session exists.
|
||
|
||
The exact server change it would need: (1) forward the chosen model/agent —
|
||
extend `chatBroker.Prompt` and `opencode.Chat.Prompt` to accept them and include
|
||
`model`/`agent` in the `POST /api/session/{id}/prompt` body, and pass
|
||
`prompt.Model`/`prompt.Agent` from `handleChatPrompt`; (2) expose a catalogue
|
||
request (for example `chat_models`/`chat_agents`, answered from the endpoint's
|
||
model/agent list) so the client can offer only what the server reports; and
|
||
(3) optionally accept `model`/`agent` on `chat_create` so a session starts with
|
||
the operator's chosen default rather than the endpoint's. Until then the app is
|
||
honest: it shows what the server reports and does not pretend to set it.
|
||
|
||
Tests (4 new): in `ChatFormatTest`, that `chatHeaderMeta` shows the reported
|
||
model, tag and directory, that it never claims a model the server did not report
|
||
(blank thread → empty, tag only → `Operator`), and that a session tag and a
|
||
thread tag label the same; in `ChatSessionManagementTest`, that an open
|
||
conversation carries the model/agent/tag the server reports and that a later list
|
||
refresh folds the server's new model into the open thread.
|
||
|
||
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 / 505 tests / 0 failures / 0 errors / 0 skipped** (4
|
||
new). `gradle --offline --no-daemon :app:assembleDebug` → `BUILD SUCCESSFUL`; the
|
||
APK was published to this run's artifacts directory as
|
||
`pipelines-debug-wip-8e6cb39.apk` (18,706,104 bytes, sha256
|
||
`b52f2be1fcfce2654b90b9735ce03683fbf91e0a651b2b0ad49e92488d81ad05`; `8e6cb39` 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/272/1/pipelines-debug-wip-8e6cb39.apk`
|
||
(`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
|
||
`Content-Length: 18706104`).
|
||
|
||
Not verified in this pass: the header meta on a device and the create-flow note —
|
||
the brief keeps implementation verification to the build and the unit tests, and
|
||
visual review owns the operator's Pixel 9 Pro XL. No packaged skill reference was
|
||
touched: this is an app-UI change and no reference describes the chat surface.
|
||
|
||
## 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).
|
||
|
||
## Answer a waiting human decision from the phone (17 Oct 2026)
|
||
|
||
The last piece of the original goal the app was missing: a run parked on a person
|
||
is now answerable from the phone. `android/` only; nothing in the Pipelines
|
||
server, its Go source, the installer or the Docker files was touched, no
|
||
dependency was added (the new glyph comes from the already-declared
|
||
`material-icons-extended`), no run was started from the app and no server field
|
||
was added.
|
||
|
||
- **The same `decide` request the terminal uses.** `Protocol.DECIDE_RUN`
|
||
(`decide_run`) with `stage`, `option` and optional `feedback`, exactly the fields
|
||
`internal/protocol/message.go` carries and the TUI's Enter builds
|
||
(`internal/tui/decision.go`); `PipelinesRepository.decideRun` sends them and
|
||
returns the resumed run's detail. There is no second mechanism.
|
||
- **Surfaced through the existing push path, with no server change.** A waiting
|
||
transition already arrives as a `run_event` with `status: waiting` and a waiting
|
||
step delta. The compact delta omits the waiting step's `output` — where the
|
||
author's options and instructions are recorded — so `runDetailNeedsFullSync` now
|
||
also fetches the full run on a waiting run/step; that fetch fills the recorded
|
||
evidence and the decision appears live, with no refresh. `RunState` gained
|
||
`Waiting` (violet, `FrontHand`, its own label) so the runs list and the run
|
||
summary show "waiting" instead of the unknown fallback. `lastWaitingStep`,
|
||
`waitingOptions`, `waitingPrompt` and `humanOptions` mirror `tui.lastWaitingStep`,
|
||
`protocol.WaitingOptions`/`WaitingPrompt` and `stage.HumanOptions`.
|
||
- **Where it is reachable.** A prominent "Waiting for your decision" card with a
|
||
Decide action sits above the run detail's tabs (on any tab — opening the run is
|
||
enough) and at the top of the waiting stage's pane; both open the same sheet. It
|
||
is not wired to a submenu, and an attention surface (another item) renders the
|
||
same shared `DecisionPrompt`/`pendingDecision` component.
|
||
- **The sheet.** It shows the run and the waiting stage, the author's recorded
|
||
instructions, every option exactly as written (its edge key) with the label it
|
||
routes to (`deploy → SUCCESS`), an optional feedback field and a deliberate
|
||
`Confirm decision` button. Selecting an option only selects it; the button stays
|
||
disabled until one is chosen, so a stray tap cannot answer by accident.
|
||
Answering applies the returned run immediately, so the run's new stage is shown
|
||
without a manual refresh.
|
||
- **Refusals are honest.** A refusal (the run moved on, the stage changed, another
|
||
client answered first) keeps the sheet open with the server's own message
|
||
verbatim, and the run is re-read silently so the app stops offering a decision
|
||
that is gone — never a silent failure and never a faked success.
|
||
|
||
Pure helpers: `pendingDecision` (the step's recorded evidence first, the pinned
|
||
graph as the fallback), `DecisionOption`, `DecisionDraft` (the deliberate-confirm
|
||
gate) and `decisionRefusalMessage`.
|
||
|
||
Tests (13 new): `HumanDecisionTest` (6 — the recorded options/instructions,
|
||
non-string tolerance, the sorted non-error-edge fallback, the last waiting step
|
||
and the `decide_run` envelope with its exact wire names) and `DecisionTest` (7 —
|
||
the waiting run's stage/options/targets/instructions, non-waiting runs, the graph
|
||
fallback, the prompt fallback, stage inference, the confirm gate with optional
|
||
feedback, and the verbatim refusal message). `RunEventsTest`'s sync rule gained
|
||
the waiting cases and `RunStatusTest` the waiting status mapping.
|
||
|
||
Evidence (implementer pass, macOS, cached Gradle 8.11.1 at
|
||
`~/.gradle/wrapper/dists/gradle-8.11.1-bin/bpt9gzteqjrbo1mjrsomdt32c/gradle-8.11.1/bin/gradle`,
|
||
JDK 17 from Homebrew `openjdk@17`,
|
||
`ANDROID_HOME=/Users/alan/Library/Android/sdk`, every command
|
||
`--no-daemon --offline`):
|
||
|
||
- `gradle :app:testDebugUnitTest --offline --no-daemon --console=plain` →
|
||
`BUILD SUCCESSFUL`; the JUnit XMLs total **57 suites / 518 tests / 0 failures /
|
||
0 errors / 0 skipped** (up from 55 suites / 505 tests).
|
||
- `gradle :app:assembleDebug --offline --no-daemon --console=plain` →
|
||
`BUILD SUCCESSFUL`; `app/build/outputs/apk/debug/app-debug.apk` is 18,519,392
|
||
bytes, sha256
|
||
`4086e6dab453dba81fd0e2f023b0c6713600a68f78d95ada073e0df785b971a1`
|
||
(`--rerun-tasks --no-build-cache`, reproduced byte-for-byte by a second full
|
||
rebuild; an incremental package is not byte-reproducible), published to this
|
||
run's artifacts directory as `pipelines-debug-wip-d48175a.apk` (`d48175a` =
|
||
`git rev-parse --short HEAD`; the tree is uncommitted WIP on top of it) and
|
||
served at
|
||
`http://10.0.0.75:8080/artifacts/277/1/pipelines-debug-wip-d48175a.apk`
|
||
(`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
|
||
`Content-Length: 18519392`); `10.0.0.249` served it too.
|
||
|
||
Not verified in this pass: the on-device sheet/feedback/refusal behaviour and the
|
||
screenshots — the brief keeps implementation verification to the build and the
|
||
unit tests, and visual review owns the operator's Pixel 9 Pro XL. The "attention
|
||
surface" named in the brief is not present in this tree, so the decision is
|
||
reachable from the run detail and its stage and the shared component is ready for
|
||
it. No packaged skill reference was touched: the decide protocol is unchanged and
|
||
already documented, and this is an app-UI change.
|
||
|
||
## Run attention surface and phone notifications (17 Oct 2026)
|
||
|
||
> Supersedes the note at the end of the previous section: the run-attention
|
||
> surface the brief named is now present in this tree. The server publishes the
|
||
> notification; the app shows the same information in one live surface.
|
||
|
||
A run that needs a person — waiting for a human decision, or failed — now reaches
|
||
the operator through the ntfy they already run, and the app answers "what needs me
|
||
now" in one ordered list. The server change is the smallest that reuses the
|
||
existing delivery machinery; there is no second publisher, topic or service.
|
||
|
||
- **One run-level notification, reusing the stage's publisher.** `internal/server/
|
||
notify.go` adds `notifyRun`, called from `finishRunState` (failed) and when a run
|
||
parks on a human (`runner.go` `runLoop`). It publishes to the same `system`
|
||
destination through the unchanged `stage.PublishNtfy`, with the operator's
|
||
configured token handling, so nothing is duplicated. `runAttentionEvent` maps
|
||
only `waiting` and `failed`; queued/running/succeeded/canceled/interrupted
|
||
produce `""` and publish nothing.
|
||
- **No storms.** `runner.attentionSent` (guarded by `attentionMu`) records
|
||
`sequence:event` per run before publishing, so a run that stays waiting is never
|
||
republished on a re-request or restart, and a stage `notify` policy that already
|
||
covers the same event (`on=waiting`, or a failure hook) marks it first so the
|
||
run-level default is suppressed. The set is dropped when the run is terminal
|
||
(`forgetAttention`). A delivery failure is logged, never fails the run, and is
|
||
not retried.
|
||
- **The payload opens the run.** It names the run id and pipeline, and carries a
|
||
`click` action `pipelines://run/<id>` (validated in `validNtfyClick` — absolute
|
||
URL, no userinfo, no fragment, no credentials). `AndroidManifest.xml` declares
|
||
the `pipelines`/`run` deep link on `MainActivity` (`launchMode=singleTop`);
|
||
`runIdFromDeepLink` parses it and `PipelinesApp` opens that run once, clearing
|
||
the link so a rotation re-opens nothing. It opens a run; it starts nothing.
|
||
- **One attention surface.** `ui/Attention.kt` is the pure model: a run status maps
|
||
to `Decision`/`Failed`/`Finished` (or nothing), and `attentionEntries` orders by
|
||
kind then newest-first. `ui/components/AttentionSurface.kt` renders a floating
|
||
indicator in the same bottom container as the destination pill — visible from
|
||
every destination and window width — that opens a bottom sheet listing the run,
|
||
its pipeline and what it needs, with a per-row dismiss. The indicator draws
|
||
nothing when the list is empty. No competing navigation surface is added.
|
||
- **Live and self-clearing.** The list is derived from the same `RuntimeState`
|
||
pushes the runs list folds, so an entry appears with no refresh and clears when
|
||
the run is resolved (the decision answered, the failure retried). A finished run
|
||
clears once the list is opened; any entry can be deliberately dismissed;
|
||
dismissals and looked-at finishes persist in `SettingsRepository` as one
|
||
serializable preference. Opening a non-decision entry deals with it.
|
||
|
||
Tests: `internal/server/notify_test.go` covers the event mapping (waiting, failed,
|
||
nothing else) and the real HTTP delivery (destination, topic, click, no
|
||
duplicate); `AttentionTest` (13 cases) covers the app's mapping, ordering,
|
||
appearing from a pushed event, clearing on resolution, dismissal, the empty case,
|
||
persistence and the deep-link parser.
|
||
|
||
Evidence (this pass, macOS, JDK 17 `/opt/homebrew/opt/openjdk@17`, cached Gradle
|
||
8.11.1, `ANDROID_HOME=$HOME/Library/Android/sdk`):
|
||
|
||
- `go build ./...` → success; `go test ./internal/server/... ./internal/stage/...
|
||
./internal/author/...` → `ok` for all three packages.
|
||
- `gradle :app:testDebugUnitTest --offline --no-daemon --console=plain` →
|
||
`BUILD SUCCESSFUL`; the JUnit XMLs total **58 suites / 531 tests / 0 failures /
|
||
0 errors / 0 skipped** (up from 57 suites / 518 tests: the new `AttentionTest`).
|
||
|
||
Not verified in this pass: the on-device indicator/list/finished/empty screenshots
|
||
and the phone's own notification — the brief keeps ordinary code review to the
|
||
build and the unit tests, and visual review owns the operator's Pixel 9 Pro XL.
|
||
The concrete payload delivered to the local ntfy service was reproduced by the
|
||
code review with a live curl subscriber; the device captures are visual review's.
|
||
|
||
## Destination pill stands down in an open conversation (17 Oct 2026)
|
||
|
||
The floating destinations pill was drawn over the bottom of every screen,
|
||
including an open chat, where it sat on the composer and the newest message and
|
||
competed with the send/stop controls. It now stands down while the Chat
|
||
destination is showing an open conversation and stays everywhere else,
|
||
unchanged. `android/` only; no new dependency, no run started from the app, no
|
||
server/installer/Docker file touched, and the operator's Pixel was never used.
|
||
|
||
- **One rule.** `destinationPillVisible(currentRoute, conversationOpen)` is false
|
||
only for `chat` with an open conversation — a session's transcript and composer
|
||
— and true for the chat list and every other destination. `conversationOpen` is
|
||
the new `AppViewModel.conversationOpen` (`chatStore.state.map { it.active != null }`,
|
||
`distinctUntilChanged`), read from the same store the chat surface renders, so a
|
||
background open chat never hides the pill elsewhere and a streamed chat delta
|
||
never recomposes the app shell.
|
||
- **The space, not just the pill.** `destinationPillReserve(pillVisible)` returns
|
||
the named `DESTINATION_PILL_RESERVE` while the pill is drawn and `0.dp` while it
|
||
is hidden: the content Column keeps clearing a drawn pill, and a hidden pill
|
||
leaves no empty band at the end of scrollable content, so the composer sits at
|
||
the true bottom. The pill and its reservation are driven by the one predicate,
|
||
so no frame has a drawn pill over content it does not clear or a reserved gap
|
||
behind a hidden pill; the viewport height is constant for as long as a
|
||
conversation is open, so the composer and the newest message do not move while
|
||
it is shown. Works with the keyboard open: the composer's own `imePadding` and
|
||
the pill's `paneSafeArea()` are unchanged, with no pill left to sit over them.
|
||
- **Still escapable.** Nothing about leaving a conversation changed: its top-bar
|
||
back arrow (`Back to chats`), the system Back button/gesture (`ChatScreen`'s
|
||
`PredictiveBackHandler`), and on a wide window the covered chat-list strip
|
||
(`SlidingPaneStack.onPopTo`) all return to the list. The pill was never the way
|
||
out; Back is.
|
||
- **Nothing else touched.** The pill's destinations, travelling indicator,
|
||
morph-into-search and behaviour on every other screen are untouched; the
|
||
attention indicator is unchanged.
|
||
|
||
Evidence (this pass, macOS, JDK 17 `/opt/homebrew/opt/openjdk@17`, cached Gradle
|
||
8.11.1, `ANDROID_HOME=$HOME/Library/Android/sdk`, `--offline --no-daemon`):
|
||
|
||
- `gradle :app:testDebugUnitTest --offline --no-daemon --console=plain` →
|
||
`BUILD SUCCESSFUL in 11s`; the JUnit XMLs total **58 suites / 533 tests / 0
|
||
failures / 0 errors / 0 skipped** (up from 531: `PipelinesNavTest` gains
|
||
`thePillStandsDownOnlyWhileAConversationIsOpen` and
|
||
`theReserveTracksTheDrawnPillSoContentNeitherJumpsNorLeavesAGap`).
|
||
- `gradle :app:assembleDebug --offline --no-daemon --console=plain` →
|
||
`BUILD SUCCESSFUL`; `app/build/outputs/apk/debug/app-debug.apk` is **18,535,932
|
||
bytes**, sha256 `fc872b5398c231f053cd6e5f6794b2b6c2a8f947314ba0de02851dab2a95c3e`.
|
||
- **APK publish.** Copied to
|
||
`~/.local/share/pipelines/data/artifacts/287/1/pipelines-debug-wip-890d267.apk`
|
||
(`890d267` = `git rev-parse --short HEAD`; the tree is uncommitted WIP on top of
|
||
it), sha256 matched. The LAN URL
|
||
`http://10.0.0.75:8080/artifacts/287/1/pipelines-debug-wip-890d267.apk` returned
|
||
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
|
||
`Content-Length: 18535932`.
|
||
|
||
Not verified in this pass: the conversation/list screenshots — the brief keeps
|
||
implementation and ordinary code review to the build and the unit tests, and
|
||
visual review owns the operator's Pixel 9 Pro XL (its captures are the ones the
|
||
brief names: a conversation with no pill, and the chat list with it).
|
||
|
||
## Run title readability: whole in the run view, two lines in the list (17 Oct 2026)
|
||
|
||
A run's title is derived from its prompt, so it is often long. The run view now
|
||
guarantees the operator can read it whole, while the places that are one of many
|
||
clamp deliberately. `android/` only; no new dependency, no Pipelines
|
||
server/Go/installer/Docker file touched and no run started from the app; the build
|
||
and unit tests only, no device command run.
|
||
|
||
- **Run view shows the whole title.** The run-summary title line rendered
|
||
`runLabel(run.title, run.name)` with the Compose default; it now states the
|
||
intent with `RUN_VIEW_TITLE_LINES` (`Int.MAX_VALUE`) and `TextOverflow.Clip`, so
|
||
it wraps over as many lines as it needs and is never ellipsised. The fixed-height
|
||
M3 app-bar copy stays a compact one-line label; the summary's scrollable title is
|
||
the complete one.
|
||
- **Runs-list rows grow, then clamp.** `RunHistoryScreen.RunRow`'s title went from
|
||
`maxLines = 1` to `RUN_ROW_TITLE_LINES` (2), so a longer title takes a second
|
||
line before it ellipsises; the row's glyph, status chip and meta line keep their
|
||
alignment and the selection highlight and tap target are unchanged.
|
||
- **Stage-pane context line.** `StageDetailPane`'s run-label line went from
|
||
`maxLines = 1` to `STAGE_RUN_LABEL_LINES` (2) — the pane is compact context, not
|
||
the place the whole title lives.
|
||
- **One named budget.** `ui/RunIdentity.kt` holds the three named line budgets so
|
||
the choice is deliberate at each call site. `RunTitlesTest` (4 cases) pins them
|
||
and asserts a clamping place is never more generous than the run view;
|
||
`RunIdentityTest` gained a case that `runLabel`/`runIdentity` never shorten a
|
||
long title, so re-introducing a truncating helper here fails.
|
||
|
||
Tests: the 57 result XMLs aggregate to **513 tests, 0 failures, 0 errors, 0
|
||
skipped** (`RunTitlesTest` 4/0, `RunIdentityTest` 6/0).
|
||
|
||
Evidence (macOS, JDK 17 from Homebrew `openjdk@17`, Gradle 9.7.1 `--offline`,
|
||
`--no-daemon`, `ANDROID_HOME=/Users/alan/Library/Android/sdk`):
|
||
|
||
- `gradle :app:testDebugUnitTest --no-daemon --offline --rerun` → `BUILD
|
||
SUCCESSFUL`.
|
||
- `gradle :app:assembleDebug --no-daemon --offline` → `BUILD SUCCESSFUL`;
|
||
`app-debug.apk` 18,486,624 bytes, sha256
|
||
`2b23762b54f011bbec680804a232f32bd43c244fb52c465a0f4b2c2c9a0148cb`.
|
||
- **APK publish.** Copied to this run's artifacts directory as
|
||
`pipelines-debug-wip-2bc00a2.apk` (`2bc00a2` = `git rev-parse --short HEAD`, the
|
||
tree being uncommitted WIP on top of it), served at
|
||
`http://10.0.0.75:8080/artifacts/278/4/pipelines-debug-wip-2bc00a2.apk`
|
||
(`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`; the
|
||
downloaded bytes hash to the same sha256).
|
||
|
||
Not verified in this pass: how the wrapping summary title, the two-line list row
|
||
and the two-line stage header actually render — that needs the device, which this
|
||
build-and-unit-test pass did not use; visual review owns the operator's Pixel 9
|
||
Pro XL.
|