Turn the stage detail into the rightmost pane of a bounded three-level stack and show every run artifact in a summary gallery. - The stage detail opens as a real level-2 pane from both entry points (a Timeline row and a graph node). StageDetailPane is wrapped in the same Scaffold/TopAppBar with a back arrow as the other panes, and its identity/result facts (status, outcome, target, duration, visit, model target) render outside any collapsible so a fresh pane is never empty. StageDetailSheet, ModalBottomSheet and RightSlidingPanel are removed. - SlidingPaneStack replaces SlidingMasterDetail: pane 0 fills the host, panes 1 and 2 overlay at peek*level, each covered pane keeps one tappable peek strip, and MasterPane/backStep/popTo/MAX_PANE_DEPTH are the pure model. The peek tap, the pane back arrow, the system Back button and the predictive-back gesture all pop exactly one level. - New pure runArtifactGroups(steps) groups a run's artifacts by stage and visit (stable order, duplicates kept, empty run -> empty) and artifactsEmptyMessage distinguishes the running "capture pending" case. ArtifactGallery renders image thumbnails (tap opens full size) and non-image rows with name, size, content type and open/copy; urls resolve through ServerUrl, never a hardcoded host. - Run Summary shows the run gallery and the stage pane shows that visit's group, keeping the existing per-visit artifacts summary and notes. - Tests updated/added (PaneStateTest, SlidingPaneStackTest, ArtifactGroupsTest, ArtifactGalleryTest, StageDetailSheetTest, refreshed DetailTabsTest/PipelinesNavTest, CollapseRemovalTest kept green) and android/README.md records the pass, evidence and not-verified list.
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), andANDROID_HOME/ANDROID_SDK_ROOTset. - 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:
cd android
gradle wrapper --gradle-version 8.9
Until then, build with a locally installed Gradle:
cd android
gradle :app:assembleDebug
Build, test and install
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
Configuration
Open the Settings tab and enter:
- Server URL —
ws://HOST:PORT/connect(LAN/VPN) orwss://…/connect(proxy/VPN). A path is optional and defaults to/connect, matching the Go server'sGET /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.mdandcompose.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/#successterminals sharing a lower row and arrows entering their top borders (anerror -> #failureroute 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 (routePointscomputes the path once per layout and stores it onEdgeLayout.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 purezoomAboutkeeps the content point under the fingers fixed (clamped toMIN_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 inrememberSaveableand the panel refits on resize. Because the panel lives inside each screen'sverticalScrollcolumn, growing it only extends it below the fold, so expanding also requestsBringIntoViewRequesterto 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 Steps, 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 sections themselves live in aHorizontalPager: tapping a tab (or swiping) slides that section's panel in, a later section entering from the right and an earlier one from the left, following the index order. The pager composes only the visible page at rest, each section is a singleLazyColumn, and the Graph tab keeps the full-heightWorkflowGraphpanel with its Fit and expand controls. Narrow windows show a horizontally scrollingPrimaryScrollableTabRow; wide windows show an always-visible selectable rail (icon + label, no collapse control).selectedIndexis the single source of truth: an external change (Back) scrolls the pager and a settled pager reports the new index, guarded against feedback loops. The tabs carry real tab semantics (Role.Tab+ selected state), so selection is never conveyed by colour alone, and the selected index isrememberSaveable(survives recomposition, configuration change and process death) and clamped byclampTabIndex. - 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/#failurenamed as terminals), memory, limits and notification policy, skipping what a stage does not have. The rows come from the samestageDefinitionFields/StageFieldRowthe 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.ktcard:surfaceContainerrole, 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 = nullrenders 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 isrememberSaveable, so it survives configuration changes; the sections are items of the tab's singleLazyColumn, 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 fromLocalConfiguration.current.screenWidthDp): both window widths use one sliding three-level pane stack (ui/components/SlidingPaneStack.kt) — pane 0 is the pipeline (or run) list filling the window, pane 1 the selected detail and pane 2 the selected stage/graph node, each overlaying the one below atpeek * levelleaving a tappable peek strip of the pane it covers on the left; 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 isrememberSaveable, per section and per screen, defaulting to expanded. Real lists (versions, steps, session evidence) are items of the one outer list, so nothing nests a scrollable. - Steps render as a timeline in run detail: a leading status glyph connected to
the next step by an outcome-coloured line (kept aligned with the step title),
the stage with its sequence and an outcome chip. A step's metadata is a set of
aligned label/value rows (
KeyValueRow) — paired side by side in two columns on a wide window and stacked in one column on a narrow one — with a single consistent vertical rhythm (one bottom gap per step, no doubled gap when a step has no expandable detail) and full-width monospace evidence cards. Every retained field stays: status, outcome, duration, visit/maxVisits/limitReached/ model target, target, session id, agent active, diagnostic and, behind the collapsed-by-default detail, input, output, transcript, file changes (including binary/truncated and skipped) and notification receipts. - The runs list is grouped by day (
Today/Yesterday/date, newest first) under sticky headers, with the usage aggregates as a metrics block (total, average viaformatDuration, 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 rawresultPreviewis 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 toMaterialThemeand 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
usageaggregates, 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 viaget_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 reusedrequest_key≤128 chars, the configured absolute workspace andinput.prompt) and cancel run (confirmation; sends theRunID, 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:assembleDebugand:app:testDebugUnitTestall 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 newzoomAboutanchor/clamp cases, plus duration formatting, run-state mapping and run day-grouping). Re-run with--rerun-tasksto confirm.- The debug APK was installed and driven on the
Pixel_Fold_API_36emulator (Android 16,adb shell cmd uimode night yes) against a live server atws://10.0.2.2:8080/connectwith workspace/Users/alan/repos/pipelines. Settings, pipeline list (all 9 pipelines), pipeline detail, the workflow graph, run history and run detail were captured tocaptures/andcaptures/style_pass/(both git-ignored) and reviewed. adb logcatfor the app package contained noFATAL 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) holdspipeline_detail_before/afterandrun_detail_before/afterpairs 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 logcatshowed noFATAL EXCEPTIONand 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:testDebugUnitTestreported 76 tests, 0 failures (up from 60: newStageDetailSheetTestfor the stage/step field derivation andStepMetaTestfor the step metadata pairing + details predicate, plus the icon/rail-width assertions inDetailTabsTestand the file-change/notification formatting inFormatTest).:app:assembleDebugand:app:installDebugsucceeded; the install reportedInstalled 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.pngfollowed byadb -s emulator-5554 pull(neverexec-out … >), tocaptures/space_pass/(git-ignored):narrow_pipeline_top_tabs(narrow window, tabs across the top),source_tab_narrow(rendered definition) andsource_tab_raw_narrow(theRawtoggle revealing the exact markdown),wide_source_rail_expanded(icon+label rail, Source tab) andwide_source_rail_collapsed(icon-only rail, content visibly wider),wide_run_steps_expandedandwide_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), pluswide_graph_stage_sheet(tapping a stage on the Graph tab still opens the refactoredStageDetailSheet). 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 density390→401: the activity recreated and the collapsed strip stayed collapsed (Expand tabswas still the control's description after the change; capturewide_detail_rail_collapsed_config_change). The saved tab index is clamped byclampTabIndex(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 -dcontained 0FATAL EXCEPTIONlines and 0E AndroidRuntimelines. The emulator was stopped withadb emu kill; noqemu-system-aarch64-headlessprocess 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.
GraphPaletteis a curated, fixed palette plus a pure deterministic outcome→index mapping (nohashCode() % 4).errorstays the theme error role andsuccessthe 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:GraphPaletteTestchecks the helper against known reference ratios (white/black 21,#777/white 4.48) and asserts every palette colour is ≥ 4.5:1 againstDarkSurface 0xFF0E1513(measured values range from 8.63:1,approved, to 13.78:1,fast;success11.73:1 anderror10.89:1 as the dark scheme supplies them). - Timeline + visit tabs. The run-detail
Stepstab is renamedTimeline(key keptsteps); 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 sharedStageDetailSheet. The sheet now takes a stage's orderedrunStepsplus aninitialVisitIndexand shows avisit 1..Ntab row only when there is more than one visit; the timeline opens on the tapped visit and the graph on the most recent.runStepFieldsgained 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 flatSurface, thinHorizontalDivider, leading element + title + secondary line, no per-row elevation) instead of a card per item. The selected row uses the same tonalsecondaryContainer/onSecondaryContainertreatment as the tab rail and destinations, exposed asselectableselected 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
NavigationBaris replaced by a floating roundedSurfaceat 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 plusRole.Tabselected 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 inapp/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 → RunningAutoMirrored.DirectionsRun, QueuedSchedule, SucceededCheckCircle, FailedError, CanceledCancel, InterruptedPauseCircle, ActiveBolt, UnknownAutoMirrored.HelpOutline. The debug APK is ~17 MB; note thatapp/build.gradle.ktssetsrelease { isMinifyEnabled = false }, so R8 does not strip unused extended icons in the current release config (that stripping only applies to a minified build). :app:testDebugUnitTestreported 93 tests, 0 failures (newGraphPaletteTest,TimelineTest,PipelinesNavTest; extendedStageDetailSheetTestandDetailTabsTest;StepMetaTestwas removed with the inline metadata grid it covered).:app:assembleDebugsucceeded.- Captures were written with
adb -s emulator-5554 shell screencap -p /sdcard/shot.pngfollowed byadb -s emulator-5554 pull(neverexec-out … >), tocaptures/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 crops16_pill_wide_2x,17_tabs_wide_2x,18_runstatus_icons_2x,18b_failed_status_2x,19_pill_narrow_2x. adb -s emulator-5554 logcat -dcontained 0FATAL EXCEPTIONlines and no Compose runtime exception. The wide layout was exercised withadb shell wm size 2000x3400(≈820dp at density 390); the emulator was stopped withadb emu killpluskill -9of any survivingqemu-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.
RunStepnow models the server'sartifacts(StageArtifact{name, size_bytes, content_type, url}),artifacts_skippedandartifacts_truncatedwith the exactinternal/protocol/runs.gowire names.ui/graph/Artifacts.ktrenders one row per file (name,humanBytessize, content type) with an open (ACTION_VIEW) and a copy-link action, an inline image thumbnail (OkHttp +BitmapFactorywithinSampleSizeoff the main thread, bytes cached once per URL) and a full-size view on tap; other types get a type icon. URLs are resolved byServerUrl.resolveArtifactUrlagainst the configured server URL (ws→http/wss→https,/connectdropped), never a hardcoded host; with no URL configured the actions are disabled and a hint is shown. Empty/partial states reuse the TUI strings frominternal/tui/file_changes.go. The Timeline rows carry a subtleAttachFileindicator (hasArtifacts) with a per-visitcontentDescription. - Collapsed defaults + self-describing titles.
SectionExpansionStatenow 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 byevidenceSectionTitle, e.g.Evidence - step 4, ui_reviewer visit 1, opencode, correlatingSessionEvidence.sequencewith 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
ScaffoldinPipelinesAppnow usescontentWindowInsets = 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 viawindowInsetsPadding(WindowInsets.navigationBars). While the connection banner is visible it owns the status-bar inset (padding inside itsSurface) and theNavHostbelow consumesstatusBarsso the app bar is not double-padded. - APK publish.
:app:assembleDebugproducedapp/build/outputs/apk/debug/app-debug.apk(18,181,943 bytes, sha25641c9df314da40bb19df7e3d90f27a83339a275768cefee537c4ba796efe01eab, 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 touchingandroid/) with a matchingshasum -a 256. At 17.3 MiB it exceeds the 8 MiB per-file inventory cap (internal/server/artifacts.gomaxArtifactFileBytes = 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.kthoists its derivations withremember(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.ArtifactBytesCacheis a byte-boundedLruCache(16 MiB) rather than an unbounded map, so a long session cannot retain every fetched artifact.artifactCaptureNotesreturns no notes for an empty artifact list, matchinginternal/tui/file_changes.goartifactLines(which returns nothing when the list is empty); the empty-state summary is unchanged.- The field-section title fallback is the pure
fieldSectionTitle, covered byTimelineTest#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:testDebugUnitTestreported 103 tests, 0 failures (newProtocolModelTest#runStepArtifactsParseWithExactWireNamesOrAbsent,FormatTestcases forhumanBytes/artifactMetaLine/artifactsSummary/artifactCaptureNotes,ServerUrlTest#resolvesArtifactUrlAgainstTheConfiguredServerUrlandresolveArtifactUrlReturnsNullWhenUnconfiguredOrBlank,DetailTabsTest#sectionsStartCollapsedAndToggleIsRemembered, andTimelineTestcases forhasArtifacts/evidenceSectionTitle/fieldSectionTitle).:app:assembleDebugsucceeded (18,181,943-byte debug APK).:app:lintDebugstill reports the two pre-existingNewApierrors forandroid:windowLightNavigationBar(minSdk 26) inres/values/themes.xmlandres/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 hardcodedlocalhost/10.0.2.2host.curl -IreturnedHTTP/1.1 200 OK,Content-Type: application/vnd.android.package-archive,Content-Length: 18181943; a streamedGETpiped toshasum -a 256returned41c9df314da40bb19df7e3d90f27a83339a275768cefee537c4ba796efe01eab, equal to the localapp-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 thanmaxArtifactFileBytes(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 noSlidingMasterDetail.kt,RightSlidingPanelorModalBottomSheetin 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, theonTogglePaneparameter and the "Collapse list pane"IconButtonon both list top bars,LIST_PANE_WIDTH(360.dp) andCOLLAPSED_LIST_PANE_WIDTH(56.dp), and the observed-side rail collapse (RailToggle,railWidthDp,COLLAPSED_RAIL_WIDTH_DP,WIDE_RAIL_WIDTH_DPcollapse branch, "Collapse tabs") are all gone; the wide rail is always visible as the section index.ui/CollapseRemovalTest.ktscanssrc/main/javafor those identifiers and fails if any return. The old full-screenpipeline/{id}/{version}andrun/{id}routes were removed, sodestinationSelectedis a plain route equality. - One shared host, one slide.
ui/components/SlidingMasterDetail.ktis 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 singleanimateDpAsState(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 ismeasuredWidth - 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 ispeekWidthDp(minimumInteractive, startInset) = maxOf(PEEK_WIDTH_DP, minimumInteractive + startInset), so the tappable strip left after the left system-gesture inset is still at leastLocalMinimumInteractiveComponentSize(48dp). The strip is positioned clear of the status/nav bars and the gesture area by offsetting/sizing it withWindowInsets.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 defaultspring()with no literal). - Sections open to the right.
DetailTabskeeps the index fixed in place and moves the section bodies into aHorizontalPager(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.ktbackStep) 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.PredictiveBackHandlerhandles the gesture;android:enableOnBackInvokedCallback="true"was added to the manifest. - Saved state.
PaneSelection(pane, item id/version, section index) is all primitives with aSaver, so the open pane and selected section survive rotation, configuration change and process death.rememberPagerStatealso saves the pager page. - Secondary surface. The wide stage-detail overlay reuses the same
right-slide (
RightSlidingPanel); on a narrow window it deliberately keeps itsModalBottomSheet(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 inStageDetailSheet.ktare 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:testDebugUnitTestreported 112 tests, 0 failures (newPaneStateTest— pane open,backStepat section > 0 / section 0 / list, section ordering and slide direction,Saverround trip and primitive payload; newCollapseRemovalTest; newSlidingMasterDetailTestforpeekWidthDp;DetailTabsTestupdated andPipelinesNavTestupdated for the removed routes). -
:app:assembleDebugsucceeded.:app:lintDebugstill reports only the two pre-existingNewApierrors forandroid:windowLightNavigationBar(minSdk 26) inres/values/themes.xmlandres/values-night/themes.xml; those files were not modified. -
grepoverapp/src/mainfor 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 dumpshowed 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 densitychange 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 logcatfor the package contained noFATAL EXCEPTIONorAndroidRuntimeerror during the sweep, and no run was started from the app.
- Tapping a pipeline row slid the detail in;
-
:app:testDebugUnitTestand 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) andslide-W5-closed-list(strip tapped again, list restored, byte-identical toslide-W1-list); the narrow window (wm size 1080x2340, ≈524dp) has the same setslide-N1…slide-N5(top tab row,N3graph,N4back to Summary,N5closed, identical toN1). - 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], theplannerheading and theDefinitionsection, dismissed by tapping the strip) and tapping a graph node (W9-graph-stage-overlay).
- The wide sequence was captured to
-
APK publish.
app/build/outputs/apk/debug/app-debug.apk(18,184,868 bytes, sha2567942795c1d979a66e4759a0c3e3f0399d60e256b29ba4a7266dfc52142245ac8) 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 frompython3 scripts/lan-address.py, neverlocalhost/10.0.2.2) returnedHTTP/1.1 200 OK,Content-Type: application/vnd.android.package-archive,Content-Length: 18184868; a streamedGET | shasum -a 256returned7942795c1d979a66e4759a0c3e3f0399d60e256b29ba4a7266dfc52142245ac8, 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)
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.
StageDetailSheetand itsModalBottomSheet/RightSlidingPanelbranches are gone.StageDetailPane(ui/graph/StageDetailPane.kt) is the stage level of the stack, wrapped in the sameScaffold/TopAppBarwith a back arrow as the other panes. Both entry points — a Timeline row and a graph node — now setPaneSelection(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 sharedSectionHeader+rememberSectionExpansion(stageKey).runStepFields,stageDefinitionFields,StageFieldRow,StageTypeChip,controlVisitLabel,numberFields/terminalFieldsand the visit tab row are all kept. - One three-level stack.
ui/components/SlidingPaneStack.ktreplacesSlidingMasterDetail: pane 0 fills the host, panes 1 and 2 overlay it atpaneOffsetDp(level, peek) = peek * levelandpaneWidthDp(hostWidth, level, peek) = hostWidth - peek * level(derived from the one namedPEEK_WIDTH_DPtoken and the measured width; no new offsets). Each covered pane keeps exactly one peek visible and its peek strip is tappable, callingonPopTo(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) andpopTo(selection, level)are the pure model;PaneSelectioncarriesstageKey/stageVisitand its saver encodes six primitives. - Back and the outside tap agree.
PredictiveBackHandleris enabled fordepth >= 1and 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.kthas the purerunArtifactGroups(steps)(grouped by stage then visit fromrunTimeline, stable order, duplicate names kept, empty run → empty) andartifactsEmptyMessage(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,humanBytessize, 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 unchangedArtifacts · N recordedsummary and capture notes. Every url resolves throughServerUrl.resolveArtifactUrl(no hardcoded host), andArtifactImage/ArtifactBytesCacheremain 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:testDebugUnitTestreported 122 tests, 0 failures (rewrittenPaneStateTest— three levels,depth,MAX_PANE_DEPTH,backStepat each level,popTolevels and the six-primitive saver; renamedSlidingPaneStackTest—peekWidthDppluspaneOffsetDp/paneWidthDp; newArtifactGroupsTest— grouping/order, duplicates kept, empty run, visit numbers vsrunTimeline, running-vs-finished empty message;StageDetailSheetTestgained the headline/evidence split assertions).CollapseRemovalTeststill passes.gradle :app:assembleDebugsucceeded (18,198,400 bytes).gradle :app:lintDebugstill reports only the two pre-existingNewApierrors forandroid:windowLightNavigationBarinres/values/themes.xmlandres/values-night/themes.xml.rg -n 'ModalBottomSheet|StageDetailSheet' android/app/src/mainandrg -n 'https?://' android/app/src/main/java/net/awan/pipelines/ui/graphboth return nothing;git diff --statshows no change underandroid/gradleor thebuild.gradle.ktsdependency blocks.- On
emulator-5554(2076x2152, density 390 ≈ 851dp wide; never the attached Pixel) against the live serverws://10.0.0.75:8080/connect(LAN address frompython3 -cimportingscripts/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 1header, then a grid ofPreview of …png); tapping a thumbnail opened the full-size dialog (02_sheet_ui_reviewer_top.png); a non-image row showedEVIDENCE.md,3.0 KiB · text/plain; charset=utf-8,Open/Copyenabled="true". - Tapping the Timeline row
reviewer · visit 1opened the stage pane as level 2 with two peeks visible (Back to runsat[73,165][190,1859],Back to runat[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 nodeStage revieweropened the same pane (Status completed,Outcome success,Visit 2 / 3,Target ui_reviewer). - Tapping the detail peek (
285 1000) → depth 1 (Back to runsonly); tapping the list peek (130 1000) → depth 0 (list, no strips).input keyevent 4at depth 2 → depth 1, at depth 1 → depth 0; the predictive-back swipeinput swipe 5 1000 900 1000 250at depth 2 → depth 1. settings put system user_rotation 1(config change) kept depth 2 and thereviewer/visit 1 selection; afteram kill net.awan.pipelines(verifiedpidofempty) the relaunch restored the same depth and selection.- The stage pane's Artifacts section expanded to
Artifacts · 6 recordedplus the visit's thumbnails; run 60 (executing) showed the run empty stateArtifacts · capture pending. adb logcat -d | grep -c 'FATAL EXCEPTION'and… | grep -c 'E AndroidRuntime'both returned 0; no run was started from the app.
- Summary of run 58 showed the grouped gallery (
- APK publish.
app/build/outputs/apk/debug/app-debug.apkwas copied to…/artifacts/60/2/pipelines-debug-059c85a.apk(059c85a=git log -1 --format=%h -- android/);shasum -a 256matched.curl -I http://10.0.0.75:8080/artifacts/60/2/pipelines-debug-059c85a.apkreturned 200 withContent-Type: application/vnd.android.package-archiveand aContent-Length; a streamedGET | shasum -a 256equalled 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.
ArtifactGallerynow measures the row once withBoxWithConstraintsand calls the pureartifactTileDp(availableWidth, columns, spacing, preferred)(the widest that fits, capped at the preferredARTIFACT_TILE_DP), so three tiles and their gaps always fit the pane. The only new named token isARTIFACT_TILE_SPACING_DP(8.dp), shared by the row arrangement and the fitting; no magic offsets. - Dead code removed.
ArtifactRowno longer carries an unreachable image branch (the gallery passes it only non-image artifacts); it renders the file glyph, name andartifactMetaLinewith open/copy. - No duplicated derivation.
runArtifactGroupsreusesrunTimeline's display visit number (entries→(stage, sequence) → visit) instead of re-derivingcontrol.visit ?: index + 1. - Docs corrected. The current-architecture bullet and the superseded
SlidingMasterDetail/RightSlidingPanel/ModalBottomSheetreferences 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:testDebugUnitTestreported 127 tests, 0 failures, 0 errors (the 5 newArtifactGalleryTestcases included);CollapseRemovalTeststill passes.gradle :app:assembleDebugsucceeded (17,830,569 bytes).gradle :app:lintDebugstill reports only the two pre-existingNewApierrors forandroid:windowLightNavigationBarinres/values/themes.xmlandres/values-night/themes.xml.rg -n 'ModalBottomSheet|StageDetailSheet|RightSlidingPanel|SlidingMasterDetail' android/app/src/mainandrg -n 'https?://' android/app/src/main/java/net/awan/pipelines/ui/graphboth return nothing;git diff --statshows no change underandroid/gradleor thebuild.gradle.ktsdependency blocks.- On
emulator-5554(never the attached Pixel) against the live serverws://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-imageemulator.logrow showed10.8 KiB · text/plain; charset=utf-8with enabledOpen/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 4at depth 2 → depth 1 and at depth 1 → depth 0; the predictive-back swipeinput swipe 5 1000 900 1000 250at depth 2 → depth 1. - A
wm density480 → 440 change kept depth 2 with thereviewervisit-1 selection and the expanded Artifacts section; afteram kill net.awan.pipelines(verifiedpidofempty) and relaunch, the same depth and selection returned. adb -s emulator-5554 logcat -dcontained 0FATAL EXCEPTIONand 0E AndroidRuntimelines; no run was started from the app.
- APK publish.
app/build/outputs/apk/debug/app-debug.apk(17,830,569 bytes, sha2566ac6004e9d4bc29d30457cc99009c226df7157dae2b41f07fa7c8a7a46a40498) was copied to…/artifacts/60/4/pipelines-debug-059c85a.apk(059c85a=git log -1 --format=%h -- android/);shasum -a 256matched.curl -I http://10.0.0.75:8080/artifacts/60/4/pipelines-debug-059c85a.apkreturnedHTTP/1.1 200 OK,Content-Type: application/vnd.android.package-archive,Content-Length: 17830569; a streamedGET | shasum -a 256equalled 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).