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