Resolve the L6 routes against the newer C2/C13/L5/R10 shell: keep both sides
(single client imports, the run-alert watch inside the reconnect path, the boot
route + popstate wiring alongside loadNotifyAsked, main's L5 row and L6 done).
Completes the item: the Settings view, its pure helpers and the client's
socket-replacement path, plus the fix the review required (a header-side URL
correction clears the Settings field's own error) and a smoke check for it.
Resolve C10 vs C11 in the shared shell:
- keep both send hooks in the smoke's WebSocket shim (recording +
scripted replies + synthetic approval acknowledgement) instead of the
second assignment overwriting the first;
- close the .chat-approval CSS rule so the C11 background-task rules are
not swallowed by it (the list lost its 3-row cap and scrolling);
- assert the folding invariant directly (no adjacent agent bubbles)
instead of 'agent bubbles <= user prompts', which the growing operator
session now legitimately breaks;
- exercise the resource clamp by scroll overflow instead of a clone
measurement that the clamped frame makes unreliable.
Completes the item the pipeline could not land: the C10 diff its own
implementer and probe assertions already verified is committed as-is.
The resource block is a padding-free six-line clamp inside a padded frame
(the app's maxLines = 6 + ellipsis) and the primary control is filled.
Add the background-tasks bar to an open conversation: heading
"Background tasks" plus "{n} running", shown only while at least one
shell is running. Rows are capped at 3 (BACKGROUND_TASK_VISIBLE_ROWS)
and the list scrolls beyond; each row is a play glyph, "Running", a
one-line shellCommandSummary and "Details" while selected. Tapping a
row toggles its detail pane ("Command"/"Task identity"/"Status:
running" plus the bounded output: spinner, error + "Retry",
"Output unavailable for this task.", "No output yet.", or the
monospace output and "Output is bounded to 64 KiB." with "Refresh").
Fold shell frames without ever marking the turn running, merge a blank
command from the previous frame, list only running shells (an exited
shell is never a task) and drop/relearn shells on reconnect via
chat_shells. Refresh always rereads the bounded 64 KiB page from cursor
0. Update PARITY.md C11 with its captures and the replayed-vs-real note.
Checks: node --check on every touched file; cd web && node --test test/
(456 pass).
Address the review of C8/C9: the composer's Stop control now routes to
`chat_interrupt` (`onStop`) instead of the inert submit path, and the smoke
clicks it and asserts the page's own "Stopping the running turn…" notice with
no `Action failed` dialog (captures/63b). Accepting `/close` finishes the
session locally — the running/queued bits clear and the conversation leaves
the pane for the list, mirroring Android's `finishSession` — and the smoke
asserts the select hint returns. A command notice draws the one terminal
glyph (`CHAT_COMMAND_GLYPH`, `>_`) for both states, tinted only; the growing
textarea accounts for its padding and border so six rows are six whole lines;
remove a shadowed duplicate `chatSessionById`. Wording unchanged; every pure
helper and the wire shapes remain unit-tested.
The smoke creates a throwaway session via `/new`, really prompts, really
interrupts and closes it; the operator's session is never prompted.
Add the composer at the foot of an open conversation: a growing 1–6-row
textarea (Enter sends, Shift+Enter newline), an Attach file control with
removable attachment chips (25 MiB limit, failed attachments block sending),
one send/stop control that turns to Stop while a turn runs, and the queued
notice cleared on any incoming frame. Add the five slash commands with the
palette, the pure chatCommand* helpers and the command notices. The prompt
carries native_message_id so OpenCode accepts it, and a rejected prompt
restores the draft and attachments with the server's message. Drafts persist
per chat in memory and localStorage; attachments stay memory-only.
Tests cover every pure helper and the exact chat_prompt/chat_interrupt/
chat_create wire shapes; ui-smoke captures the composer, palette, a failed
command notice, the attachment chips and the Stop control (a real prompt to a
throwaway session that is closed in cleanup).
A template detail now offers "Create pipeline from this template". Its
dialog ("Create from {name}", one required field "New pipeline name
(required)", the note that it creates a draft and does not run, Create /
Cancel with Cancel reading Close after a success) validates the
template's source first and, only when it parses, submits it create-only
with the trimmed name. Create is disabled while the name is blank or
while sending; the field locks while sending and after a success. A
refusal shows the server's own error in the still-open dialog; a success
shows `Created "{name}". It is in the Pipelines list.` and refreshes
list_pipelines so the new row is visible.
Pure helpers + both request shapes are unit-tested; the flow is captured
against a scratch server with its own throwaway database. The live
server's pipeline list is never touched: the default ui-smoke run sends
no submit and create runs only under its --scratch flag. Wording matches
android/.../TemplateDetailScreen.kt and PipelinesRepository.kt.
Browser Chat destination for parity with the Android app:
- session list grouped by directory (closed grouped under "Closed"), kind
chip, activity badge, work-label meta line, "Search chats" filter (C1)
- open/close/reopen with the Android copy verbatim (C3)
- conversation history paging via the opaque next_cursor (C4)
- markdown subset renderer + code blocks (C7)
- scroll follow / "Jump to latest" / per-session saved position (C14)
Request builders in src/repository.js; pure merge/format/markdown/paging
logic in src/chat.js and src/markdown.js; view in app.js. Every server
string set with textContent, markdown built as DOM nodes.
Add the run-level operator actions to the browser run detail, matching the
Android client's wording and wire frames:
- R11 human decision: pure model in src/actions.js (pendingDecision,
lastWaitingStep, waitingPrompt/waitingOptions, humanOptions,
decisionTargetLabel, DecisionDraft) plus the decision card and sheet;
decide_run sends run_id, the chosen option and trimmed feedback.
- R12 cancel: a Cancel run action offered only while executing; the Android
confirm copy; cancel_run then a silent get_run refresh.
- R13 retry: offered only for a loaded, non-executing failed run; resume is
the default (no retry_mode, like Android) with a browser-only
Restart from start secondary that sends retry_mode:"restart".
- R14 rename: an inline set_run_title field; refreshes the run and its list row.
- One shared Action failed dialog for all of the above.
Add the protocol constants and typed builders, a hand-written dark-palette
section for the card/sheet/dialogs, focused unit tests for the helpers and
request shapes, and ui-smoke captures for the new states. Update PARITY.md:
R11 stays partial (no live waiting run), R12–R14 done with the stated
shown-not-executed and Android-divergence notes.
Also harden openRunDetail() in the UI smoke: the tabstrip already exists from
the previously opened run, so wait for the target run's identity line before
asserting on its actions (review finding).
Integrate main's run-detail Changes (R4) and Graph (R5) work with the
connection banner/reconnect/foreground-recovery/live-badge work (T3/T4/T5).
Conflicts resolved by keeping both independent additions:
- web/styles.css: the .conn-*/.live-* rules and the .change-*/.diff-* rules
are separate blocks; both retained under their own comment headers.
- web/test/ui-smoke.mjs: both capture sequences retained (T3/T4/T5 writes
28-connected-banner/29-disconnected-banner/30-reconnect-recovered; R4/R5
writes its own distinct 28-34 run-change captures), so no filename collides.
Checks after the merge: node --check on all touched JS/MJS; node --test test/
225 pass / 0 fail; node test/ui-smoke.mjs --out <worktree>/captures UI SMOKE
PASS against ws://127.0.0.1:8080/connect, including the connected banner +
build line + live badge, the disconnected retry banner, the online-event
recovery, and main's R4/R5 captures.
Resolve the web/PARITY.md conflict by keeping main's R3 (now listing the
Graph tab) and R5 rows alongside this branch's R4 row; R4's Changes viewer
merges cleanly into app.js, styles.css and ui-smoke.mjs.
Add a collapsed-by-default Changes section to the run Summary tab and a
full-screen diff viewer, ported from the Android RunChanges/ChangeDiffViewer
wording. Pure aggregation and unified-patch parsing live in src/changes.js;
app.js wires the section/viewer and sets every server string with textContent.
Unit tests cover the header variants, kind merge, stat sums and hunk parsing;
ui-smoke captures the collapsed/expanded section, rendered and raw viewer,
paging, Escape/backdrop close, binary, truncated and a running run's header.
Close T3, T4 and T5 of web/PARITY.md (the "Transport and connection"
table). T1/T2/T6 are untouched beyond wiring.
- src/connection.js (new): the pure, DOM/socket/timer-free helpers behind
every new state — `bannerState` (the persistent banner's copy and tone),
`stateBadge` (the compact header indicator, which is also where the retry
attempt is named), `foregroundAction` (the return-to-foreground policy
from ConnectionRecovery.kt), `protocolMismatch`, `serverBuildLabel` and
`liveBadgeState`. Wording and colour roles mirror ConnectionBanner.kt,
LiveBadge.kt/RunStream.kt and SettingsScreen.kt.
- src/app.js: wiring only. The banner sits in normal document flow under
the header (never overlaying content); a Reconnect control appears beside
the URL field whenever `bannerState` offers one and re-opens the same
validated endpoint through `client.connect`, resetting the backoff;
`visibilitychange`/`online` drive the foreground recovery; the ping reply
records the server build and protocol for the banner.
- src/protocol.js: `PROTOCOL_VERSION = 1`, citing internal/protocol/
identity.go and Message.kt.
- styles.css: the .conn-* banner and .live-badge rules in the app's dark
palette, on the existing :root variables.
- test/connection.test.mjs (new): 18 focused unit tests for the pure
helpers, including source-parity assertions against the Android files.
- test/ui-smoke.mjs: assert the connected banner + build line + live badge
and capture them, then point the page at a closed port to capture the
disconnected retry banner and recover via the browser's `online` event.
- PARITY.md: T3/T4/T5 done with their captures.
Checks: `node --check` on all five touched JS/MJS files; `node --test
test/` 190 pass / 0 fail (18 new); `node test/ui-smoke.mjs --out ...
/web/captures` UI SMOKE PASS against ws://127.0.0.1:8080/connect, writing
28-connected-banner.png, 29-disconnected-banner.png and
30-reconnect-recovered.png.
Add the run detail's Graph tab (between Summary and Input), reusing the
shared src/graph.js renderer (P6) rather than a second renderer. In run
mode a visited stage is executed (solid fill + border), an unvisited one
hollow with a dashed muted border; a terminal is executed only when a
visit resolved to it; a route is executed only when a recorded visit
produced that outcome (solid with an arrowhead, success first, error
last, others alphabetical, `error*` for the fallback). The Executed /
Not executed legend shows only for a run. While the run executes the
current stage carries a pulsing halo (static under prefers-reduced-motion)
and a ticking elapsed badge; a finished run shows neither. Clicking a
stage opens the existing visit pane at that stage's latest visit, and
Back/Escape return focus. The empty state is the exact
"This server did not include the run graph."
extend src/graph.js with the run-mode inputs (runState-driven executed
styling, legend, active halo/elapsed badge); keep app.js to wiring.
Extend graph.test.mjs with focused run-mode unit tests and ui-smoke.mjs
with the run 438 / run 440 / live-run captures. Mark R5 done in
web/PARITY.md.
Checks: node --check on every touched file; cd web && node --test test/
(178 pass, 0 fail); cd web && node test/ui-smoke.mjs --out captures
(UI SMOKE PASS, captures 28-31).
The browser run detail becomes a tab strip — Summary, Input, Output,
Timeline — over the selected tab's body, with the Graph tab key reserved
for the R5 item.
- Summary: run label, status chip + outcome, the run identity line, the
key/value rows (Pipeline, Stage, waiting-for-resource line, Workspace,
content hash, Started, Finished, live Duration, Retry of, Diagnostic)
and the collapsed run artifacts gallery.
- Input / Output: one collapsed section per recorded map entry, the value
as a monospace block; empty states match the app.
- Timeline: one row per visit with the stage-outcome glyph, `{stage} ·
visit {n}`, an outcome chip, a paperclip when artifacts were recorded,
the duration and the description; a row opens the per-visit stage pane.
- Stage pane: headline rows, the Verdict block with inline artifact links
and the Artifacts / Session / Output / Input / This run / Stage
definition sections, all closable with Escape.
All new logic is the pure, DOM-free src/runDetail.js ported from the
Android sources; app.js keeps only the wiring and every server string is
set with textContent.
PARITY.md: R3, R6 and R7 marked done with their captures.
Close P6 of web/PARITY.md: the pipeline detail's Graph tab now renders the
pipeline's workflow graph — stage nodes in declaration order, labelled outcome
edges, and the #failure/#success terminals on a shared lower row — plus a
definition pane opened from a node.
- src/graph.js (new): reusable `mount(container, graph, options) -> { unmount }`
plus the pure helpers it is built from (layout, edges, `error*`, lanes,
fit/clamp/zoom, hit-test, stage-definition fields). Definition view only, so
the run-detail Graph tab (R5) can reuse it. Mirrors WorkflowGraph.kt,
GraphPalette.kt, GraphSemantics.kt, StageDetailPane.kt and RunGraphTab.kt.
- src/app.js: wiring only — mount the graph in the Graph tab, drop the previous
mount on every re-render.
- styles.css: the .graph-* styles in the app's dark palette.
- test/graph.test.mjs (new): focused unit tests for the pure helpers, no DOM.
- test/ui-smoke.mjs: open "Plan and land", switch to Graph, capture the graph,
a stage pane and the expanded view, and assert the zoom/pan clamps and the
empty-pane wording against the live server.
- PARITY.md: P6 done with the 2026-10-19 captures; P3 notes the Graph tab now
renders the graph; R5 stays todo.
Checks: node --check on all five touched JS/MJS files; `node --test test/`
137 pass / 0 fail; `node test/ui-smoke.mjs --out ../captures` UI SMOKE PASS
against ws://127.0.0.1:8080/connect.
Combine the R8/R9 artifacts gallery, viewer and session link with main's
pipelines/runs/templates work. app.js: keep both import blocks. ui-smoke.mjs:
the artifacts step now navigates to Runs and selects run 430 through the
post-main run-row markup (meta[data-run-id=430]) instead of the retired
'.list button.row #430' spike row.
Checks: node --check on every touched file; node --test test/ 108 pass;
live ui-smoke against ws://127.0.0.1:8080/connect passes (run 430: 18 tiles,
viewer '1 of 10 · image/png', session link .../artifacts/430/8/session.html).
captures/ stays untracked.
Close three rows of the browser client's parity checklist, matching the Android
app's wording and behaviour:
- P1 pipeline list: name; "id {id} · v{version} · {N stages}"; "updated d MMM
HH:mm"; a last-run line joined from list_runs (status chip plus
"{ago} · {duration} · run {id}", or "no runs recorded").
- P2 filter + sort: Filter menu (name contains, Runs Any/Has runs/No runs, the
seven server run statuses, Clear filters) and Sort menu (Server order default,
Name A-Z/Z-A, Most recent run, Fewest/Most stages, Reset). Server order is
preserved.
- P3 pipeline detail: Summary/Graph/Source tabs; Summary shows the content hash
(monospace), latest version, created/updated and a collapsed-by-default
Versions section. The Graph tab carries the browser guidance note only; the
rendered graph stays P6.
New src/pipelines.js holds the pure, DOM-free helpers (timestamps, durations,
last-run join, comparators, filter, empty states); app.js is wiring only.
web/test/pipelines.test.mjs covers the helpers; web/test/ui-smoke.mjs captures
the list, controls and detail against the live server. All server strings are
set with textContent.
Day-grouped run list with sticky day headers (Today / Yesterday / d MMM
yyyy / Unknown date), a usage roll-up block, the app's row hierarchy and
a bounded filter/sort menu — mirroring RunHistoryScreen.kt, ListFilter.kt
and ListSort.kt. New pure helpers live in src/runs.js with focused unit
tests; app.js keeps the wiring and sets server strings with textContent.
R1 done, R2 partial: no per-row "needs you" mark exists in the Android
app; its wording is deferred to R15 (separate attention surface).
Port the Android artifact derivation into a pure, DOM-free src/artifacts.js
(presentedArtifacts with the retired session.md hidden everywhere, grouping by
stage/visit, the header/summary/capture-note wording, kind and size formatting,
viewer paging and sessionExportArtifact) and unit-test it.
Wire it into src/app.js: a run-level artifacts gallery with per-(stage,visit)
groups, per-visit summaries and tiles, a full-screen viewer overlay (paging,
Escape/backdrop close) and the read-only session.html link. Every server string
is set with textContent; captures/ stays untracked.
Captured live against run 430 through test/ui-smoke.mjs:
captures/04-run-430-artifacts.png, 05-artifact-viewer.png,
06-session-export-link.png. PARITY.md marks R8 and R9 done.
Integrates nine commits of reviewed work from the lane-go branch after the
automated resolver failed on this merge five times (each attempt dying on the
malformed-result defect whose fix is contained in this same merge).
Integration decisions:
- Search: kept main's shipped design (Store.Search + SearchResponse.Results) and
dropped lane-go's parallel, older attempt (an unused Message.Matches field, an
absent runs.search, and two partial TUI plumbing blocks). lane-go itself did not
compile: protocol.SearchMatch was undefined and model.go referenced searchNav,
requestSearch and applyRunNav, which exist nowhere. Those partial TUI blocks are
removed; the queued TUI omni-search item will implement the surface properly on
main's design.
- Both sides' additions are kept where they are independent: run titles and
provenance, the human decision stage and its CLI/TUI surface, the derived stage
verdict, the stale-client guard, the line-oriented result format, and main's
search command.
- The search key's help label is now "/ omni search"; the two tests asserting the
old label are updated rather than the label reverted.
- docs/cli.md and the packaged operations reference carry both sides' text.
Verified: go build ./... , go vet ./... and the full go test ./... suite pass.