Chat turn visual specification

Assistant rendering across lifecycle states

Streaming, completed, and restored assistant messages use the same ExecutionStrip, ThinkingStep, and FunctionStep components. When ordered blocks are absent, existing thinking and tool records are adapted for presentation in their stored order; this fallback does not reconstruct missing interleaving or invent tool records. Tool results, error state, identifiers, and full-output references remain intact. Completion never switches to the legacy boxed ToolsBlock table.

Implementation acceptance: complete a turn with tool calls, expand its execution summary, then reload the conversation. The same shared rows and detail interaction remain available.

Chat math delimiters

Chat markdown already stashes complete $$/$/\[/\( blocks before marked and restores them as escaped text after sanitize. The React bubble still has to run KaTeX: MarkdownText typesets after paint, and the chat-area pin path calls typesetMath on the observed message column. Unclosed streaming math is not a complete stash pair; the next paint with a closer typesets. Sanitize, code, links, and ordinary escapes stay as they were. No new math library.

Acceptance: the sample \(d_t\) / \(v_t = (d_t - d_{t+1}) / d_t\) produces KaTeX HTML on the assistant bubble; display \[/$$ and inline $ do too; prose without math and incomplete openers do not typeset; invalid math does not throw.

Bounded transcript history

The transcript uses bidirectional, byte-budgeted pages. A connection owns a small LRU of immutable disk-backed snapshots with message-ID indexes. A page request reads only its selected display groups, preserving tool descendants and compaction metadata. Snapshot tokens are scoped to the connection, session and captured branch head. Replaced snapshots and disconnected connections release temporary files.

The browser targets four cached conversations, allowing displayed panes and requests in flight to temporarily exceed that limit, and releases page references when conversations are deleted. Each conversation retains at most six ordinary pages and an 8 MiB content budget per loaded transcript, with an indivisible page allowed when needed to preserve a single large turn. Eviction occurs opposite the reading position, never deleting persisted records; active updates are retained. Scrolling back automatically retrieves evicted pages in either direction. Measured rows outside the viewport unmount, preserving their height. Heights of evicted rows are removed.

Prefetch distance follows scroll direction and speed with a bounded maximum. Only one page request runs at a time; failures retry with exponential backoff. Invisible panes stop requesting and stale responses cannot overwrite a newer generation. Page insertion and eviction restore the visible message and its offset before paint. Restoration uses a message ID rather than a pixel offset in an obsolete window. Jump to latest retrieves the latest window directly.

Acceptance uses a 300,000-message synthetic source: repeated bidirectional paging keeps cached pages, rendered rows and measurements bounded; rapid scrolling under latency preserves a visible message; stale replies, reconnect, branch changes and live updates cannot corrupt the window. Backend page reads must not scan or parse the full snapshot after indexing. Cold snapshot construction remains a separate measured operation.

Protocol v2 defers the full graph until its view is visible; ordinary branch metadata requests omit graph bodies. Cold snapshot construction reads and enriches the authoritative branch once. Subsequent indexed pages avoid full hydration.

Interaction contract: the bottom of an intermediate history window is not the latest conversation position. Main and split panes share the same following, adaptive rendering and jump behavior. Jump remains available while newer history exists and after a failed request; repeated clicks share one pending intent. Wheel, pointer and keyboard interaction cancel a pending jump or saved-position restoration before it changes the visible window. Ordinary paging still compensates for inserted rows at the current reading position. Pane teardown saves the final reading anchor. Connectivity recovery resumes automatic loading without retaining an obsolete retry delay.

Interaction acceptance: browser tests exercise an intermediate-window bottom, failed and repeated jumps, interrupted delayed restoration, independent split panes and unmount/remount. These interaction refinements are implemented and pass independent specification and quality review. Browser acceptance also checks that the saved anchor survives queued animation frames after unmount.

Performance contract: bounded Chat loads skip graph construction when the captured messages have neither compaction coverage nor spawn/attach relationships requiring graph annotations. When those annotations are needed, the shared graph builder performs the same semantic filtering without viewport geometry; opening the DAG still requests its full layout. First-open persistence hydration remains linear in stored nodes. The Markdown cache uses a 256-entry LRU and an 8 MiB budget estimated from UTF-16 source and sanitized output lengths; an individual entry exceeding the budget is rendered but not retained. Cache policy never bypasses sanitization.

Performance acceptance uses persisted synthetic messages through the public load handler and production browser components. Timing, frame intervals and retained heap are recorded separately; stable regression checks assert skipped work, semantic equivalence, cache eviction and bounded retention rather than machine-specific timing. Performance refinements are implemented and pass independent specification and quality review. Public-handler regression verifies skipped graph work and compaction equivalence; browser regression verifies byte-budget eviction, LRU promotion and oversized-entry bypass. Timing and retained-heap comparisons are synthetic measurements, not guarantees for full-App workloads.

Implementation status: implemented. The 300,000-message synthetic-source browser test verifies bounded bidirectional paging, rapid reversals under delayed transport, saved-message restoration, live-row preservation and jumps during pending loads. Indexed backend reads, snapshot cleanup and the web regression suite pass. Cold construction still reads the authoritative branch once; synthetic measurements do not establish latency for large real-world attachments or tool output.

Conversation loading mark

Only the existing empty-reply thinking… placeholder replaces its loading mark with the approved 18px open double ring. The rings counter-rotate while exchanging radius and stroke width. Colors follow theme tokens; reduced motion freezes the mark and forced colors use system text color.

Execution summaries, thinking steps, function steps, nested calls, pane titles, retry notices and reply footers do not use this mark. No additional indicator position is selected by tool, thinking or text phase. The function timeline retains its original layout, text shimmer, running dot, disclosure structure and detail interactions.

Acceptance: an empty-reply placeholder displays one new mark; tool calls, thinking content and reply text add no double rings to the timeline or footer. Approval and terminal states suppress the placeholder. Independent history reconciliation, nested progress and stable-message rendering fixes remain intact. Implementation and acceptance evidence is recorded in the generation-motion-layout task report.

Transcript update ownership

Message IDs and ordered assistant blocks define the transcript. Execution trees supplement the owning reply; status trees never generate replacement chat rows. History snapshots reconcile with observed progress for the same message: running snapshots cannot remove received tool calls, shorten text, or reopen a settled reply. Terminal snapshots update lifecycle and metadata while retaining received trace when omitted. Branch and history-window replacement still removes rows absent from that window.

Each execution root keeps its persisted path. Repeated calls to the same function remain distinct, and a root is consumed once across all text-separated execution groups. A completed function remains in its existing execution summary. Direct function runs retain their standalone presentation. Acceptance exercises stream, partial history, completion, late tree updates, errors, cancellation, and reload through production reducers and rendered components.

Implementation status: verification pending.

Queue and current-turn input

Queued messages dispatch in order after the current turn. Consumed steering input appears between the preceding and subsequent reply content. Its user node remains independent; the reply stores an ordered boundary reference shared by streaming, cancellation and history loading. Older records without a boundary place steering before the owning reply using persisted predecessor edges, without guessing a text offset.

Receipt polling confirms the same command without changing the visible waiting label. Pending or uncertain delivery cannot be resent, edited or removed. Definitive rejection retains the ordinary queued draft; transport failure retains uncertain delivery and never resends it as another turn. Attachments use ordinary queue delivery. Session queues and editing order remain independent.

Streaming steer: an accepted text instruction interrupts the active ordinary text/reasoning response, preserves its emitted content, then applies the durable command at the completed provider boundary before the next model request. The request is closed before continuation. Tool-call argument streams, running tools and structured-output responses retain their existing safe-point delivery; no tool is replayed or cancelled by steer. Polling is bounded and works while the provider is silent.

Stop during pending steer preserves the partial reply and its active history position. A command rejected because of cancellation remains an unsent draft with an explicit Send action; cancellation never automatically converts that draft into a new turn. Cancellation projection may advance only the exact top-level turn from its own user node to its existing assistant node, using compare-and-set, and never changes a newer or explicitly selected branch.

Implementation status: streaming interruption and stop retention pass independent specification and quality review, affected tests and the full verification manifest. Installed-App acceptance is recorded separately in release evidence.

Failed replies

A failed reply retains its partial answer and ordered thinking/function trace. One terminal notice appears after that content, before message actions. A concise localized headline describes the failure; technical details expand on request and render as plain text. No automatic retry is added.

Partial reply blocks and failure detail have separate fields. The legacy node output retains the error text for model-context and non-Web consumers; the Web mapper restores the partial answer from ordered text blocks. The failed assistant node persists the detail, reason, retryability and retry delay before the final failure event. History restores the same notice. Legacy error output is recognized without rewriting history and does not repeat the answer inside the notice.

Scope: main chat failures, shared assistant bubble and history mapping. Existing cancellation, approval, nested function details, retry/branch semantics and Goal reports retain their behavior. The existing provider taxonomy design remains authoritative; this adds durable presentation without a competing error store or third-party UI dependency.

Acceptance: a public turn emits text and tools then fails; live rendering and cold history both show answer, trace and one final notice. Empty and legacy failed replies remain visible. Successful/cancelled replies gain no error notice. Details work in narrow and dark layouts.

Release regression coverage also retains browser permission inheritance and high-level agent delegation checks. Bound-page tests supply an explicit binding and expect the existing stop after three failed attempts on the same observation, including the concrete failure reason. They do not change the browser workflow or its permission policy.

Implementation status: implementation, independent specification and quality reviews, and the full declared verification manifest pass. The browser regression fixtures match the existing bound-page path and failure limit. Installed-App acceptance is recorded separately in release evidence.