Pure move, behaviour unchanged: app.js is now the shell (boot, state, client wiring, connection/banner, navigation and routes, render dispatch, header). Views live under src/views with shared DOM and format helpers. client.js stays DOM-free; no circular imports; every server-derived string still uses textContent.
Pure move, behaviour unchanged: every rule is carried verbatim into one of base, lists, run-detail, chat, graph, dialogs or settings, linked in a fixed order from index.html. No @import and no build step.
The layout prototype shows the operator's target shell: a left destination rail
(Pipelines/Runs/Chat/Settings) with the detail sections grouped in the rail, list
and detail panes, a status dot in the rail footer and no top connection chrome.
The spec's DOM sketch still mentions the old connection banner; the implementation
brief supersedes that (connection lives in Settings only).
The audit records 9 must-fix, 12 should-fix and 15 notes from real DOM and
accessibility-tree inspection, with file:line for each finding.
Add an opt-in --decide smoke mode that reuses or submits a human-only pipeline, starts two runs in throwaway workspaces, and presses the real card, sheet and Confirm for the feedback and no-feedback shapes. Record R11 as done with the live captures.
The created chat loads its history asynchronously; reading the DOM once raced the
load (worse when the OpenCode endpoint is busy), reporting a permanent 'Loading
conversation...' that the app never showed.
--compare BEFORE AFTER fails when a capture is missing or unexpected and lists
pixel drift for manual review; live durations make byte equality the wrong gate.
Describes what the client is, how to run and test it (OS-assigned smoke port,
gitignored captures), the module areas, and keeps the 403/proxy explanation that
justifies serving the page from serve.mjs.
Integration fixes found by the full suite:
- drop the dead 1 Hz run poll helpers still referencing R10-removed state (they
threw on every route apply, so the first connection never rendered a list);
- keep this tab's ephemeral verification chats across a reload (sessionStorage),
so a chat the server intentionally hides stays usable in the tab that made it;
- the smoke marks only the throwaway ephemeral, clears the marker after /new, and
tolerates a stale page banner plus a re-rendered row menu;
- the nav no longer claims a false Pipelines (0) before that list has loaded, and
the Runs destination preloads it once per connection.
Full suite: 580 unit tests green, UI SMOKE PASS.
Reconcile L6 with R10's live-run watch: onConnected waits for the connection's
watch on the first connect too, and the reconnect path uses R10's
loadCurrentView(runsFresh) call while keeping L6's detail re-hydration. The
selectRun catch keeps L6's stale-selection and server-refusal guards.
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.