Expanding a stage section drew its rows stacked at the section's origin:
CollapsibleSectionBody passed the section's several field composables straight
into AnimatedVisibility, which lays out a single child, so the rows overlapped at
the top of the section and only the last was visible. The shared body now wraps
its content in one full-width Column, so any multi-row section stacks its rows
under its header.
Every stage section now opens as its own pane rather than growing the stage
screen inline:
- PaneState: add the Section pane level (MAX_PANE_DEPTH = 3) and a saved
sectionKey primitive, with backStep/popTo/encode/decode handling so one Back or
peek pops exactly one level and the open section survives rotation and process
death.
- StageDetailPane: the stage screen keeps a compact collapsed list of its
sections (Artifacts, Output, Input, This run, Stage definition); opening one
shows it as a full-window surface over the stage on a narrow window, or a panel
to the right of the stage pane on a wide one, with its own Scaffold/TopAppBar
title, its own scroll and its own top spacing.
- SectionHeader: a navigation mode for those rows - a static forward chevron
(mirrored for RTL) and an "Open <section>" action instead of a rotating
disclosure chevron and "Expand/Collapse", so assistive tech is not told the row
expands in place. The detail screens' disclosure rows are unchanged.
- DetailTabs: drop the rememberSectionExpansion initiallyExpanded seed, whose
last caller was the inline stage definition.
- Tests: cover the Section level's backStep, popTo, encode/decode and depth, and
the shared stageSectionSpecs order and blank-section cases.
Sections still start collapsed, the operator's choices still persist, and each
section's content is unchanged. android/ only; no dependency was added.
Also in this diff, from the covered-identity statistics work: PipelinesApp passes
compactStats = true on its two stacks (SlidingPaneStack's statistics flag).
A covered pane's width is spent on the covered region (`identityWidth +
startInset`), and when a second level is covered `coveredEdgesDp` gives the
nearest identity that region less the thin older edge (`startInset + minTouch`;
the leading gesture inset cancels), i.e. `identityWidth - minTouch`. Flooring a
statistics-bearing identity at the full block alone (`MIN_COVERED_PANE_WIDTH_DP +
PEEK_WIDTH_DP`, 168dp) therefore left the nearest edge at 120dp, below the
`paneStatTier` Full boundary, so a pipeline's last-run/age and average lines were
filtered out at every depth a pipeline is ever covered. `coveredIdentityWidthDp`
now floors a statistics-bearing identity one touch target above the block
(`+ minTouch`), so the nearest edge is exactly 168dp and reaches Full, while the
single-covered and title-only cases are unchanged and the active pane width still
does not depend on depth.
The covered title also broke mid-word in a narrow strip ("Complete a Task" ->
"Complet"/"e a Task"). `wholeWordTitle` now packs the title greedily onto
whole-word lines and, once they are full, drops the remaining words and
ellipsizes the last line at a word boundary; a word wider than the whole strip is
the one exception, ellipsized to the width because it has no internal boundary.
It takes an injected `measure`, so the packing rule is unit-testable without a
device, and `PaneIdentity` measures with the same `cardTitle` role it draws with.
`PaneIdentityTest` adds the pure cases: the width-degradation tiers, the
statistics-bearing width floor, the nearest-edge geometry at depth 2 (which fails
without the `+ minTouch` reserve, so it pins the defect), and the whole-word
wrap/ellipsis/oversized-word/no-room cases. `android/README.md` records the
corrected geometry, the fix and the run's build/test evidence.
android/ only; no new dependency, no server field, and no server/Go/installer/
Docker change. Build and unit tests only (no device): 300 tests, 0 failures.
The covered panes spent a fixed 224dp (PEEK_BUDGET_DP) whatever the window
width, so a folded window lost over half its width and the active pane was
squeezed as levels were added. Derive the covered region at runtime from the
compact identity a covered edge must show - an icon plus the shortest label
that identifies the pane, measured with the app's own type role and floored at
the platform minimum touch target - plus the leading gesture inset.
coveredEdgesDp now returns edges that sum to exactly that region, so the active
pane opens at hostWidth - region and its width is identical at every depth:
opening a level only adds a thin edge inside the region. The nearest covered
level shows its identity, one older level is a thinner touch-target edge, and
older levels fold into a count rather than accumulating width; tapping an edge
still pops everything above it. Removes PEEK_BUDGET_DP, MIN_ACTIVE_PANE_WIDTH_DP
and the peekBudgetDp/peekStripsDp budget split from Dimens.kt and
SlidingPaneStack.kt. PaneIdentity gains the pane-kind icon drawn above the title
at the vector's own measured default size, and each destination passes its
compact label/icon.
The touched files also carry the in-flight covered-pane statistics and list-scroll
plumbing they depend on (PaneStat/paneStatTier/visiblePaneStats, per-destination
LazyListState); the remaining pieces of that work remain uncommitted.
A running run now shows how long it has taken so far instead of its start
time, kept live: the runs-list meta row, the pipeline list's last-run line
and the run detail summary's Duration row all read one shared rule,
runDurationText (ui/Format.kt), which reports the elapsed while executing and
keeps the stored total once the run has finished.
The elapsed is derived from the server's own start timestamp against a single
shared clock, rememberLiveNowMillis/hostResumed (ui/components/LiveTime.kt),
so it stays correct after a reconnect and never ticks while the app is
backgrounded or while no shown run is executing. WorkflowGraph's private
lifecycle read and once-a-second loop are replaced by that same shared pair.
A missing start omits the value and a future start (clock skew) reads as 0s.
Unit tests (FormatTest, PipelineLastRunTest) cover a run that has just
started, the minute and hour boundaries, a missing and a future start, and a
finished run keeping its stored total duration.
One query now finds anything in the system over the wire and from the CLI.
- protocol: add Search/SearchResults message types and a SearchRequest
(query, optional kind filter, optional limit) / SearchResponse (typed,
ranked matches plus truncation and scan-bound counters) pair, with typed
payloads for pipeline, version, run, step/visit, field text and artifact.
- store: add Store.Search, a read-only query over pipelines,
pipeline_versions, pipeline_runs, run_steps (+step_control) and
step_artifacts. Ranks exact name (3) > name substring (2) > body text (1),
breaks ties by recency then a stable kind/target order, and reports the
matched field. Bounds work with a 50-default/200-max result cap, a 2000-row
per-kind scan limit and a 2000-step / 1 MiB field-text scan budget.
- terms: a bare status word or lone date expression (today, yesterday, this
week, YYYY-MM-DD) selects runs; anything else stays free text.
- server: dispatch protocol.Search to stores[0].Search; read-only and
unconfirmed.
- cli: add `pipelines search QUERY [--type KIND] [--limit N] [--json]`, help
text and a BROWSE line.
- store: add OpenReadOnly so the live-database check never runs DDL.
- docs: document the grammar, kinds, ranking and bounds in docs/cli.md,
scope the TUI omnisearch to pipelines in docs/ui-ux-review.md, and add a
search bullet to the packaged operations reference.
- tests: protocol round trip, store/ranking/term-parsing/limit/scan-bound
unit tests, a server end-to-end test, and an env-guarded live check.
No new dependencies; go.mod/go.sum unchanged.
Move the workflow-graph package (WorkflowGraph, the StageDetailPane sheet,
Artifacts, ArtifactViewer, ArtifactImage) off its remaining raw dp literals
and onto the geometry tokens, all substitutions value-equal so the visuals
are unchanged.
- ui/theme/Dimens.kt gains the off-scale component and graph-chrome sizes:
the run legend's GRAPH_LEGEND_PAD_X/PAD_Y/GAP, the collapsed
GRAPH_PANEL_MIN_HEIGHT (moved off WorkflowGraph.kt, now imported by its
test), the gallery's ARTIFACT_TILE_DP/THUMB_DP/BADGE_DP/PROGRESS_DP/
PROGRESS_STROKE_DP, and the stage-type chip's STAGE_CHIP_PAD_H.
- Artifact tile/row and thumbnail corner radii derive from the Material
shape scale (MaterialTheme.shapes.medium/.small), matching the graph's
existing node corners.
- DimensTest.kt's allow-list shrinks from 24 to 21 entries: 24.dp, 56.dp and
96.dp are gone now that their last call sites migrated. The structural
hairlines/zeros, the not-yet-migrated app shell and Settings literals, and
the sp type values owned by Typography.kt remain.
- WorkflowGraphTest.kt imports the moved GRAPH_PANEL_MIN_HEIGHT.
- android/README.md documents the change and its verification evidence.
Verified: gradle :app:assembleDebug :app:testDebugUnitTest --rerun-tasks
BUILD SUCCESSFUL, 30 XMLs / 259 tests, 0 failures/errors/skipped; the
enforcement test fails on a deliberately introduced literal and passes once
removed; before/after captures at both window widths differ only on the
status-bar clock and live relative-time text.
A model stage whose final result was malformed failed the whole run even when
the work and evidence had survived, because the only recovery was an isolated
formatter call on a fixed 30-second deadline that could time out on its own
(run 55, ui_reviewer of pipeline 9 v6).
Add an ordered, deterministic local repair pass (internal/stage/result_repair.go)
that runs before any model call: (a) append missing closing delimiters via the
existing closeJSONContainers; (b) remove one unambiguous trailing comma before a
closing } or ]; (c) insert exactly the single comma/colon the JSON parser reported
at its byte offset. Every candidate must pass losslessSyntaxRepair(original,
candidate) and decodeModelResult before it is accepted, so no field value is
invented, removed, reordered or rewritten. Ambiguous payloads (an unescaped quote
or colon inside a string value, or a stray delimiter with no single completion)
return not-ok and fall through to the bounded model re-emit rather than guessing.
stageResultText still strips surrounding prose and a single code fence first;
model_prompt.go now also strips prose around a single balanced-but-malformed
object span so the deterministic pass sees just the object.
Replace the fixed 30-second formatter deadline with repairDeadline(payloadBytes,
remaining), which grows monotonically with payload size, has a floor, and is
clamped to the attempt's remaining budget minus a safety margin, so the stage
context remains the outer bound and a large result is not guaranteed to time out.
The one-request-per-attempt, 32 KiB bound and the deny-all, retained, new-session
property of RepairFormat are unchanged for OpenCodeClient and PiClient.
Record an explicit recovery status on every terminal path: repaired, partial or
unrecoverable, plus a byte offset. A candidate that is valid JSON but still fails
envelope validation is marked partial and never returned as a completed result;
the unrecoverable path retains the bounded original payload, the precise parse
error (including its byte offset) and surfaces the status in the FINAL RESULT
VALIDATION diagnostic.
safeToReplay is intentionally unchanged. The deterministic local repair and the
fresh deny-all, no-tools, retained formatter session are independent of the
stage's tool set and never re-prompt or replay the admitted agent session, so a
shell-enabled review stage gains malformed-result recovery without any replay of
admitted work. Risk: no change to mutation safety; the only added cost is one
bounded formatter call, already budgeted. Replayability is not extended for shell
stages.
Docs and packaged skill references (docs/model-results.md,
internal/author/skill/references/{format,debugging,verification}.md) describe the
three-tier recovery, the status words and the derived deadline; the safeToReplay
decision and its risk are recorded there alongside the commit.
Tests add mocked, offline coverage for the deterministic and partial paths, a
repairDeadline monotonicity/floor/clamp table, and a shell-stage regression
proving a recoverable malformed result does not fail the run or replay tool work.
Replace the hardcoded paddings, spacings, sizes and offsets in the four
list/detail screens and the shared components they are built from with
references to the token file from the previous item, via WindowInsets or
layout where those derive the value. Every replacement is value-equal, so
the screens render identically at both window widths.
Name the glyph sizes that cannot derive from layout as four new ICON_*
tokens in ui/theme/Dimens.kt (14/18/20/24dp) and shrink the DimensTest
allow-list from 30 to 24 entries: 14.dp, 18.dp and 20.dp leave because
their last call site migrated, and the already-unused 32.dp, 11.sp and
13.sp entries are dropped. All adb/emulator work targeted emulator-5554
only; android/ only; no new dependency, server/Go/installer/Docker file
touched, and no run started from the app.
Verified: :app:assembleDebug + the full unit suite (30 result XMLs, 259
tests, 0 failures/0 errors/0 skipped), the shrunk allow-list still fails a
forced raw-literal probe, and before/after screenshots of every converted
screen at narrow and wide widths match near-zero.
internal/summarise called protocol.NormalizeText, which was never defined, so the tree did not compile. Add the shared normalisation helper: drop zero-width formatting runes, turn control characters into spaces and collapse whitespace runs (including the non-breaking space variants) into single spaces. Reuse it in OutputPreview instead of duplicating the mapping logic.
Cover the awkward inputs (newlines, tabs, non-breaking spaces, zero-width runes, surrounding quotes, trailing punctuation) in the protocol and summarise tests. Unrelated working-tree changes are left uncommitted.
Compose the parallel lane (lane-app2) with the work already on main,
preserving both intents rather than picking one side:
- lane-app2's modernised run graph (rounded tonal nodes, pill terminals,
chipped outcome labels, pass/fail emphasis and active-stage/edge motion)
plus its remembered list filters/sort and last-run badges, and the
app-owned run-status palette.
- main's cross-fading loading/empty/error states, animated list items and
the single geometry token file (Dimens.kt + DimensTest).
Conflicts resolved in android/README.md (kept both appended sections),
RunStatus.kt (kept the shared ColoredChip extraction and made it animate
under MotionQuick), PipelineListScreen.kt (filters/sort/badges composed with
the StateCrossfade/load-phase presentation and animateListItem rows),
RunDetailScreen.kt (kept both the artifact-selection and graph-palette
imports) and RunHistoryScreen.kt (the cross-faded load branch now passes
sort/filters through, and both empty branches keep the Clear filters action
with animated items). LoadPhase.Empty now carries an optional recovery
action so the crossfade can still offer Clear filters. The graph's new
geometry literals moved onto Dimens.kt GRAPH_* tokens so DimensTest passes
and its allow-list shrinks as intended.
Verified: :app:assembleDebug and :app:testDebugUnitTest (259 tests,
0 failures) with the offline Gradle 8.11.1 / JDK 17 toolchain.
Introduce ui/theme/Dimens.kt as the one source of truth for app geometry,
alongside Typography.kt for type. It defines the 4dp spacing scale
(SPACING_XXS/XS/S/M/L/XL/XXL) and receives the geometry constants that
already existed, each with a comment tying it to what it is: PEEK_WIDTH_DP
(the collapsed strip), PEEK_BUDGET_DP, MIN_ACTIVE_PANE_WIDTH_DP and
MIN_COVERED_PANE_WIDTH_DP from SlidingPaneStack.kt, DESTINATION_PILL_RESERVE
from PipelinesApp.kt, and WIDE_RAIL_WIDTH_DP and DETAIL_MAX_WIDTH_DP from
DetailTabs.kt. Call sites now import the tokens; every value is unchanged,
so no layout changes.
Add ui/theme/DimensTest.kt, a JVM test that scans the app's Kotlin sources
for raw dp/sp literals and fails with file:line:literal unless the literal
is a token or an explicit, reasoned allow-list entry. The allow-list records
the 34 literals that predate the token file, each with a written reason, and
is expected to shrink as call sites migrate onto the tokens.
Document the change and its verification in android/README.md.
Replace the old terminal-diagram look on the Graph tab with a tonal
surface language, keeping the same information and every outcome hue.
- Nodes: stages are rounded rectangles from MaterialTheme.shapes.medium,
terminals become pills (height/2). Fills are tonal surfaces via the new
pure tonalFill(surface, accent, fraction) with a soft outlineVariant
border instead of a flat fill plus hard outline.
- Type: node names use the cardTitle role and outcome labels the label
role, with theme line height/letter spacing; the [brackets] and all-caps
are gone (nodeDisplayLabel renders Success/Failure title-cased in colour).
- Edges: StrokeCap.Round/StrokeJoin.Round, bends rounded by one
ROUTE_CORNER_RADIUS (cornerCutRadius clamps short segments), filled
arrowheads scaled as edgeStrokeWidth * ARROW_HEAD_SCALE, and labels on
a shared DrawScope tonal chip.
- Spacing: named dp tokens instead of ad-hoc literals.
Adds pure-logic unit tests (WorkflowGraphTest, GraphPaletteTest) and
documents the change in android/README.md.
Verified: :app:assembleDebug and :app:testDebugUnitTest both BUILD
SUCCESSFUL (207 tests, 0 failures) with no Kotlin warnings.
Animate selection and status changes across the Android UI using the
existing Motion tokens, leaving every resting state unchanged.
- DestinationPill draws one selection indicator and animates its offset
between the three slots (animateDpAsState, MotionStandard), with the
glyph tint cross-fading in step; geometry comes from named
DESTINATION_ITEM_SIZE/GAP tokens via the unit-tested
destinationIndicatorOffsetDp helper.
- The shared ListRow fades its tonal container and content colour under
MotionQuick instead of switching.
- New shared CollapsibleSectionBody wraps section bodies in
AnimatedVisibility (expand/shrink + fade) under MotionQuick, used by
both the lazy collapsibleSection and the stage pane's StageSection, so
body and chevron move together.
- StatusChip eases container and label colour and RunStatusIcon eases its
glyph tint, so a live run's status transition is visible rather than a
silent colour swap.
Verified: assembleDebug + testDebugUnitTest BUILD SUCCESSFUL, 186 tests
across 23 classes with 0 failures/errors/skips; frames captured on
emulator-5554 for the travelling pill, section collapse and a live status
change; APK published to the run artifact directory. README documents the
change and its evidence.
internal/summarise performs a single tool-free generation through the
configured default harness (its interactive model), reusing the exact
stage.ModelGenerator/OpenCodeClient/PiClient construction provider-check
uses. It bounds input (InputCap), output (one line, OutputCap runes) and
time (DefaultTimeout), returns the NoSummary sentinel on any error/timeout/
unusable reply, never runs tools or writes files, and records the harness,
model and failed flag in one sanitized log line plus at most one
OperationEvidence.
Reuse: stage.TruncateRunes and stage.OperationLog.Record are the exported
forms of the existing rune-safe truncation and bounded evidence recording;
protocol.NormalizeText trims replies to one line. No new dependencies.
Not wired into titles/verdicts yet: protocol.OutputPreview and the
internal/server/notify.go notification summary are the obvious future call
sites.
A data-backed pane swapped its loading spinner, empty message, error
message and content with a plain `when`, so content flashed from empty to
full and empty/error states popped.
Introduce a shared presentation model in ui/components/States.kt:
- `LoadPhase` (Loading, Error(message), Empty(message), Content), with
message-carrying phases capturing their text at classification so a
fading-out branch never recomposes against cleared error/filter state.
- `listLoadPhase(loading, error, hasData, emptyMessage)` and
`detailLoadPhase(error, hasData)` pure classifiers preserving the
existing precedence (failed load with no data, then loading, then
empty, else content; stale data keeps the pane on content).
- `StateCrossfade(phase)` wraps the branch in a `Crossfade` using the
existing `MotionStandard` token; both branches share one box so the
resting layout is unchanged and the outgoing phase fades under the
incoming one.
Apply to PipelineListScreen, RunHistoryScreen, PipelineDetailScreen and
RunDetailScreen. Detail panes render the fading-out branch from the last
non-null item. The Runs pane keeps its inline empty/error line inside the
list, now fading through animateListItem().
Add LoadPhaseTest covering the classifiers and captured messages, and
document the change and evidence in android/README.md.
Introduce ui/components/Motion.kt beside the pane dimension tokens: two
named duration+easing tokens, MotionQuick (120ms) for small in-place state
changes and MotionStandard (220ms) for content that moves or swaps, under a
300ms MAX_MOTION_MILLIS cap. Every animation call site now asks a token for
its spec instead of writing a duration: the pane slide and section
Crossfade use MotionStandard, the section chevron uses MotionQuick, and the
pane-pop stagger moves in as MOTION_STAGGER_MILLIS (the old
PANE_SLIDE_* / SECTION_SWAP_MILLIS constants are gone).
Add a single LazyItemScope.animateListItem() helper (ListRow.kt) wrapping
the supported Modifier.animateItem with the tokens: items fade in/out
(MotionQuick) and slide to new positions on refresh, filter or re-sort
(MotionStandard). Pipelines rows, run rows, version rows and evidence rows
use it. Specs are built at composition time (no per-frame allocation) and
the chevron reads its angle inside graphicsLayer so it turns without
recomposing the header; resting layout is unchanged and the standard
animator duration scale still applies, so disabled animations are instant.
Add MotionTest covering token ordering, per-token bands, the cap, monotonic
easings, self-reversal and spec timing; SlidingPaneStackTest now reads the
pane timing from the token. Document the change and its verification in
android/README.md.
Show what is happening while a run is live. The executing stage now carries a
subtle pulsing halo (replacing the blink) and a live ticking elapsed badge
derived from the run's current visit start. Executed edges carry a directional
flow of light dots along the path; a finished stage settles into its static
colour. A finished run never animates, the animation pauses when the graph is
off screen, and with the system animation setting disabled it falls back to a
static but clearly marked running state.
The per-frame visual state and should-animate decision live in pure functions
(GraphMotion.kt, Format.kt secondsSince; GraphSemantics exposes executing and
currentStageStartedAt) with unit tests and no frame-timing assertions. Adds
GraphMotionTest and extends GraphSemanticsTest and FormatTest.
chat_sessions now brokers GET /api/session but filters the global list to
the sessions this server recorded in run_steps, deduped by session id, and
fails closed to an empty list when no ownership source is configured. A
session another client holds (in-server claim, released on stream end or
disconnect) or an active run is marked busy; a second client's chat_prompt
for a held session is rejected before any OpenCode call. chat_create stays
unbrokered.
Long-pressing any artifact — a gallery tile in the run summary or a row in
the stage pane's per-visit list — now enters artifact selection: the pressed
item is selected with the app's selected treatment and further taps toggle
items instead of opening them. A contextual bar replaces the surface's top
bar while selecting, showing the count plus Copy links, Share and a close;
it carries the same pane safe-area insets as the bar it replaces, uses 48dp
IconButtons and leaves selection mode on Back before the surface's own Back
runs. Selection applies only to artifacts, never the runs or pipelines lists.
The selection is one shared host: ArtifactSelectionScaffold owns the
remembered ArtifactSelection, the resolvedSelection lookup, the bulk
copy/share actions, the SnackbarHostState and the pane-scoped BackHandler,
and both RunDetailScreen (summary grid) and StageDetailPane (per-visit list)
go through it, so neither screen owns its own SnackbarHostState or
BackHandler. The immutable ArtifactSelection (enter/toggle/selectAll/clear)
treats selection mode as "one or more urls selected", so it can never
restore half-applied; rememberArtifactSelection saves it via a listSaver and
reseeds per run/visit.
Copy links resolves every selected url against the configured server through
the existing resolvedArtifactUrl (no hardcoded host), writes one absolute
link per line through the new single Clipboard.copyText path (now also used
by the code blocks, pipeline source, artifact row and viewer), and confirms
the number of lines actually produced in a Snackbar. Share fetches every
selected artifact through the existing client, reuses the single-item
writeSharedArtifact (same bounded cache, FileProvider and prune), and sends
one ACTION_SEND_MULTIPLE typed by bulkShareMimeType (the common type, else
the wildcard) with the count in the chooser title; when any fetch fails the
whole set degrades in the same action to its resolved links shared as text.
Pure helpers and tests: ArtifactSelectionTest covers enter, toggle,
deselect-last, select-all/clear, the restored state, the one-per-line link
formatting and the labels; ArtifactSharingTest gains shareTargets and
bulkShareMimeType cases. Unit tests plus assembleDebug pass (168 tests,
21 classes, 0 failures). android/README.md documents the model, action bar
and the bulk share flow, and the doc-accuracy pass records that the bulk
copy writes links in gallery (candidate) order.
No new dependency (icons come from the declared material-icons-extended).
Treat `success` and `error` as the emphasised outcomes so pass/fail is
obvious at a glance and from a distance. An executed pass/fail edge now
uses PASSFAIL_EDGE_STROKE=7f (was 3f), a same-hue, more saturated stroke
(PASSFAIL_SATURATION=1.6f via the new pure boostSaturation helper) and a
matched PASSFAIL_ARROW_HEAD_SIZE=20f arrowhead. Other executed outcomes
keep EDGE_STROKE=3f and not-executed routes the finer
INACTIVE_EDGE_STROKE=2.5f, so the two decisive outcomes dominate.
All widths, the arrowhead size and the saturation factor are named
tokens chosen by edgeStrokeWidth/edgeArrowHeadSize/edgeStrokeColor; the
old 12f arrowhead literal at the call site is gone (drawArrowHead now
takes the size as a parameter). Outcome hues are unchanged; the boosted
stroke keeps the original hue and value.
The run Graph tab help line notes that executed success and failure
routes are drawn thickest, and the definition-only view gets the same
emphasis since every route counts as executed there. New unit tests cover
the saturation maths (hue/value/alpha preserved, safe and clamped) and the
per-edge width/arrowhead/colour choices.
Carry the two states structurally instead of by fading, so the difference
survives a screenshot, a dim screen and a colour-blind reader.
- Executed edges: solid full-colour stroke plus an arrowhead.
- Not-executed edges: dashed muted stroke (INACTIVE_DASH_EFFECT), no arrowhead.
- Executed nodes: keep their fill and normal border.
- Not-executed nodes: no fill, dashed muted border and a muted but legible label.
- Add a one-line legend (GRAPH_LEGEND / GraphLegendEntry / LegendSwatch) pinned
TopStart, rendered only when a run is selected.
- Replace the private EdgeLayout.isExecuted/inline visited check with the shared
edgeIsExecuted/stageIsExecuted predicates and remove the alpha-based dimming.
- Update the KDoc and the run Graph tab help text ("solid ... dashed and outlined").
Tests: executed/inactive predicates over the definition view and a RunGraphState,
the dash pattern as a positive even-length rhythm, and the legend naming both
states with executed first.
Give each gallery image cell and each per-visit file row its own share
control: a 48dp IconButton with an accurate "Share <name>" content
description drawn as a sibling of the item's tap handler, so sharing
never opens the image or the item.
Sharing fetches the artifact through the existing client into a scoped
cache file (cache/shared-artifacts/), exposed via a non-exported
FileProvider declared with the new res/xml/file_paths.xml, and sends it
through ACTION_SEND. When the fetch returns nothing the action falls
back to sharing the resolved link as text. Cache files are named
deterministically per artifact so re-sharing overwrites instead of
growing without bound, and a failed or unreachable fetch cannot crash.
The artifact-to-file naming, mime/extension table and the file-vs-link
fallback decision are factored into ArtifactSharing.kt and covered by
the new ArtifactSharingTest.kt. The existing open and copy-link actions
are unchanged; the viewer's action scrim alpha is shared as
ARTIFACT_ACTION_SCRIM_ALPHA. android/README.md documents the provider
and the share flow. No new dependency is added.
The chat_interrupt path was already wired end to end (protocol type,
server dispatch through handleChatSimple to broker.Interrupt, and the
adapter POST /api/session/{id}/interrupt), but nothing exercised it
against a live stream. Add the missing coverage:
- internal/opencode/chat_test.go: pin the adapter's outbound call
exactly (POST /api/session/ses_1/interrupt, empty JSON body, one
request, nil on 200) plus a non-nil error on HTTP 500.
- internal/server/chat_test.go: drive the real opencode.Chat adapter
over an httptest SSE fixture that holds the turn open until the
interrupt arrives, then assert the run ends, the interrupt is
acknowledged, no error frame is sent, and the prompt/interrupt posts
and interrupt path match. Also cover invalid-session rejection,
the unconfigured-broker error, and broker-failure reporting, adding a
spare interruptErr hook to the scripted fakeChat.
Production code is unchanged: verification found no gap in the existing
interrupt transport. Tests use httptest loopback fixtures only and do
not touch the live OpenCode service.
Tapping an image artifact (run summary grid, per-visit list or stage pane,
all rendered through ArtifactGallery) now opens a new scrim-backed
full-screen viewer instead of the former small centred dialog, which is
removed rather than stacked.
- ArtifactViewer.kt renders a full-bleed Dialog (usePlatformDefaultWidth =
false, decorFitsSystemWindows = false) whose content re-applies
paneSafeArea() so the dark backdrop reaches the edges while respecting
status bar, cutout and navigation bar. A top-right row keeps the
open-in-new and copy-link actions and adds a close button over a
translucent scrim capsule.
- Gestures: pinch zooms about the centroid, drag pans via the existing
graph zoomAbout, double-tap toggles fit <-> 2.5x, and a downward swipe at
fit dismisses; a plain tap does nothing. Zoom clamps to [1x, 5x] and the
new pure clampImageOffset keeps pan inside the scaled image. Zoom state is
keyed on the url, so closing the viewer or opening another image resets to
fit/centred. System Back and the close button dismiss the viewer without
closing the pane behind it.
- Loading goes through the existing cached, off-main-thread
rememberArtifactBitmap/ArtifactImageState path with distinct loading and
error states, drawn in the light inverseSurface role that contrasts with
the always-black scrim.
- Pure helpers fitImageSize, clampImageOffset and toggleZoomScale are
covered by the new ArtifactViewerTest. ArtifactImage.kt widens
rememberArtifactBitmap/ArtifactImageState to internal and Artifacts.kt
replaces FullSizeArtifactDialog with ArtifactViewer (openArtifact made
internal).
- android/README.md documents the viewer, its gestures and the evidence
gathered on emulator-5554.
Give each list a filter control, remembered per list across restarts like
the sort, combined with AND. Filters narrow; the (later) omni search will
find, so they are kept distinct.
- ui/screens/ListFilter.kt: RunTimeRange (AnyTime default, Today, Last7Days,
Last30Days), RunPresence (Any default, HasRuns, NoRuns) and the
RunFilters/PipelineFilters data classes, with one pure predicate per facet
(runMatchesStatuses, runMatchesPipeline, runMatchesTimeRange,
pipelineMatchesPresence, pipelineMatchesLastRunStatus) and the AND-combining
filterRuns/filterPipelines. A default narrows nothing; an empty status set
means "any"; the time windows are inclusive calendar days; a blank,
unparseable or future timestamp never matches a finite window; a runless
pipeline has no last-run status; fromStorage tolerates stale/unknown/blank
values; encodeRunStates/decodeRunStates round-trip the status set.
- ui/components/FilterMenu.kt: the shared top-bar control both screens use -
an IconButton with a numeric active-filter count badge opening the caller's
sections plus one Clear filters action (disabled when nothing is active),
the count folded into the icon description, and a menu capped to the window
and clear of the navigation inset so it stays scrollable rather than
clipping.
- PipelineListScreen.kt/RunHistoryScreen.kt wire the control and predicates;
the existing name search on pipelines stays a separate field, and the new
pipeline facets depend on the run history.
- ui/components/States.kt: EmptyState gains optional actionLabel/onAction so
both lists distinguish "nothing exists" from "nothing matches the current
filters" and offer Clear filters only in the latter.
- data/SettingsRepository.kt + ui/AppViewModel.kt: store each facet under its
own stable key as a StateFlow, exactly like the sort keys; the screens
resolve the stored strings so the repository stays unaware of the UI enums.
Verified on this tree with :app:testDebugUnitTest, assembleDebug, and
emulator-5556 persistence and captures; recorded in android/README.md.
In the run detail summary, artifacts now appear at the top of the page and as a grid rather than a list:
- RunDetailScreen emits the "run-artifacts" LazyColumn item before the "run-summary" item, so the captured screenshots are the first thing the operator sees. The rest of the summary and its collapsed-by-default sections are unchanged.
- ArtifactGallery derives its geometry from the measured width via the new pure artifactGrid(availableWidth, preferred, spacing): it fits as many preferred-shaped cells as the width allows and stretches them to fill the row, instead of the removed fixed ARTIFACT_GRID_COLUMNS count. A host narrower than one preferred cell falls back to a single narrower cell; a non-positive preferred token never divides by zero. Tiles still open the full-size image on tap; non-image artifacts keep their compact list form.
- ArtifactGalleryTest replaces the fixed-column cases with grid cases covering a narrow pane (fewer, larger cells), a wide window (more columns), a very wide window (cells near the preferred shape), the single-cell fallback and degenerate inputs, asserting the row never overflows the host.
Verified with assembleDebug (APK 17,863,337 bytes, sha256 32e9081b28f5caa85f5bfa24f7fe7149eeddb919d4e71cf497e9017b80f54ce7) and the unit tests (140 tests, 0 failures/errors/skipped); captured on emulator-5554 at both window widths.
decodeChatMessages only understood the native-serve {info,parts} envelope,
so records from the V2 HTTP API (GET /api/session/{id}/message) decoded
with an empty role and were silently dropped, leaving chat_messages with
empty history. Teach nativeChatMessage to read the V2 top-level shape
(id/type/agent/model/time, parts under "content", user prompt as a bare
string) while keeping the native {info,parts} path via role/id/model/agent/
created accessors and a contentParts fallback.
Add seeded-session evidence: a decoder table test covering both envelopes
(user + assistant with text, reasoning and a completed tool part carrying
input, content and status) plus handler tests that drive chat_messages
through the broker fallthrough and through the real adapter.
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.
Add a per-list sort control to each top bar and persist the choice in
SharedPreferences so it survives restarts.
- ui/screens/ListSort.kt: PipelineSort and RunSort enums plus pure
comparators with explicit tie-breaks, and sortPipelines/sortRuns.
ServerOrder/NewestFirst remain the defaults; a still-executing or
unparseable-timestamp run sorts last.
- ui/components/SortMenu.kt: the shared top-bar control, a distinct
IconButton opening a Material 3 DropdownMenu of every option plus a
divider and Reset, with the active choice checked.
- data/SettingsRepository.kt + ui/AppViewModel.kt: store the sort key
per list as a StateFlow; fromStorage falls back to the default for a
stale/unknown/blank value.
- ui/Format.kt: share parseInstant and durationSeconds so the printed
duration and the sort key cannot disagree; PipelineLastRun.kt reuses
the shared latest-run fold.
- PipelineListScreen.kt/RunHistoryScreen.kt wire the control and sort;
groupRunsByDay preserves the comparator's order.
- ListSortTest.kt covers the comparators and storage fallback;
RunGroupingTest.kt gains an explicit-order case.
Verified on this tree with :app:testDebugUnitTest (167 tests, 0
failures), assembleDebug, and emulator-5556 persistence, the sort
control, and Reset; captured in android/README.md.
Give every pane one shared slide spec, a fixed 300 ms duration and a symmetric cubic-bezier easing, so a close is the open curve run backwards at the same duration; several levels that pop in one tap now stagger so each reverses in order from the top.
The stack mounts a level while it is open or still sliding out and calls the pane only then, and rememberPaneContent retains each closing pane's full parent identity (item/version/section, stage key, visit). A closing pane therefore keeps rendering the content that opened it instead of vanishing or falling back to an empty node, and a fully closed level composes nothing. Geometry, tokens and insets are unchanged.
Adds three pure unit cases for the symmetric easing and the stagger rule; documents the change and its emulator verification in android/README.md.
Add the server-side half of the brokered chat path (route B): the
opencode.Chat adapter forwards chat_prompt to POST
/api/session/{id}/prompt through the owned Connection.Call translation
and derives chat_event frames from the authenticated /api/event SSE
firehose (text and reasoning deltas, tool parts with their status
transitions, step and usage). Every pushed frame carries a stable
session and message id, with a last-message-id fallback so step/tool
events that omit the assistant message id stay attributable.
The /connect handler keeps per-session retained state (chatHub) capped at
1 MiB with least-recently-updated eviction at 128 turns, so a
reconnecting client re-syncs through chat_messages instead of replaying
deltas the OpenCode per-session log never resends. Prompt dispatch
subscribes before posting and buffers pre-ack frames to preserve order,
and cancels the stream on disconnect so no goroutine leaks. chat_sessions
and chat_create are declared but not yet brokered: they answer with an
explicit protocol error rather than the generic Pong.
Reuse the existing transport, validation and normalization; no second
OpenCode transport or credential path is introduced.
Tests: protocol golden round-trip, adapter normalization + v1/v2 Call
translation, and handler ack/stream/validation/resume/disconnect, plus a
real-adapter no-tool evidence harness.
Each pipeline row in the Android list now renders its most recent run:
the status chip, how long ago it started, its recorded duration and its
run id. Pipelines that have never run say "no runs recorded" instead of
leaving a blank line, and the line is withheld until the run history has
loaded so a missing history is never reported as "no runs".
The list_runs history already arrives whole (id DESC), so the join is
client-side: PipelineLastRun.kt folds it onto a Map keyed by pipeline id,
recency decided from the timestamps with the higher run id breaking an
exact tie, and formats "ago · duration · run N", omitting any genuinely
absent fragment. The change is android/-only, adds no server field or
dependency, keeps the existing title/secondary structure and selected-row
highlight, and never starts a run.
PipelineLastRunTest covers most-recent-wins, no runs, unknown pipeline
id, equal timestamps, a bad timestamp, an unknown status word, the
formatRanAgo scales and the "no runs recorded" wording. README records
the verification: :app:testDebugUnitTest (153 tests, 0 failures) and a
full --rerun-tasks assembleDebug (17,863,337 bytes, sha256 b2255066…).
Rewrite SKILL.md to state the stance (reconnoitre, then route all work
through Pipelines runs; manage and debug, never implement), keep the
existing authoring/operations index, and route to four new references.
Add references/orchestration.md (stance, work items, brief template,
hard constraints, pipeline choice, running and watching),
references/lanes.md (worktrees, devices, sync/merge, restart-replay
cursor fix), references/debugging.md (eight symptom/confirm/do
playbooks) and references/delivery.md (artifacts, LAN URLs, WIP naming,
install boundaries), each with a clearly labelled project example where
Android/device specifics apply.
Append orchestration verification habits to references/verification.md
and add the four new files to install.go's managed inventory.
Add the internal/protocol types the phone needs to talk to OpenCode chat
through the Pipelines server (route B): the chat_* request/response type
constants (sessions, create, prompt, messages, interrupt, reply) and the
server-pushed chat_event frame, plus the part/status/role/tool-state/decision
constant sets and payload structs modelled on the verified OpenCode shapes -
an assistant turn is a list of parts (text | reasoning | tool), and a tool
part carries name, executed, state.status (streaming | running | completed |
error), state.input, state.content, state.metadata, state.error and
epoch-millisecond timings.
Add eight optional omitempty chat fields to the shared Message envelope, so
older peers ignore them, and a golden round-trip test covering every new type,
an exact-JSON pin of a tool chat_event frame, envelope preservation and
omitempty. go test ./internal/protocol/... passes.
The pane's Scaffold already painted an opaque colour, but it was the app
background role, identical to the peeks it slides over, so it read as
"no background" and its rows ran together with the covered pane's compact
identity.
Paint the whole pane one theme container role: StageDetailPane gains
paneContainerColor() = colorScheme.surfaceContainer and applies it to the
Scaffold container, the TopAppBar and the visit PrimaryScrollableTabRow, and
StageSection passes it to the shared SectionHeader, which gains an opaque
containerColor parameter defaulting to the previous background. The pane now
fully covers the area it occupies, including under a sticky section header,
and sits a tuneful step above the app background it covers.
Move the shared cards one step up so a card stays a card on the new sheet:
CodeBlock and the artifacts ArtifactRow use surfaceContainerHigh and the
full-size artifact dialog uses surfaceContainerHighest. No geometry, inset or
dependency changes; all colours come from the existing theme.
Verified with gradle :app:assembleDebug and :app:testDebugUnitTest (137 tests,
0 failures) and by capturing the pane open over the graph and the Timeline at
both window widths on emulator-5554. android/README.md records the change and
evidence.
Add a README evidence subsection for the committed run-status colour change at 24584d8: the unit suite (143 tests, RunStatusPaletteTest 7/7 incl. contrast), assembleDebug with the published APK size and sha256, before/after pixel-sampled captures on emulator-5556, and the APK publish location and LAN URL.
Run status was mapped onto Material roles, so a succeeded run read amber
(tertiary) and a running run read mint (primary). Replace that mapping with an
app-owned RunStatusPalette: Running/Active blue, Succeeded green, Failed the app
error red, Interrupted amber, Canceled muted grey, Queued neutral grey and
Unknown a low-key surface grey, each with a one-line rationale. runStateColor is
now a pure lookup over the palette.
Keep each state's distinct material glyph and text label so status is never
colour-only, and add a WCAG-AA contrast test for every status colour against the
dark surface plus hue-specific assertions.
Leave the graph's stage-outcome palette untouched. The timeline's step chips are
a stage outcome, not a run status, so point them at the shared graphColors/
outcomeColor factory (extracted from WorkflowGraph) to agree with the graph, and
factor the shared ColoredChip pill out of StatusChip so neither repeats the
layout. Document the change and its evidence in android/README.md.
A stage opened from a run (Timeline, run graph or run stage list) now leads
with the run-side result instead of the stage's own definition: status,
outcome, duration, visit and target, then the visit's results in the order
Artifacts (gallery first), Output, Input, then the remaining run evidence
under This run. The stage's full definition (type, prompt, output contract,
outcomes, model, provider, configs, tools, limits, memory, notify) moves into
one collapsed "Stage definition" section at the bottom.
StageDetailPane gains a runContext flag: RunStagePane passes true and gets the
collapsed-definition default, while PipelineStagePane passes false and keeps
the definition expanded, since it is then the pane's only content.
rememberSectionExpansion gains an initiallyExpanded set (part of the save key)
so the seed respects an operator's own expand/collapse choices without
inheriting them across contexts.
Nothing visible before is removed - the previous Model/Provider headline
promotion is reverted and those facts remain reachable inside the expanded
definition. The visit tabs and the collapsed-by-default behaviour of the other
sections are unchanged. android/ only; no dependency added.
Updates android/README.md and StageDetailSheetTest.kt accordingly.