Fixes found by running the full suite after merging main, not by the route
model itself:
- start the run-alert watch on the FIRST connection too: L6's early return for a
pending deep link skipped it, so no subscribe was sent (R10 broke silently);
- an ephemeral /new chat no longer refreshes the session list (the server
intentionally omits it), which had replaced the open conversation and dropped
its local notice;
- the chat row menu flips above the row when it would fall off the window, so the
last rows' items are hit-testable (a real defect, not clipping);
- smoke robustness for drifted live data: the C2 closed-row assertion opens C13's
menu, the C13 hide step opens a conversation when none is left open, the
timeline empty-state capture is skipped when no empty run exists, and the last
row is scrolled into view.
Full suite: 551 unit tests green, UI SMOKE PASS.
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).
Resolve the C11/C12 vs C13 overlap in the chat work:
- PARITY: keep main's done C11/C12 rows and this branch's done C13 row.
- app.js/chat tests: keep both import/helper sets (notices and overrides/seen).
- ui-smoke: keep main's C11 background-task bar, C12 notice checks and the
shared composer throwaway, and C13's row-menu rename/hide/seen checks.
The composer throwaway stays a listed server session: C12 switches away
and back to it and C13 reads its row, which an ephemeral create (2fe6301)
deliberately hides from chat_sessions. The live-run graph halo check is
best effort as its own comment says, so a run with no stage in flight at
capture time skips instead of failing the whole smoke.
Every run defaulted to 8091, so two parallel pipeline items running the UI
check collided with EADDRINUSE. An explicit --port/WEB_UI_PORT still wins;
otherwise the OS assigns a free port. Verified with two simultaneous --scratch
runs (60540/60541), both PASS.
The operator's chat list showed ~99 stray "New chat" entries. The listing
was already fail-closed (registry-only); the fault was what got recorded: an
automated UI check drives the real page, so its throwaway chat was recorded as
an operator chat exactly like a manually created one and stayed in the list for
ever (each run added one).
Server: chat_create takes an optional ephemeral flag. The session is created,
bootstrapped, usable, closable and reopenable exactly like any other, but its
registry row is hidden, so chat_sessions never lists it. operator_sessions gains
an ephemeral column (idempotent migration, existing rows default to listed) and
the list query filters it; the single-row lookup does not, so close/reopen keep
working. RecordVerificationSession is the hidden recorder.
Web: the page marks a create ephemeral only when automation asks for it
(__pipelinesEphemeralChat, set by the UI smoke for its throwaway chat), so the
smoke's own runs stop polluting while a manual create is unchanged.
Tests: a hidden row is never listed yet is still looked up and closable; a
normal re-record of the same id lists it again; a pre-ephemeral database
migrates with every existing chat still listed. Live data pruned separately
(107 -> 8 registry rows, backed up).
The discovery loop already opened the session it found, and openChatSession
keeps a loaded thread, so the assertion's second click early-returned and sent
nothing once the live server listed an empty session first.
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).
The merge put main's C5 live-stream section after the C8/C9 composer section,
but the composer section closes its throwaway session and returns to the list,
so no conversation was open for C5 to observe. The C5 section now re-opens the
operator's own session (read-only: real subscribe + history, synthetic frames
injected into the page's socket handler) and waits for its newest history page
to render before replaying, so the history load cannot replace the replayed
turn. `node test/ui-smoke.mjs` is green end to end against
ws://127.0.0.1:8080/connect.
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.
Both web-attention and web-chat declared 'const cleared' in the top-level
module scope of test/ui-smoke.mjs; the auto-merge kept both, which is a
SyntaxError. Rename the chat one to 'clearedQuery'.
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.