6229fc9db5
The stage detail pane covered the status bar. Introduce one shared paneSafeArea() (WindowInsets.safeDrawing: status bar, display cutout, navigation bar, gesture area and IME) and apply it from the live window insets across the pane stack: - SlidingPaneStack uses it (unioned with systemGestures) for the covered peeks' strip geometry. - Each pane's Scaffold reserves it once via contentWindowInsets, and its TopAppBar reserves the top/horizontal part, so no pane sits under the status bar, a cutout, the navigation bar or the IME. Applied to the five stacked panes and SettingsScreen. - The connection banner owns the top inset and the NavHost consumes it (paneSafeArea().only(Top), was statusBars) so the inset is never doubled. - The floating destinations pill clears the same safe area, so the keyboard no longer hides it. Scrollable content stays inside the remaining space rather than clipping. android/README.md records the design and emulator-5554 verification.
1676 lines
107 KiB
Markdown
1676 lines
107 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`.
|