@north-light/api 0.3.580 → 0.3.587

package/dist/clients/attach/render/chat-view.js

@@ -0,0 +1,2108 @@
+// render/chat-view.ts — the render half of `crtr surface attach`.
+//
+// A direct port of pi's `InteractiveMode.handleEvent()`
+// (interactive-mode.js:2169-2462) + its rebuild path
+// (`addMessageToChat`/`renderSessionContext`, :2483-2648) that DRIVES pi's own
+// exported TUI components rather than reimplementing them. The viewer never
+// spawns pi and never opens the session — it only consumes the relayed
+// `AgentSessionEvent` stream + the `welcome` snapshot over `view.sock`.
+//
+// Ownership boundary: ChatView owns the chat scroll `Container` it is handed.
+// Its activity state (working spinner, compaction/retry indicators) is signaled
+// to the viewer-owned fixed slot when one is supplied. It does NOT own the
+// editor, the footer, or the terminal title — those are chrome laid out by the
+// attach command. Events that only affect that chrome
+// (queue_update / session_info_changed / thinking_level_changed) are forwarded
+// to the optional `onFooterEvent` sink instead of rendered here.
+//
+// Custom-tool rendering: extensions run in the broker, so the viewer generally
+// has no extension `ToolDefinition`. The viewer supplies native renderers only
+// for crouter-owned message/tool types it understands; other extension
+// `renderCall`/`renderResult` hooks degrade to the default ToolExecutionComponent
+// path while builtin tools, diffs, and partial-result streaming keep working.
+import { Container, Loader, Spacer, Text } from '@earendil-works/pi-tui';
+import { AssistantMessageComponent, BashExecutionComponent, BranchSummaryMessageComponent, CompactionSummaryMessageComponent, CustomMessageComponent, parseSkillBlock, SkillInvocationMessageComponent, ToolExecutionComponent, UserMessageComponent, } from '@earendil-works/pi-coding-agent';
+import { attachMarkdownTheme } from '../config.js';
+import { ContextMessageComponent } from './context-message.js';
+import { presentationFor } from './card-presentation.js';
+import { detectInlinePageResult, PageBlockComponent } from './page-block.js';
+import { CRTR_OUTPUT_CUSTOM_TYPE, CrtrOutputMessageComponent, createCrtrBashToolDefinition, } from './crtr-output.js';
+import { CRTR_CYCLE_DIVIDER_CUSTOM_TYPE, endedByAbort } from '../../../core/runtime/session-cycles.js';
+import { isHumanWordsEntry, parseCard } from '../../../shared/generated-context.js';
+import { assistantVisibleText, isGroupBoundaryKind, isTrueUserMessage, } from '../../../shared/tool-groups.js';
+import { messageKey, normalizeTurnReplyRecord, START_TURN_KEY, turnReplyText, } from '../../../shared/turn-replies.js';
+import { isCycleDivider } from './condensed-history.js';
+import { transformDiagramFences } from './diagram.js';
+import { styleAttachAgentMarkdown, styleAttachMarkdownSource, styleAttachMessageMarkdown, styleAttachSummaryMarkdown, } from './markdown-source.js';
+import { createCrtrEditToolDefinition } from './edit-diff.js';
+import { GroupActivityRecorder } from './group-activity.js';
+import { GroupRecapComponent } from './group-recap.js';
+import { FoldedToolCallController, bashCallBackgroundHintLines, createCrtrPlainBashToolDefinition, createCrtrReadToolDefinition, createCrtrWriteToolDefinition, } from './tool-calls.js';
+import { ringCompletionBell } from '../chrome/completion-bell.js';
+import { extractFilePaths } from '../../../core/human/visible-paths.js';
+import { extractDocRefs } from './doc-links.js';
+import { keepWhenCondensed, liveRegionStart } from './condensed-history.js';
+import { ViewerAssistantMessageComponent } from './assistant-message.js';
+import { CompositeViewportSource, MeasuredContainer, } from './measured-container.js';
+import { readConfig, updateRawConfigAtomically } from '../../../core/config.js';
+import { DEFAULT_CONDENSED_HISTORY, DEFAULT_LIVE_CYCLES } from '../../../types.js';
+import { applySnapshot as projectSnapshot, applyToolGroupSummary as projectToolGroupSummary, applyWorkingActivity as projectWorkingActivity, bashEnd as projectBashEnd, bashOutput as projectBashOutput, bashStart as projectBashStart, initialConvState, reduce as projectEvent, } from '../../conversation/projection.js';
+/** Theme-derived chrome colors (spinner / dim / error) are supplied by the
+ *  attach command via `ChatViewOptions.palette` (built from the live theme in
+ *  config.ts). pi does not re-export the raw `theme` instance, so standalone
+ *  ChatViews receive the same semantic ANSI fallback palette. The message components
+ *  use the attach Markdown theme, which preserves the user's pi theme while making
+ *  fenced code visually distinct. */
+const defaultDimStyle = (s) => `\x1b[2m${s}\x1b[22m`;
+/** How many catch-up messages `applySnapshot` builds between event-loop yields.
+ *  Keeps large non-streaming snapshots from monopolizing the main thread so
+ *  queued keystrokes are serviced during construction. */
+const SNAPSHOT_YIELD_EVERY = 50;
+/** The user's `live_cycles` setting — how many trailing refresh-yield cycles the
+ *  transcript renders at full fidelity. Read per ChatView (i.e. per attach), so
+ *  `crtr sys config set live_cycles --value N` takes effect on the next attach
+ *  without a daemon restart. A missing/unreadable config falls back to the
+ *  shipped default. */
+function readLiveCycles() {
+    try {
+        return readConfig('user').live_cycles;
+    }
+    catch {
+        return DEFAULT_LIVE_CYCLES;
+    }
+}
+/** The user's `condensed_history` setting — which messages of an already-condensed
+ *  cycle still render (the cycle dividers always do). Read per attach, like
+ *  `live_cycles`. */
+function readCondensedHistory() {
+    try {
+        return readConfig('user').condensed_history;
+    }
+    catch {
+        return DEFAULT_CONDENSED_HISTORY;
+    }
+}
+/** The user's `fold_finished_tools` setting — the persisted starting state of the
+ *  fold view setting. Toggling it in a viewer writes it back (`persistFoldFinishedTools`),
+ *  so the choice carries into later chats and later viewers. */
+function readFoldFinishedTools() {
+    try {
+        return readConfig('user').fold_finished_tools;
+    }
+    catch {
+        return false;
+    }
+}
+/** Whether this attach should start folded tool groups on their broker-generated
+ * summaries. The setting is deliberately attach-local: the broker remains the
+ * single summary producer and every viewer independently chooses its display. */
+function readSummarizeToolCalls() {
+    try {
+        return readConfig('user').summarize_tool_calls;
+    }
+    catch {
+        return false;
+    }
+}
+/** Whether folded tool recaps list their actual activity or use compact counts.
+ * The detailed form is the default; each attach reads its own presentation choice. */
+function readDetailedToolRecaps() {
+    try {
+        return readConfig('user').detailed_tool_recaps;
+    }
+    catch {
+        return true;
+    }
+}
+/** The `consolidate_replies` experiment: fold each turn behind one reply. Read
+ * per attach. */
+function readConsolidateReplies() {
+    try {
+        return readConfig('user').consolidate_replies;
+    }
+    catch {
+        return false;
+    }
+}
+/** Persist the fold view setting to user config. Best-effort: a viewer must never
+ *  die because the config file is unwritable — the in-viewer toggle still applies. */
+async function persistFoldFinishedTools(value) {
+    try {
+        await updateRawConfigAtomically('user', (latest) => ({ ...latest, fold_finished_tools: value }));
+    }
+    catch {
+        // ignored — the fold still applies to this viewer.
+    }
+}
+/** A component supports the Ctrl+O global tool-output toggle. Mirrors pi's
+ *  `isExpandable` duck-type (interactive-mode.js): any rendered child carrying a
+ *  `setExpanded(boolean)` method — tool executions, custom/compaction/branch/skill
+ *  message components — participates; everything else (the status container, plain
+ *  text, assistant/user bubbles) is skipped. */
+function isExpandable(obj) {
+    return (typeof obj === 'object' &&
+        obj !== null &&
+        'setExpanded' in obj &&
+        typeof obj.setExpanded === 'function');
+}
+/** Every SGR escape, for measuring a line's visible content. */
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+/** Same match, with the SGR parameter list captured for rewriting. */
+const SGR_PARAMS_RE = /\x1b\[([0-9;]*)m/g;
+/** Drop every background-color SGR parameter from a line, keeping foreground and
+ *  text styles. The minimized fold is a dense index of what ran, so the tool's
+ *  pending/success/error background band (pi paints it across the full pane width)
+ *  reads as noise there — one call per line, unhighlighted. `0` (full reset) is
+ *  kept: it clears the background too, and nothing follows it to re-set one. */
+function stripBackground(line) {
+    return line.replace(SGR_PARAMS_RE, (_whole, params) => {
+        const parts = params.split(';');
+        const kept = [];
+        for (let i = 0; i < parts.length; i++) {
+            const code = Number(parts[i] === '' ? 0 : parts[i]);
+            // Extended colors (`38` foreground, `48` background, `58` underline):
+            // consume the full sequence atomically so an RGB channel in the 40-47 or
+            // 100-107 range is not mistaken for a standalone background code.
+            if (code === 38 || code === 48 || code === 58) {
+                const mode = Number(parts[i + 1]);
+                const end = i + (mode === 5 ? 2 : mode === 2 ? 4 : 1);
+                if (code !== 48)
+                    kept.push(...parts.slice(i, end + 1));
+                i = end;
+                continue;
+            }
+            // Standard (40-47) and bright (100-107) backgrounds. `49` (reset to the
+            // default background) is KEPT — it is the thing we want, and dropping it
+            // would let a neighbouring row's background bleed into this line.
+            if ((code >= 40 && code <= 47) || (code >= 100 && code <= 107))
+                continue;
+            kept.push(String(code));
+        }
+        return kept.length > 0 ? `\x1b[${kept.join(';')}m` : '';
+    });
+}
+/** Sender sections of an inbox card body; `parseCard` already read their entries.
+ * Whatever remains is other content riding the same digest. */
+const INBOX_SENDER_SECTIONS = /<from\b[^>]*>[\s\S]*?<\/from>/g;
+/** A tool component that can fold itself down to its CALL. pi's `ToolExecutionComponent`
+ *  only knows expanded/collapsed, so each crtr-owned definition receives a local fold
+ *  controller and captures the compact call component it renders. Folded render paints
+ *  that captured call directly, dropping result and Box chrome while letting a wrapped
+ *  path keep its natural rows. Tools without a crtr definition remain in full. */
+/** A one-line separator that appears only while its adjacent tool group is
+ * folded. It stays in the transcript so toggling folded tools reflows the same
+ * message/tool boundary without rebuilding the chat. */
+class FoldedToolSeparator extends Spacer {
+    folded = false;
+    separatesToolGroup = false;
+    setFolded(folded) {
+        this.folded = folded;
+        this.refresh();
+    }
+    setSeparatesToolGroup(separatesToolGroup) {
+        this.separatesToolGroup = separatesToolGroup;
+        this.refresh();
+    }
+    refresh() {
+        this.setLines(this.folded && this.separatesToolGroup ? 1 : 0);
+    }
+}
+/** The dim row under a consolidated reply that stands for the folded working. */
+class WorkingRow extends Container {
+    label = new Text('', 1, 0);
+    constructor() {
+        super();
+        this.addChild(new Spacer(1));
+        this.addChild(this.label);
+    }
+    setLabel(label) {
+        this.label.setText(label);
+    }
+}
+function plural(count, singular, pluralForm) {
+    return `${count} ${count === 1 ? singular : pluralForm}`;
+}
+class MinimizableToolComponent extends ToolExecutionComponent {
+    /** Bound by ChatView at append time; pi's base component does not expose it. */
+    activityCallId;
+    minimized = false;
+    expandedState = false;
+    foldController;
+    resultObserver;
+    /** A foldable definition owns its folded call component; it may also observe
+     *  results before the imported shell renders them. */
+    setToolView(foldController, resultObserver) {
+        this.foldController = foldController;
+        this.resultObserver = resultObserver;
+    }
+    updateResult(...args) {
+        this.resultObserver?.(args[0], args[1] ?? false);
+        // The clock stays in the model's persisted result and copyable transcript,
+        // but need not consume a visible row in the human's tool card.
+        const result = args[0];
+        const content = result.content;
+        if (Array.isArray(content) && /^elapsed \d+(?:h \d+)?m \d+s(?:\n|$)/.test(content.at(-1)?.text ?? '')) {
+            super.updateResult({ ...result, content: content.slice(0, -1) }, args[1]);
+        }
+        else {
+            super.updateResult(...args);
+        }
+    }
+    setExpanded(expanded) {
+        this.expandedState = expanded;
+        super.setExpanded(expanded);
+    }
+    /** Flip the local fold state, then use the imported component's public
+     *  expansion setter to rebuild its call renderer at the current setting. */
+    setMinimized(minimized) {
+        if (!this.foldController || this.minimized === minimized)
+            return;
+        this.minimized = minimized;
+        this.foldController.setFolded(minimized);
+        super.setExpanded(this.expandedState);
+    }
+    render(width) {
+        // The backgrounding row is appended HERE, by the component that owns the
+        // whole tool block, so it renders after the block's highlighted band ends
+        // instead of inside it. It is empty unless this is a bash call still running
+        // past the threshold.
+        if (!this.minimized) {
+            return [...super.render(width), ...bashCallBackgroundHintLines(this.foldController?.callComponent(), width)];
+        }
+        const call = this.foldController?.callComponent();
+        if (!call)
+            return super.render(width);
+        // trimEnd drops right-hand padding, which only existed to carry the
+        // background band these lines no longer paint.
+        return call.render(width)
+            .filter((line) => line.replace(ANSI_RE, '').trim().length > 0)
+            .map((line) => stripBackground(line).trimEnd());
+    }
+}
+const defaultErrorStyle = (s) => `\x1b[31m${s}\x1b[39m`;
+const defaultAttachPalette = {
+    accent: (s) => `\x1b[33m${s}\x1b[39m`,
+    active: (s) => `\x1b[36m${s}\x1b[39m`,
+    info: (s) => `\x1b[34m${s}\x1b[39m`,
+    muted: defaultDimStyle,
+    faint: defaultDimStyle,
+    border: (s) => s,
+    surface: (s) => s,
+    bold: (s) => `\x1b[1m${s}\x1b[22m`,
+    error: defaultErrorStyle,
+    warning: (s) => `\x1b[33m${s}\x1b[39m`,
+    diffAdded: (s) => `\x1b[32m${s}\x1b[39m`,
+    diffRemoved: (s) => `\x1b[91m${s}\x1b[39m`,
+    bashMode: (s) => `\x1b[32m${s}\x1b[39m`,
+    bashModeAlt: (s) => `\x1b[92m${s}\x1b[39m`,
+};
+export class ChatView {
+    tui;
+    /** The chat scroll area handed in by the attach command. */
+    container;
+    /** Settled history is cached independently from the live status area so picker
+     *  navigation does not re-render a long conversation on every key repeat. */
+    historyContainer = new MeasuredContainer();
+    /** Standalone ChatViews render activity inline; the attach viewer supplies
+     *  `onActivityChange`, so its transcript excludes this container. */
+    statusContainer = new MeasuredContainer();
+    /** Optional banner, above history and status in the viewport's flat source. */
+    bannerContainer;
+    transcript;
+    /** Where `append()` puts a component. Normally `historyContainer`; retargeted to
+     *  a nested container while condensed history is being built, so the same
+     *  message-rendering path serves both regions. */
+    appendTarget = this.historyContainer;
+    /** Inline page blocks placed in this transcript, by page id — one block per
+     *  page, so a `--replace` revision refreshes the block already on screen. */
+    pageBlocks = new Map();
+    /** The person's inbox answers in the live region, each with its leading
+     *  spacer. Summary mode hides them with the settled pages they answer. */
+    inboxAnswers = new Set();
+    inlinePageBlocks;
+    pageOpenHint;
+    backgroundBashHint;
+    /** Trailing cycles kept at full fidelity (config `live_cycles`). */
+    liveCycles;
+    /** Messages kept from a condensed cycle (config `condensed_history`). */
+    condensedHistory;
+    cwd;
+    showImages;
+    imageWidthCells;
+    hideThinking;
+    hiddenThinkingLabel;
+    /** Ctrl+O: pi's two-state tool-output expansion. */
+    toolOutputExpanded;
+    /** The view setting (Alt+C → z → f): fold every SETTLED tool call to its single
+     *  call line. Independent of `toolOutputExpanded` — it survives an expand/collapse
+     *  and only ever applies to tool calls that are done. */
+    foldSettledTools = readFoldFinishedTools();
+    /** Summary mode only changes Ctrl+O when both persistent settings are on. */
+    summarizeToolCalls = readSummarizeToolCalls();
+    detailedToolRecaps = readDetailedToolRecaps();
+    showGroupSummaries = this.summarizeToolCalls && this.foldSettledTools;
+    /** Groups exist only while building/rendering the full-fidelity live region. */
+    groups = [];
+    openGroup;
+    /** Consolidated replies (`consolidate_replies`), read once per attach. */
+    consolidateReplies = readConsolidateReplies();
+    /** `/show-working`: expand every turn's working. Viewer-local, not persisted. */
+    showWorking = false;
+    turnReplies = new Map();
+    turns = [];
+    openReplyTurn;
+    /** The turn the live region opens in when it begins mid-turn (the condensed
+     * region held its person's message), else the pre-message `start` turn. */
+    carriedTurn = { key: START_TURN_KEY, prose: [] };
+    /** >0 while appending components that never join a turn (the person's
+     * message, turn chrome, errors, condensed history). */
+    outsideTurns = 0;
+    /** Components the turn fold currently hides. */
+    turnHidden = new Set();
+    groupSummaries = new Map();
+    /** Node id → display name for every node spawned in this transcript, so a
+     *  later group's finish notice can name the child rather than its id. */
+    nodeRoster = new Map();
+    streamingWasGroupMember = false;
+    onFooterEvent;
+    /** Viewer hook that places activity in its fixed slot, when available. */
+    onActivityChange;
+    /** Theme-derived colorizers for the activity/status area. */
+    spinnerStyle;
+    dimStyle;
+    errorStyle;
+    /** Palette shared with recap rows that render outside pi tool callbacks. */
+    recapPalette;
+    /** Bold accent for the expanded crtr-context label. */
+    labelStyle = (s) => `\x1b[1m${s}\x1b[22m`;
+    /** Viewer-local Markdown projection, handed to pi's message components so
+     *  THEY apply it at render time with the exact content width. The viewer keeps
+     *  no projected copy: the components hold canonical source, and each
+     *  transformer reads live viewer state on every call. Diagrams apply only to
+     *  assistant-authored Markdown. */
+    markdownTransformers = [
+        (markdown, { messageType, availableWidth }) => (messageType === 'assistant' ? transformDiagramFences(markdown, availableWidth) : markdown),
+        (markdown, { messageType }) => (messageType === 'user' ? styleAttachMarkdownSource(markdown) : styleAttachAgentMarkdown(markdown)),
+    ];
+    /** The assistant message component currently being streamed (between
+     *  message_start and message_end for an assistant turn). */
+    streamingComponent;
+    /** The separator immediately after the live assistant component. It becomes
+     *  visible when that response has visible prose or thinking and folded tools. */
+    streamingToolSeparator;
+    /** Content classes for each separator, so Ctrl+T can add/remove thinking gaps
+     * without rebuilding the transcript. */
+    foldedToolSeparatorContents = new Map();
+    /** Tool-call id → its execution component, for the duration of the call. */
+    pendingTools = new Map();
+    /** The `!` bash component currently streaming (between bash_start and bash_end). */
+    bashComponent;
+    /** The single active activity loader (working/compaction/retry), if any. */
+    activityLoader;
+    /** The shared broker transcript state; this renderer projects it into pi TUI
+     *  components while retaining terminal-only folding and virtualization. */
+    projection = initialConvState();
+    /** Broker-selected normal label for this turn; compaction/retry temporarily
+     *  replace it and restore it when the run remains active. */
+    workingActivity = this.projection.workingActivity;
+    runActive = false;
+    // -- Single-writer snapshot ordering -------------------------------------
+    // A non-streaming catch-up yields to the event loop mid-build (so queued stdin
+    // drains), which opens a window where later broker frames could otherwise
+    // mutate a half-rebuilt transcript. These three fields make the ChatView a
+    // single ordered writer: applySnapshot is the only thing that mutates the
+    // view while a build is in flight, live frames are deferred and replayed in
+    // wire order once it finishes, and a newer welcome always supersedes an older
+    // build. See applySnapshot / deferIfBuilding.
+    /** True while applySnapshot is mid-build; live broker frames defer instead of
+     *  mutating the partially-rebuilt view. */
+    applyingSnapshot = false;
+    /** Bumped on every applySnapshot. A build suspended at a yield compares this
+     *  after resuming and abandons itself when a newer welcome has bumped it, so
+     *  the newest welcome wins and stale state never overwrites the live view. */
+    snapshotGeneration = 0;
+    /** Live frames captured during an in-flight build (bound closures that re-run
+     *  the original entry point), replayed in order when the build completes and
+     *  dropped when a newer welcome supersedes the build. */
+    deferredFrames = [];
+    /** Text of the most recent assistant message, kept current from the welcome
+     *  snapshot AND the live event stream so `/copy` (getLastAssistantText) works
+     *  whether the message arrived before or after attach. */
+    lastAssistantText;
+    /** Existing file paths found anywhere in the rendered transcript, newest first. */
+    transcriptFilePaths = [];
+    /** `[[ref]]` document references from the transcript, newest first. */
+    transcriptDocRefs = [];
+    /** Canonical copyable transcript blocks, in their rendered visual order. */
+    copyBlockRecords = [];
+    copyIndex = new Map();
+    /** Registrations made while building condensed history are collapsed onto its
+     * outer container once that container becomes a top-level viewport block. */
+    condensedCopyBlocks = new WeakMap();
+    constructor(tui, container, opts = {}) {
+        this.tui = tui;
+        this.container = container;
+        this.cwd = opts.cwd ?? process.cwd();
+        this.showImages = opts.showImages ?? true;
+        this.imageWidthCells = opts.imageWidthCells ?? 60;
+        this.hideThinking = opts.hideThinking ?? false;
+        this.hiddenThinkingLabel = opts.hiddenThinkingLabel ?? 'Thinking...';
+        this.toolOutputExpanded = opts.toolOutputExpanded ?? false;
+        this.liveCycles = opts.liveCycles ?? readLiveCycles();
+        this.condensedHistory = opts.condensedHistory ?? readCondensedHistory();
+        this.onFooterEvent = opts.onFooterEvent;
+        this.onActivityChange = opts.onActivityChange;
+        this.inlinePageBlocks = opts.inlinePageBlocks ?? false;
+        this.pageOpenHint = opts.pageOpenHint ?? (() => 'crtr human list');
+        this.backgroundBashHint = opts.backgroundBashHint ?? (() => null);
+        this.recapPalette = opts.palette ?? defaultAttachPalette;
+        this.spinnerStyle = this.recapPalette.active;
+        this.dimStyle = this.recapPalette.muted;
+        this.errorStyle = this.recapPalette.error;
+        // Banner sits above history and OUTSIDE it, so resetChat() (which clears only
+        // historyContainer) never wipes it — it persists across every welcome snapshot.
+        if (opts.banner && opts.banner.length > 0) {
+            const banner = new MeasuredContainer();
+            banner.addChild(new Spacer(1));
+            for (const line of opts.banner)
+                banner.addChild(new Text(line, 1, 0));
+            banner.addChild(new Spacer(1));
+            this.bannerContainer = banner;
+            this.container.addChild(banner);
+        }
+        this.container.addChild(this.historyContainer);
+        if (!this.onActivityChange)
+            this.container.addChild(this.statusContainer);
+        this.transcript = new CompositeViewportSource([
+            ...(this.bannerContainer ? [this.bannerContainer] : []),
+            this.historyContainer,
+            ...(this.onActivityChange ? [] : [this.statusContainer]),
+        ]);
+    }
+    /** The transcript as one flat ordered block list for the viewport. */
+    transcriptSource() {
+        return this.transcript;
+    }
+    // Catch-up: render the welcome snapshot, then live events resume.
+    /** Render the full message history from a `welcome` snapshot. Ports pi's
+     *  `renderSessionContext` (interactive-mode.js:2553): assistant messages spawn
+     *  tool-execution components matched to their toolResult messages; everything
+     *  else routes through `addMessageToChat`. The TUI's differential renderer +
+     *  reflow-on-resize is automatic — no scrollback reconstruction needed. */
+    async applySnapshot(snapshot) {
+        // Open a new build generation. Any older build still suspended at a yield
+        // abandons itself when it resumes (generation check below), and live frames
+        // that were deferred against the transcript we are about to discard are
+        // dropped — a newer welcome always wins.
+        const generation = ++this.snapshotGeneration;
+        this.applyingSnapshot = true;
+        this.deferredFrames.length = 0;
+        this.resetChat();
+        this.projection = projectSnapshot(snapshot, this.projection);
+        this.workingActivity = this.projection.workingActivity;
+        this.runActive = this.projection.isStreaming;
+        this.seedToolGroupSummaries(this.projection.toolGroupSummaryDetails);
+        this.turnReplies.clear();
+        if (this.consolidateReplies) {
+            for (const [key, reply] of Object.entries(normalizeTurnReplyRecord(snapshot.turnReplies)))
+                this.turnReplies.set(key, reply);
+        }
+        const renderedPendingTools = new Map();
+        const messages = this.projection.messages;
+        const lastIndex = messages.length - 1;
+        // Cycles older than the trailing `live_cycles` are condensed into one nested
+        // container before the live region is built. It retains only configured prose
+        // and cycle seams, avoiding old tool components while still reflowing on pane
+        // resize. `liveStart` is 0 until the node has yielded past the configured
+        // window, so a fresh node renders at full fidelity.
+        const liveStart = liveRegionStart(messages, this.liveCycles);
+        if (liveStart > 0) {
+            const condensed = await this.buildCondensedBlock(messages.slice(0, liveStart), generation);
+            if (generation !== this.snapshotGeneration)
+                return;
+            if (condensed)
+                this.appendCondensedBlock(condensed);
+        }
+        for (let i = liveStart; i < messages.length; i++) {
+            // Yield to the event loop every SNAPSHOT_YIELD_EVERY messages so queued
+            // stdin drains (keystrokes are handled instead of bursting after a long
+            // catch-up) while a big transcript constructs. Skipped for a STREAMING
+            // snapshot: its in-flight tail + pending tools must be bound before any
+            // relayed message_update/message_end lands, so it builds synchronously
+            // (no await → no broker frame can interleave and freeze the live bubble).
+            if (!this.projection.isStreaming &&
+                i > liveStart &&
+                (i - liveStart) % SNAPSHOT_YIELD_EVERY === 0) {
+                await new Promise((resolve) => setImmediate(resolve));
+                // A newer welcome arrived while we were suspended — abandon this stale
+                // build without touching the view (or the gate) it no longer owns.
+                if (generation !== this.snapshotGeneration)
+                    return;
+            }
+            const message = messages[i];
+            if (message.role === 'assistant') {
+                // Keep the `/copy` source current from the catch-up transcript too, not
+                // only the live stream (you usually attach AFTER the last reply landed).
+                const text = assistantVisibleText(message);
+                if (text.trim()) {
+                    this.lastAssistantText = text;
+                    this.pushTranscriptText(text);
+                }
+                // If the snapshot caught an IN-FLIGHT assistant turn (state.isStreaming
+                // and this is the trailing, non-terminal assistant message), bind it as
+                // the live streaming component so the relayed message_update/message_end
+                // frames that follow `welcome` land on it. Otherwise the in-flight
+                // message would freeze at its snapshot value until the next turn — the
+                // common case, since you typically attach to a node that is working.
+                const isStreamingTail = i === lastIndex &&
+                    this.projection.isStreaming &&
+                    message.stopReason !== 'aborted' &&
+                    message.stopReason !== 'error';
+                const hasProse = assistantVisibleText(message).trim() !== '';
+                const toolCalls = this.assistantToolCalls(message);
+                const endedWithFailure = message.stopReason === 'aborted' || message.stopReason === 'error';
+                const terminalErrorMessage = endedByAbort(message) ? 'Interrupted' : (message.errorMessage ?? 'Error');
+                // A terminal assistant failure remains visible as its own boundary. Settle
+                // any interrupted calls so the completed span before it can still recap.
+                if (endedWithFailure) {
+                    for (const component of renderedPendingTools.values()) {
+                        const result = { content: [{ type: 'text', text: terminalErrorMessage }], isError: true };
+                        component.updateResult(result);
+                        this.registerCopyBlock(component, 'tool', terminalErrorMessage);
+                        this.settleGroupTool(component, result, true);
+                    }
+                    renderedPendingTools.clear();
+                }
+                if (hasProse || endedWithFailure)
+                    this.closeOpenGroup();
+                let separator;
+                if (isStreamingTail) {
+                    this.streamingComponent = new ViewerAssistantMessageComponent(undefined, this.hideThinking, attachMarkdownTheme(), this.hiddenThinkingLabel, this.markdownTransformers);
+                    this.appendAssistantPart(this.streamingComponent, !hasProse);
+                    this.registerCopyBlock(this.streamingComponent, 'assistant', '');
+                    this.streamingWasGroupMember = !hasProse;
+                    this.streamingComponent.updateContent(message);
+                    this.registerCopyBlock(this.streamingComponent, 'assistant', assistantVisibleText(message));
+                    separator = this.streamingToolSeparator = this.appendAssistantSeparator(!hasProse);
+                }
+                else {
+                    separator = this.appendAssistantMessage(message, !hasProse && !endedWithFailure);
+                }
+                if (separator)
+                    this.setAssistantSeparatorContent(separator, message);
+                for (const content of toolCalls) {
+                    this.pushTranscriptValue(content.arguments);
+                    const component = this.appendToolComponent(content.name, content.id, content.arguments);
+                    // (isStreamingTail is never aborted/error, so its tools fall through to
+                    //  renderedPendingTools → pendingTools, where live tool events find them.)
+                    if (message.stopReason === 'aborted' || message.stopReason === 'error') {
+                        component.updateResult({ content: [{ type: 'text', text: terminalErrorMessage }], isError: true });
+                        this.registerCopyBlock(component, 'tool', terminalErrorMessage);
+                        this.settleGroupTool(component, { content: [{ type: 'text', text: terminalErrorMessage }], isError: true }, true);
+                    }
+                    else {
+                        renderedPendingTools.set(content.id, component);
+                    }
+                }
+                if (endedWithFailure)
+                    this.closeOpenGroup();
+                if (!isStreamingTail && !endedWithFailure)
+                    this.recordTurnProse(message, false);
+            }
+            else if (message.role === 'toolResult') {
+                this.pushTranscriptText(this.userMessageText(message));
+                const component = renderedPendingTools.get(message.toolCallId);
+                if (component) {
+                    component.updateResult(message);
+                    this.registerCopyBlock(component, 'tool', this.toolResultText(message));
+                    this.historyContainer.markDirty(component);
+                    this.settleGroupTool(component, message, message.isError === true);
+                    renderedPendingTools.delete(message.toolCallId);
+                    this.maybeAppendPageBlock(message);
+                }
+            }
+            else {
+                this.addMessageToChat(message);
+            }
+        }
+        for (const [id, component] of renderedPendingTools) {
+            this.pendingTools.set(id, component);
+        }
+        for (const turn of this.turns)
+            this.refreshTurn(turn);
+        // A rebuild constructs fresh components, which are born unfolded; re-apply the
+        // setting so a reconnect/welcome does not silently unfold the transcript.
+        this.applyToolDisplay();
+        // If we attached mid-turn, the `agent_start` that spins up the working loader
+        // already fired before we connected — restore it from the snapshot's streaming
+        // state so an actively-working node shows the spinner right away.
+        if (this.projection.isStreaming)
+            this.setActivity(this.makeLoader(this.workingActivity));
+        this.tui.requestRender();
+        // Build complete and still current (a mismatch would have returned above):
+        // open the gate and replay, in wire order, any live frames that arrived
+        // during construction so they land on the finished transcript.
+        this.applyingSnapshot = false;
+        this.replayDeferredFrames();
+    }
+    /**
+     * Build the condensed form of the already-finished cycles as a nested component
+     * container, or return undefined when nothing survives condensation.
+     *
+     * Reuses `addMessageToChat` by retargeting `append()` at the nested container, so
+     * condensed history uses the same renderer as live history with tool traffic
+     * filtered out. The outer history cache keeps stable-width frames cheap, while
+     * preserving the components lets pane-width changes reflow their content. The
+     * build yields on the live cadence and abandons itself when a newer welcome
+     * supersedes this generation.
+     */
+    async buildCondensedBlock(messages, generation) {
+        const condensed = new Container();
+        const previousTarget = this.appendTarget;
+        const copyBlocks = [];
+        this.appendTarget = condensed;
+        this.condensedCopyBlocks.set(condensed, copyBlocks);
+        try {
+            if (this.consolidateReplies) {
+                if (!(await this.buildCondensedTurns(messages, generation)))
+                    return undefined;
+                return condensed.children.length > 0 ? { component: condensed, copyBlocks } : undefined;
+            }
+            let built = 0;
+            for (const message of messages) {
+                if (!keepWhenCondensed(message, this.condensedHistory))
+                    continue;
+                if (built > 0 && built % SNAPSHOT_YIELD_EVERY === 0) {
+                    await new Promise((resolve) => setImmediate(resolve));
+                    if (generation !== this.snapshotGeneration)
+                        return undefined;
+                }
+                built++;
+                // Condensed prose still feeds the @-path picker; `lastAssistantText` (the
+                // `/copy` source) deliberately does not — the live region always holds the
+                // newest reply.
+                this.pushTranscriptText(this.userMessageText(message));
+                this.addMessageToChat(message);
+            }
+        }
+        finally {
+            this.appendTarget = previousTarget;
+            this.condensedCopyBlocks.delete(condensed);
+        }
+        return condensed.children.length > 0 ? { component: condensed, copyBlocks } : undefined;
+    }
+    /** Consolidated replies in condensed history: each finished turn renders as
+     * the person's message, its reply, then any cycle dividers it spanned. A turn
+     * still open at the end continues into the live region, so it is carried there
+     * instead of rendered. Returns false when a newer welcome superseded the build. */
+    async buildCondensedTurns(messages, generation) {
+        const turns = [{ key: START_TURN_KEY, prose: [], dividers: [] }];
+        for (const message of messages) {
+            const turn = turns.at(-1);
+            if (isTrueUserMessage(message)) {
+                turns.push({ key: messageKey(message) ?? `local-${turns.length}`, user: message, prose: [], dividers: [] });
+            }
+            else if (isCycleDivider(message)) {
+                turn.dividers.push(message);
+            }
+            else if (message.role === 'assistant' && message.stopReason !== 'aborted' && message.stopReason !== 'error') {
+                const text = assistantVisibleText(message).trim();
+                const key = messageKey(message);
+                if (text !== '' && key !== undefined)
+                    turn.prose.push({ key, text });
+            }
+        }
+        const last = turns.pop();
+        let built = 0;
+        const render = async (turn, withReply) => {
+            if (built > 0 && built % SNAPSHOT_YIELD_EVERY === 0) {
+                await new Promise((resolve) => setImmediate(resolve));
+                if (generation !== this.snapshotGeneration)
+                    return false;
+            }
+            built++;
+            if (turn.user !== undefined) {
+                this.pushTranscriptText(this.userMessageText(turn.user));
+                this.addMessageToChat(turn.user);
+            }
+            const text = withReply ? turnReplyText(turn.prose, this.turnReplies.get(turn.key)) : '';
+            if (text !== '') {
+                const component = new ViewerAssistantMessageComponent(undefined, this.hideThinking, attachMarkdownTheme(), this.hiddenThinkingLabel, this.markdownTransformers);
+                component.updateContent(this.replyMessage(text));
+                this.append(component);
+                this.registerCopyBlock(component, 'assistant', text);
+            }
+            for (const divider of turn.dividers)
+                this.addMessageToChat(divider);
+            return true;
+        };
+        for (const turn of turns)
+            if (!(await render(turn, true)))
+                return false;
+        // The open turn: its person's message (and any dividers so far) stay here,
+        // its reply joins the live region where its working continues.
+        if (!(await render(last, false)))
+            return false;
+        this.carriedTurn = { key: last.key, prose: last.prose };
+        return true;
+    }
+    /** Defer a live broker frame when a snapshot build is in flight. Returns true
+     *  (and enqueues the replay closure) while building so the caller returns
+     *  without mutating the half-rebuilt view; false when the caller may proceed.
+     *  This is the single-writer gate every live-frame entry point passes through. */
+    deferIfBuilding(replay) {
+        if (!this.applyingSnapshot)
+            return false;
+        this.deferredFrames.push(replay);
+        return true;
+    }
+    /** Replay deferred live frames in wire order. The gate is already open, so each
+     *  closure re-enters its entry point and dispatches immediately. */
+    replayDeferredFrames() {
+        const frames = this.deferredFrames.splice(0);
+        for (const replay of frames)
+            replay();
+    }
+    /** Apply the broker's random choice for a newly received user message. */
+    setWorkingActivity(activity) {
+        if (this.deferIfBuilding(() => this.setWorkingActivity(activity)))
+            return;
+        const wasShowingWorkingActivity = this.projection.activity === this.workingActivity;
+        this.projection = projectWorkingActivity(this.projection, activity);
+        this.workingActivity = this.projection.workingActivity;
+        if (this.runActive && wasShowingWorkingActivity)
+            this.setActivity(this.makeLoader(this.workingActivity));
+    }
+    /** Clear live turn state after the broker reports completion or the viewer observes dormancy. */
+    settleRun() {
+        this.runActive = false;
+        for (const component of this.pendingTools.values())
+            this.settleGroupTool(component);
+        if (this.streamingComponent) {
+            this.historyContainer.removeChild(this.streamingComponent);
+            for (const turn of this.turns)
+                turn.members.delete(this.streamingComponent);
+            this.turnHidden.delete(this.streamingComponent);
+            this.unregisterCopyBlock(this.streamingComponent);
+            this.streamingComponent = undefined;
+        }
+        this.streamingToolSeparator = undefined;
+        this.pendingTools.clear();
+        if (this.openReplyTurn)
+            this.refreshWorkingRow(this.openReplyTurn);
+        this.applyToolDisplay();
+        this.setActivity(undefined);
+        this.settleBashComponent();
+    }
+    /** Stop any spinning activity loader. A one-shot `crtr surface attach` process lets its
+     *  timers die with the process, but if T7 reuses a ChatView across reconnects in
+     *  one process it should call this on detach to avoid a leaked interval. */
+    dispose() {
+        this.settleRun();
+    }
+    // Global display toggles (Ctrl+O / Ctrl+T), driven by the input controller.
+    // Pure client-side render state — no broker round-trip — ported from pi's
+    // `setToolsExpanded` / `toggleThinkingBlockVisibility`.
+    /** Ctrl+O prefers summaries when the user enabled both folding and summary
+     * generation. */
+    toggleToolsExpanded() {
+        let result;
+        if (this.summarizeToolCalls && this.foldSettledTools) {
+            this.showGroupSummaries = !this.showGroupSummaries;
+            this.toolOutputExpanded = !this.showGroupSummaries;
+            result = { kind: 'summaries', shown: this.showGroupSummaries };
+        }
+        else {
+            this.toolOutputExpanded = !this.toolOutputExpanded;
+            result = { kind: 'output', expanded: this.toolOutputExpanded };
+        }
+        this.applyToolDisplay();
+        return result;
+    }
+    /** The `fold finished tool calls` view setting (`/fold-tools`, Alt+C → z → f).
+     *  Returns the new state so the caller can surface a notice. */
+    toggleFoldSettledTools() {
+        this.foldSettledTools = !this.foldSettledTools;
+        void persistFoldFinishedTools(this.foldSettledTools);
+        // Turning folding back on restores the configured default (summaries),
+        // rather than preserving a stale Ctrl+O choice from an unfolded view.
+        if (this.summarizeToolCalls && this.foldSettledTools)
+            this.showGroupSummaries = true;
+        this.applyToolDisplay();
+        return this.foldSettledTools;
+    }
+    /** Push both display settings onto every rendered component. A tool call still in
+     *  flight is never hidden or minimized. Only a settled group with a broker-known
+     *  summary collapses; incomplete/failed generation leaves its folded call lines. */
+    applyToolDisplay() {
+        const inFlight = new Set(this.pendingTools.values());
+        for (const group of this.groups)
+            for (const tool of group.inFlight)
+                inFlight.add(tool);
+        for (const child of this.historyContainer.children) {
+            if (child instanceof MinimizableToolComponent)
+                child.setMinimized(this.foldSettledTools && !inFlight.has(child));
+            if (isExpandable(child))
+                child.setExpanded(this.toolOutputExpanded);
+        }
+        // The turn fold composes with group folding: a group sets its members'
+        // combined state itself; every other folded member is set here, and a
+        // member the fold released is shown again.
+        const turnFolded = this.turnFoldedComponents(inFlight);
+        const groupOwned = new Set();
+        for (const group of this.groups) {
+            this.applyGroupDisplay(group, turnFolded);
+            groupOwned.add(group.recap);
+            for (const member of group.members)
+                groupOwned.add(member);
+        }
+        for (const component of this.turnHidden) {
+            if (!turnFolded.has(component) && !groupOwned.has(component))
+                this.historyContainer.setHidden(component, false);
+        }
+        for (const component of turnFolded) {
+            if (!groupOwned.has(component) && !this.historyContainer.hiddenChildren.has(component))
+                this.historyContainer.setHidden(component, true);
+        }
+        this.turnHidden = turnFolded;
+        this.applyInboxExchangeDisplay();
+        this.updateFoldedToolSeparators(inFlight);
+        this.historyContainer.markDirty();
+        this.tui.requestRender();
+    }
+    /** Summary mode hides the back-and-forth with the person: every settled
+     *  inline page and every answer they gave from their inbox. A page still
+     *  awaiting an answer stays on screen. */
+    hidesInboxExchange() {
+        return this.showGroupSummaries && this.foldSettledTools;
+    }
+    applyInboxExchangeDisplay() {
+        const hide = this.hidesInboxExchange();
+        for (const component of this.inboxAnswers)
+            this.historyContainer.setHidden(component, hide);
+        for (const block of this.pageBlocks.values())
+            this.historyContainer.setHidden(block, hide && block.settled);
+    }
+    /** `/show-working` (Alt+C → z → w): expand or fold the working behind every
+     *  consolidated reply. Returns the new state, or null when the
+     *  `consolidate_replies` experiment is off for this attach. */
+    toggleShowWorking() {
+        if (!this.consolidateReplies)
+            return null;
+        this.showWorking = !this.showWorking;
+        for (const turn of this.turns)
+            this.refreshWorkingRow(turn);
+        this.applyToolDisplay();
+        return this.showWorking;
+    }
+    /** A broker rewrite landed for one turn. Stored first: it may precede the
+     *  turn's events, and snapshot rebuilds defer it through the writer gate. */
+    applyTurnReply(key, reply) {
+        if (this.deferIfBuilding(() => this.applyTurnReply(key, reply)))
+            return;
+        if (!this.consolidateReplies)
+            return;
+        this.turnReplies.set(key, reply);
+        for (const turn of this.turns)
+            if (turn.key === key)
+                this.refreshTurn(turn);
+        this.tui.requestRender();
+    }
+    /** Every turn member the fold hides right now. The live turn keeps what is
+     *  still in motion — the streaming message and in-flight tools — visible
+     *  below its working row. */
+    turnFoldedComponents(inFlight) {
+        const folded = new Set();
+        if (!this.consolidateReplies || this.showWorking)
+            return folded;
+        for (const turn of this.turns) {
+            const live = turn === this.openReplyTurn;
+            for (const member of turn.members) {
+                if (live && (member === this.streamingComponent
+                    || member === this.streamingToolSeparator
+                    || member === this.bashComponent
+                    || inFlight.has(member)))
+                    continue;
+                folded.add(member);
+            }
+        }
+        return folded;
+    }
+    beginTurn(key, prose = []) {
+        const reply = new ViewerAssistantMessageComponent(undefined, this.hideThinking, attachMarkdownTheme(), this.hiddenThinkingLabel, this.markdownTransformers);
+        const working = new WorkingRow();
+        this.outsideTurns++;
+        try {
+            // The fold row sits between the person's message and the reply: what
+            // was asked, what was done, then the answer.
+            this.append(working);
+            this.append(reply);
+        }
+        finally {
+            this.outsideTurns--;
+        }
+        this.registerCopyBlock(reply, 'assistant', '');
+        const turn = { key, reply, working, members: new Set(), prose };
+        this.turns.push(turn);
+        this.openReplyTurn = turn;
+        this.refreshTurn(turn);
+        return turn;
+    }
+    /** Whether an append in progress lands in the live region of a consolidating view. */
+    consolidatingHere() {
+        return this.consolidateReplies && this.appendTarget === this.historyContainer;
+    }
+    currentTurn() {
+        return this.openReplyTurn ?? this.beginTurn(this.carriedTurn.key, [...this.carriedTurn.prose]);
+    }
+    /** A settled assistant message with prose becomes part of its turn's reply. */
+    recordTurnProse(message, refresh) {
+        if (!this.consolidatingHere() || message.role !== 'assistant')
+            return;
+        if (message.stopReason === 'aborted' || message.stopReason === 'error')
+            return;
+        const text = assistantVisibleText(message).trim();
+        const key = messageKey(message);
+        if (text === '' || key === undefined)
+            return;
+        const turn = this.currentTurn();
+        if (turn.prose.some((item) => item.key === key))
+            return;
+        turn.prose.push({ key, text });
+        if (refresh)
+            this.refreshTurn(turn);
+    }
+    /** Re-render one turn's reply from its prose and the broker's latest rewrite. */
+    refreshTurn(turn) {
+        const text = turnReplyText(turn.prose, this.turnReplies.get(turn.key));
+        turn.reply.updateContent(this.replyMessage(text));
+        this.historyContainer.setHidden(turn.reply, text === '');
+        this.historyContainer.markDirty(turn.reply);
+        this.registerCopyBlock(turn.reply, 'assistant', text);
+        if (text !== '' && turn === this.turns.at(-1))
+            this.lastAssistantText = text;
+        this.refreshWorkingRow(turn);
+    }
+    refreshWorkingRow(turn) {
+        let tools = 0;
+        let cards = 0;
+        for (const member of turn.members) {
+            if (member instanceof MinimizableToolComponent)
+                tools++;
+            else if (member instanceof ContextMessageComponent || member instanceof CustomMessageComponent || member instanceof CrtrOutputMessageComponent)
+                cards++;
+        }
+        const messages = turn.prose.length;
+        // A lone prose message with nothing else IS the reply; there is no working.
+        const hasWorking = tools > 0 || cards > 0 || messages > 1;
+        const parts = [
+            messages > 0 ? plural(messages, 'message', 'messages') : undefined,
+            tools > 0 ? plural(tools, 'tool call', 'tool calls') : undefined,
+            cards > 0 ? plural(cards, 'card', 'cards') : undefined,
+        ].filter((part) => part !== undefined);
+        // "working" only while the agent is running in this turn; a settled turn
+        // just names what the fold holds.
+        const live = this.runActive && turn === this.openReplyTurn;
+        turn.working.setLabel(this.dimStyle(`${this.showWorking ? '▾' : '▸'} ${live ? 'working — ' : ''}${parts.join(' · ')}`));
+        this.historyContainer.setHidden(turn.working, !hasWorking);
+        this.historyContainer.markDirty(turn.working);
+    }
+    replyMessage(text) {
+        return { role: 'assistant', content: text === '' ? [] : [{ type: 'text', text }], stopReason: 'stop' };
+    }
+    /** Ctrl+T / app.thinking.toggle — flip thinking-block visibility and apply it to
+     *  every assistant message (the in-flight streaming bubble is itself a child of
+     *  the container, so the loop covers it too). Returns the new HIDDEN state. */
+    toggleThinking() {
+        this.hideThinking = !this.hideThinking;
+        for (const child of this.historyContainer.children) {
+            if (child instanceof AssistantMessageComponent)
+                child.setHideThinkingBlock(this.hideThinking);
+        }
+        for (const [separator, content] of this.foldedToolSeparatorContents) {
+            separator.setSeparatesToolGroup(content.hasText || (!this.hideThinking && content.hasThinking));
+        }
+        this.historyContainer.markDirty();
+        this.tui.requestRender();
+        return this.hideThinking;
+    }
+    // Live stream: the 15-of-17-case handleEvent port (turn_start/turn_end no-op,
+    // exactly as interactive pi falls through default for those two).
+    handleEvent(event) {
+        // Order behind an in-flight catch-up: a live turn that starts while a large
+        // welcome is still building is replayed after it, never interleaved into it.
+        if (this.deferIfBuilding(() => this.handleEvent(event)))
+            return;
+        this.projection = projectEvent(this.projection, event);
+        switch (event.type) {
+            case 'agent_start': {
+                this.runActive = this.projection.isStreaming;
+                for (const component of this.pendingTools.values())
+                    this.settleGroupTool(component);
+                this.pendingTools.clear();
+                if (this.openReplyTurn)
+                    this.refreshWorkingRow(this.openReplyTurn);
+                this.setActivity(this.makeLoader(this.workingActivity));
+                break;
+            }
+            case 'agent_end': {
+                this.settleRun();
+                // The node you're watching just finished its turn and handed control
+                // back — ring the completion bell (the Claude-Code Stop-hook ding).
+                // Best-effort/detached; gated on the `completion_bell` config setting.
+                // Only ever reached inside a live viewer pane, so a headless/background
+                // node (no ChatView) is always silent.
+                ringCompletionBell();
+                break;
+            }
+            // The whole run has truly settled (after any recovery/continuations). This
+            // is the broker's canonical turn-over signal and is always relayed, so use
+            // it as a safety net to clear a lingering activity loader: a missed or
+            // abnormal `agent_end` would otherwise leave a dormant, between-wakes node
+            // showing a frozen `Working…` spinner. No bell here — `agent_end` already
+            // rang it on the normal path; this only cleans up display state.
+            case 'agent_settled': {
+                this.settleRun();
+                break;
+            }
+            case 'message_start': {
+                if (event.message.role === 'custom' || event.message.role === 'user') {
+                    this.addMessageToChat(event.message);
+                    // A card that joined a folded turn hides at once.
+                    if (this.consolidateReplies) {
+                        if (this.openReplyTurn)
+                            this.refreshWorkingRow(this.openReplyTurn);
+                        this.applyToolDisplay();
+                    }
+                }
+                else if (event.message.role === 'assistant') {
+                    const hasProse = assistantVisibleText(event.message).trim() !== '';
+                    if (hasProse)
+                        this.closeOpenGroup();
+                    this.streamingComponent = new ViewerAssistantMessageComponent(undefined, this.hideThinking, attachMarkdownTheme(), this.hiddenThinkingLabel, this.markdownTransformers);
+                    this.streamingWasGroupMember = !hasProse;
+                    this.appendAssistantPart(this.streamingComponent, !hasProse);
+                    this.registerCopyBlock(this.streamingComponent, 'assistant', '');
+                    this.streamingComponent.updateContent(event.message);
+                    this.registerCopyBlock(this.streamingComponent, 'assistant', assistantVisibleText(event.message));
+                    this.streamingToolSeparator = this.appendAssistantSeparator(!hasProse);
+                    this.setAssistantSeparatorContent(this.streamingToolSeparator, event.message);
+                }
+                break;
+            }
+            case 'message_update': {
+                if (this.streamingComponent && event.message.role === 'assistant') {
+                    this.promoteStreamingAssistantToBoundary(event.message);
+                    // Incomplete Mermaid fences and HTML pairs stay literal until their
+                    // closing marker arrives; the transformers upgrade them on the render
+                    // that follows, with no separate mid-stream path.
+                    this.streamingComponent.updateContent(event.message);
+                    this.registerCopyBlock(this.streamingComponent, 'assistant', assistantVisibleText(event.message));
+                    this.historyContainer.markDirty(this.streamingComponent);
+                    const toolCalls = this.assistantToolCalls(event.message);
+                    if (this.streamingToolSeparator)
+                        this.setAssistantSeparatorContent(this.streamingToolSeparator, event.message);
+                    for (const content of toolCalls) {
+                        this.pushTranscriptValue(content.arguments);
+                        const existing = this.pendingTools.get(content.id);
+                        if (existing) {
+                            existing.updateArgs(content.arguments);
+                            this.noteGroupTool(existing, content.name, content.arguments);
+                            this.historyContainer.markDirty(existing);
+                        }
+                        else {
+                            const component = this.appendToolComponent(content.name, content.id, content.arguments);
+                            this.pendingTools.set(content.id, component);
+                        }
+                    }
+                }
+                break;
+            }
+            case 'message_end': {
+                if (event.message.role !== 'assistant')
+                    break;
+                const endedWithFailure = event.message.stopReason === 'aborted' || event.message.stopReason === 'error';
+                // A terminal failure is always its own visible boundary, including an
+                // empty abort created by yield or a daemon restart.
+                this.promoteStreamingAssistantToBoundary(event.message, endedWithFailure);
+                // Stash the completed reply's text for `/copy` (skip aborted/error turns,
+                // whose text is partial or absent).
+                if (this.streamingComponent)
+                    this.registerCopyBlock(this.streamingComponent, 'assistant', assistantVisibleText(event.message));
+                if (event.message.stopReason !== 'aborted' && event.message.stopReason !== 'error') {
+                    const text = assistantVisibleText(event.message);
+                    if (text.trim()) {
+                        this.lastAssistantText = text;
+                        this.pushTranscriptText(text);
+                    }
+                }
+                if (this.streamingComponent) {
+                    const stopReason = event.message.stopReason;
+                    let errorMessage = event.message.errorMessage;
+                    // An aborted turn may be a user interrupt or a lifecycle interruption
+                    // (a refresh-yield aborts its own turn). Providers spell it several
+                    // ways — including `stopReason: 'error'` carrying a bare AbortError,
+                    // which would otherwise render as a red `Error: This operation was
+                    // aborted` for a perfectly healthy yield — so override it outright
+                    // with one plain, human label.
+                    if (endedByAbort(event.message)) {
+                        errorMessage = 'Interrupted';
+                        // Surface the abort on the assistant bubble itself, mirroring pi
+                        // (interactive-mode.js:2280 sets streamingMessage.errorMessage before
+                        // updateContent) so the rendered message shows the annotation. The
+                        // stopReason moves with it: pi's component reserves its red
+                        // `Error: …` line for stopReason 'error', and an abort is not one.
+                        event.message.errorMessage = errorMessage;
+                        event.message.stopReason = 'aborted';
+                    }
+                    this.streamingComponent.updateContent(event.message);
+                    if (stopReason === 'aborted' || stopReason === 'error') {
+                        const text = errorMessage ?? 'Error';
+                        for (const component of this.pendingTools.values()) {
+                            component.updateResult({ content: [{ type: 'text', text }], isError: true });
+                            this.registerCopyBlock(component, 'tool', text);
+                            this.settleGroupTool(component, { content: [{ type: 'text', text }], isError: true }, true);
+                            this.historyContainer.markDirty(component);
+                        }
+                        this.pendingTools.clear();
+                    }
+                    else {
+                        // Finalize renderer caches now that every tool argument is complete.
+                        for (const component of this.pendingTools.values()) {
+                            component.setArgsComplete();
+                            this.historyContainer.markDirty(component);
+                        }
+                    }
+                    this.historyContainer.markDirty(this.streamingComponent);
+                    this.streamingComponent = undefined;
+                    this.streamingToolSeparator = undefined;
+                }
+                if (endedWithFailure) {
+                    this.closeOpenGroup();
+                    // A summary normally follows this terminal frame, but re-evaluate now
+                    // too so an early recap immediately folds the tools before this seam.
+                    this.applyToolDisplay();
+                }
+                if (this.consolidateReplies) {
+                    // The finished message's prose moves into the reply; its live copy folds.
+                    this.recordTurnProse(event.message, true);
+                    if (this.openReplyTurn)
+                        this.refreshWorkingRow(this.openReplyTurn);
+                    this.applyToolDisplay();
+                }
+                break;
+            }
+            case 'tool_execution_start': {
+                this.pushTranscriptValue(event.args);
+                let component = this.pendingTools.get(event.toolCallId);
+                if (!component) {
+                    component = this.appendToolComponent(event.toolName, event.toolCallId, event.args);
+                    this.pendingTools.set(event.toolCallId, component);
+                }
+                else {
+                    this.noteGroupTool(component, event.toolName, event.args);
+                }
+                component.markExecutionStarted();
+                this.historyContainer.markDirty(component);
+                break;
+            }
+            case 'tool_execution_update': {
+                const result = this.projection.partialToolResults.get(event.toolCallId) ?? event.partialResult;
+                this.pushTranscriptValue(result);
+                const component = this.pendingTools.get(event.toolCallId);
+                if (component) {
+                    component.updateResult(result, true);
+                    this.registerCopyBlock(component, 'tool', this.toolResultText(result));
+                    this.historyContainer.markDirty(component);
+                }
+                break;
+            }
+            case 'tool_execution_end': {
+                const result = this.projection.partialToolResults.get(event.toolCallId) ?? event.result;
+                this.pushTranscriptValue(result);
+                const component = this.pendingTools.get(event.toolCallId);
+                if (component) {
+                    component.updateResult(result);
+                    this.registerCopyBlock(component, 'tool', this.toolResultText(result));
+                    this.pendingTools.delete(event.toolCallId);
+                    this.settleGroupTool(component, result, event.isError);
+                    this.applyToolDisplay();
+                    this.historyContainer.markDirty(component);
+                    this.maybeAppendPageBlock(result);
+                }
+                break;
+            }
+            case 'compaction_start': {
+                const label = event.reason === 'manual' ? 'Compacting context...' : 'Auto-compacting...';
+                this.setActivity(this.makeLoader(label));
+                break;
+            }
+            case 'compaction_end': {
+                this.setActivity(this.runActive ? this.makeLoader(this.workingActivity) : undefined);
+                if (event.aborted) {
+                    this.showStatus(event.reason === 'manual' ? 'Compaction cancelled' : 'Auto-compaction cancelled');
+                }
+                else if (event.result) {
+                    // 0.78.1 divergence from the §3.2 sketch: `compaction_end` carries only
+                    // the CompactionResult (summary + tokensBefore), NOT the post-compaction
+                    // message list — so the viewer cannot clear+rebuild the transcript the
+                    // way in-process pi does (it rebuilds from its own SessionManager). We
+                    // append the compaction summary marker instead and KEEP the
+                    // pre-compaction scrollback for the rest of this attach session; a fresh
+                    // re-attach gets the already-compacted history via `welcome`. (Reported
+                    // in T5's final.)
+                    this.addMessageToChat({
+                        role: 'compactionSummary',
+                        summary: event.result.summary,
+                        tokensBefore: event.result.tokensBefore,
+                        timestamp: Date.now(),
+                    });
+                }
+                else if (event.errorMessage) {
+                    this.showError(event.errorMessage);
+                }
+                break;
+            }
+            case 'auto_retry_start': {
+                const seconds = Math.ceil(event.delayMs / 1000);
+                this.setActivity(this.makeLoader(`Retrying (${event.attempt}/${event.maxAttempts}) in ${seconds}s...`));
+                break;
+            }
+            case 'auto_retry_end': {
+                this.setActivity(this.runActive ? this.makeLoader(this.workingActivity) : undefined);
+                if (!event.success) {
+                    this.showError(`Retry failed after ${event.attempt} attempts: ${event.finalError ?? 'Unknown error'}`);
+                }
+                break;
+            }
+            // Footer/header-only — ChatView owns no footer; forward to the sink.
+            case 'queue_update':
+            case 'session_info_changed':
+            case 'thinking_level_changed':
+                this.onFooterEvent?.(event);
+                break;
+            // turn_start / turn_end — interactive pi ignores these (falls through
+            // default); the viewer does too.
+            default:
+                break;
+        }
+        // No unconditional markDirty here: appends/removes invalidate through
+        // MeasuredContainer, and branches that mutate a child in place explicitly
+        // mark it dirty. Activity-only events leave settled history cached while the
+        // independent status loader animates.
+        this.tui.requestRender();
+    }
+    // `!` bash live stream (broker bash_start/bash_output/bash_end frames). Mirrors
+    // pi interactive mode's `!` handling: create the component on start, stream
+    // chunks into it, mark complete on end. The persisted `bashExecution` message
+    // also rides the next snapshot, so this only drives the LIVE view.
+    bashStart(command, excludeFromContext) {
+        if (this.deferIfBuilding(() => this.bashStart(command, excludeFromContext)))
+            return;
+        this.projection = projectBashStart(this.projection, command, excludeFromContext);
+        this.closeOpenGroup();
+        this.settleBashComponent();
+        let component;
+        component = new BashExecutionComponent(command, this.componentTui(() => component), excludeFromContext);
+        this.bashComponent = component;
+        this.append(component);
+        this.tui.requestRender();
+    }
+    bashOutput(chunk) {
+        if (this.deferIfBuilding(() => this.bashOutput(chunk)))
+            return;
+        this.projection = projectBashOutput(this.projection, chunk);
+        this.pushTranscriptText(chunk);
+        if (this.bashComponent) {
+            this.bashComponent.appendOutput(chunk);
+            this.historyContainer.markDirty(this.bashComponent);
+        }
+        this.tui.requestRender();
+    }
+    bashEnd(result) {
+        if (this.deferIfBuilding(() => this.bashEnd(result)))
+            return;
+        this.projection = projectBashEnd(this.projection, result);
+        this.settleBashComponent(result);
+        this.tui.requestRender();
+    }
+    // Rebuild path (ports addMessageToChat, interactive-mode.js:2483).
+    addMessageToChat(message) {
+        // Crouter-generated context retains its runtime role (user vs custom) so
+        // delivery to the model is unchanged, but every attached view presents it
+        // through one compact disclosure contract. The producer's envelope is what
+        // classifies, so an ordinary user prompt cannot acquire this treatment and
+        // saved transcripts gain it too.
+        const card = parseCard(message);
+        if (card !== null &&
+            (message.role !== 'custom' || message.display === true)) {
+            this.pushTranscriptText(card.body);
+            // A person's inbox answer is the person speaking: their words leave the
+            // card and render as their own message. A digest carrying nothing else
+            // gets no card at all — but a passive backlog folded into the same body
+            // is content, so the residue check keeps it from vanishing with the card.
+            const answers = card.senders
+                .flatMap((sender) => sender.entries)
+                .filter(isHumanWordsEntry)
+                .map((entry) => entry.body.trim())
+                .filter((text) => text !== '');
+            const onlyHumanWords = answers.length > 0
+                && card.body.replace(INBOX_SENDER_SECTIONS, '').trim() === ''
+                && card.senders.every((sender) => sender.entries.every(isHumanWordsEntry));
+            if (!onlyHumanWords) {
+                const presentation = presentationFor(card.kind);
+                const component = new ContextMessageComponent(card, presentation, this.toolOutputExpanded, this.dimStyle, (s) => this.spinnerStyle(this.labelStyle(s)));
+                // A boundary card is a visible seam, not a group member: the preceding
+                // span keeps its own recap and the next tool call begins a
+                // broker-aligned fresh group.
+                if (isGroupBoundaryKind(card.kind)) {
+                    this.closeOpenGroup();
+                    this.append(component);
+                }
+                else {
+                    // A folded group hides its members, so whatever the card should leave
+                    // behind — a child's final, a recovery — reaches the recap here.
+                    this.appendGroupMember(component)?.activity.noteCard(card, presentation);
+                }
+            }
+            for (const answer of answers)
+                this.appendHumanAnswer(answer);
+            return;
+        }
+        switch (message.role) {
+            case 'bashExecution': {
+                this.closeOpenGroup();
+                this.pushTranscriptText(message.output ?? '');
+                const component = new BashExecutionComponent(message.command, this.tui, message.excludeFromContext);
+                if (message.output)
+                    component.appendOutput(message.output);
+                component.setComplete(message.exitCode, message.cancelled, 
+                // pi's interactive mode passes a minimal `{truncated:true}` marker here
+                // (interactive-mode.js:2489) where the typed param is the full
+                // TruncationResult; the snapshot message only carries the boolean, so we
+                // mirror pi and cast.
+                message.truncated ? { truncated: true } : undefined, message.fullOutputPath);
+                this.append(component);
+                break;
+            }
+            case 'custom': {
+                if (message.display) {
+                    this.pushTranscriptText(this.userMessageText(message));
+                    if (message.customType === CRTR_OUTPUT_CUSTOM_TYPE) {
+                        this.appendGroupMember(new CrtrOutputMessageComponent(this.userMessageText(message), this.toolOutputExpanded, this.crtrOutputTheme()));
+                        break;
+                    }
+                    // A refresh-yield cycle boundary (session-cycles.ts, synthetic — never
+                    // persisted): render as a dim rule rather than the generic custom-
+                    // message card, so scrolling through a multi-cycle node's full history
+                    // reads as one conversation with clear seams between cycles.
+                    if (message.customType === CRTR_CYCLE_DIVIDER_CUSTOM_TYPE) {
+                        this.closeOpenGroup();
+                        this.append(new Spacer(1));
+                        this.append(new Text(this.dimStyle(`── ${this.userMessageText(message)} ──`), 1, 0));
+                        this.append(new Spacer(1));
+                        break;
+                    }
+                    const component = new CustomMessageComponent(styleAttachMessageMarkdown(message), undefined, attachMarkdownTheme());
+                    component.setExpanded(this.toolOutputExpanded);
+                    this.appendGroupMember(component);
+                }
+                break;
+            }
+            case 'compactionSummary': {
+                this.closeOpenGroup();
+                this.append(new Spacer(1));
+                const component = new CompactionSummaryMessageComponent(styleAttachSummaryMarkdown(message), attachMarkdownTheme());
+                component.setExpanded(this.toolOutputExpanded);
+                this.append(component);
+                break;
+            }
+            case 'branchSummary': {
+                this.closeOpenGroup();
+                this.append(new Spacer(1));
+                const component = new BranchSummaryMessageComponent(styleAttachSummaryMarkdown(message), attachMarkdownTheme());
+                component.setExpanded(this.toolOutputExpanded);
+                this.append(component);
+                this.registerCopyBlock(component, 'assistant', message.summary);
+                break;
+            }
+            case 'user': {
+                if (isTrueUserMessage(message))
+                    this.closeOpenGroup();
+                // Consolidated replies: the person's message stands outside every turn
+                // and opens the next one, whose reply sits directly beneath it.
+                if (isTrueUserMessage(message) && this.consolidatingHere()) {
+                    // A turn carried over from condensed history ends here; give it its reply.
+                    if (!this.openReplyTurn && this.carriedTurn.prose.length > 0)
+                        this.currentTurn();
+                    this.outsideTurns++;
+                    try {
+                        this.appendUserMessage(message);
+                    }
+                    finally {
+                        this.outsideTurns--;
+                    }
+                    this.beginTurn(messageKey(message) ?? `local-${this.turns.length}`);
+                    break;
+                }
+                this.appendUserMessage(message);
+                break;
+            }
+            case 'assistant': {
+                const hasProse = assistantVisibleText(message).trim() !== '';
+                if (hasProse)
+                    this.closeOpenGroup();
+                this.appendAssistantMessage(message, !hasProse);
+                break;
+            }
+            // toolResult is rendered inline with its tool call (handled in applySnapshot).
+            default:
+                break;
+        }
+    }
+    appendUserMessage(message) {
+        const textContent = this.userMessageText(message);
+        if (!textContent)
+            return;
+        this.pushTranscriptText(textContent);
+        if (this.chatChildCount() > 0)
+            this.appendUserPart(new Spacer(1), !isTrueUserMessage(message));
+        const skillBlock = parseSkillBlock(textContent);
+        if (skillBlock) {
+            // SkillInvocationMessageComponent has no transformer seam, so its body
+            // is still styled before construction.
+            const component = new SkillInvocationMessageComponent({ ...skillBlock, content: styleAttachMarkdownSource(skillBlock.content) }, attachMarkdownTheme());
+            component.setExpanded(this.toolOutputExpanded);
+            this.appendUserPart(component, !isTrueUserMessage(message));
+            this.registerCopyBlock(component, 'user', textContent);
+            if (skillBlock.userMessage) {
+                const userMessage = new UserMessageComponent(skillBlock.userMessage, attachMarkdownTheme(), undefined, this.markdownTransformers);
+                this.appendUserPart(userMessage, !isTrueUserMessage(message));
+                this.registerCopyBlock(userMessage, 'user', skillBlock.userMessage);
+            }
+        }
+        else {
+            const component = new UserMessageComponent(textContent, attachMarkdownTheme(), undefined, this.markdownTransformers);
+            this.appendUserPart(component, !isTrueUserMessage(message));
+            this.registerCopyBlock(component, 'user', textContent);
+        }
+    }
+    // Helpers
+    /** Render an assistant reply plus its initially-hidden boundary separator.
+     *  A turn that ended on its own abort is rendered as the interrupt it is,
+     *  matching the live seam above, so re-reading the transcript later never
+     *  turns a healthy interrupt into a red `Error:` line. */
+    appendAssistantMessage(message, groupMember = false) {
+        const component = new ViewerAssistantMessageComponent(undefined, this.hideThinking, attachMarkdownTheme(), this.hiddenThinkingLabel, this.markdownTransformers);
+        const rendered = endedByAbort(message)
+            ? { ...message, stopReason: 'aborted', errorMessage: 'Interrupted' }
+            : message;
+        component.updateContent(rendered);
+        this.appendAssistantPart(component, groupMember);
+        this.registerCopyBlock(component, 'assistant', assistantVisibleText(message));
+        const separator = this.appendAssistantSeparator(groupMember);
+        this.setAssistantSeparatorContent(separator, message);
+        return separator;
+    }
+    /** Add a separator in transcript order now; it renders only after a following
+     * tool settles in the folded view. */
+    appendAssistantSeparator(groupMember = false) {
+        const separator = new FoldedToolSeparator();
+        if (groupMember)
+            this.appendGroupMember(separator);
+        else
+            this.append(separator);
+        return separator;
+    }
+    appendAssistantPart(component, groupMember) {
+        if (groupMember)
+            this.appendGroupMember(component);
+        else
+            this.append(component);
+    }
+    appendUserPart(component, groupMember) {
+        if (groupMember)
+            this.appendGroupMember(component);
+        else
+            this.append(component);
+    }
+    /** An answer the person typed in their inbox renders exactly like a message
+     * they typed here, and closes the run around it the same way. */
+    appendHumanAnswer(text) {
+        this.outsideTurns++;
+        try {
+            this.appendHumanAnswerParts(text);
+        }
+        finally {
+            this.outsideTurns--;
+        }
+    }
+    appendHumanAnswerParts(text) {
+        this.closeOpenGroup();
+        const live = this.appendTarget === this.historyContainer;
+        if (this.chatChildCount() > 0) {
+            const spacer = new Spacer(1);
+            this.append(spacer);
+            if (live)
+                this.trackInboxAnswer(spacer);
+        }
+        const component = new UserMessageComponent(text, attachMarkdownTheme(), undefined, this.markdownTransformers);
+        this.append(component);
+        if (live)
+            this.trackInboxAnswer(component);
+        this.registerCopyBlock(component, 'user', text);
+    }
+    trackInboxAnswer(component) {
+        this.inboxAnswers.add(component);
+        if (this.hidesInboxExchange())
+            this.historyContainer.setHidden(component, true);
+    }
+    /** Only the full-fidelity trailing region gets summary groups. Condensed
+     * history intentionally drops tool traffic, so grouping there would create
+     * phantom summary rows and cross the live/condensed boundary. */
+    isLiveGroupRegion() {
+        return this.appendTarget === this.historyContainer;
+    }
+    ensureGroup() {
+        if (!this.isLiveGroupRegion())
+            return undefined;
+        if (this.openGroup)
+            return this.openGroup;
+        const recap = new GroupRecapComponent();
+        const group = {
+            members: [],
+            recap,
+            activity: new GroupActivityRecorder(this.cwd, this.nodeRoster),
+            toolCount: 0,
+            inFlight: new Set(),
+        };
+        this.append(recap);
+        // The recap is a direct history child for cache identity, but zero-row and
+        // hidden until a settled broker summary makes this group collapsible.
+        this.historyContainer.setHidden(recap, true);
+        this.groups.push(group);
+        this.openGroup = group;
+        return group;
+    }
+    closeOpenGroup() {
+        this.openGroup = undefined;
+    }
+    appendGroupMember(component) {
+        const group = this.ensureGroup();
+        this.append(component);
+        if (group)
+            group.members.push(component);
+        return group;
+    }
+    removeGroupMember(component) {
+        for (const group of this.groups) {
+            const index = group.members.indexOf(component);
+            if (index !== -1)
+                group.members.splice(index, 1);
+        }
+        this.historyContainer.setHidden(component, false);
+    }
+    /** Add one tool as a group member, moving the assistant's boundary separator
+     * behind the new summary row without changing the separator's identity. */
+    appendToolComponent(name, id, args) {
+        const trailingSeparator = this.isLiveGroupRegion() &&
+            !this.openGroup &&
+            this.historyContainer.children.at(-1) instanceof FoldedToolSeparator
+            ? this.historyContainer.children.at(-1)
+            : undefined;
+        if (trailingSeparator)
+            this.historyContainer.removeChild(trailingSeparator);
+        const group = this.ensureGroup();
+        if (trailingSeparator) {
+            this.append(trailingSeparator);
+            group?.members.push(trailingSeparator);
+        }
+        const component = this.makeToolComponent(name, id, args);
+        component.activityCallId = id;
+        this.appendGroupMember(component);
+        this.registerCopyBlock(component, 'tool', '');
+        if (group) {
+            group.key ??= id;
+            group.toolCount++;
+            group.inFlight.add(component);
+            group.activity.noteCall(id, name, args);
+        }
+        return component;
+    }
+    noteGroupTool(component, name, args) {
+        if (!component.activityCallId)
+            return;
+        for (const group of this.groups) {
+            if (group.members.includes(component))
+                group.activity.noteCall(component.activityCallId, name, args);
+        }
+    }
+    settleGroupTool(component, result, isError = false) {
+        for (const group of this.groups) {
+            group.inFlight.delete(component);
+            if (!component.activityCallId || !group.members.includes(component))
+                continue;
+            if (result === undefined)
+                group.activity.resolveWithoutResult(component.activityCallId);
+            else
+                group.activity.settle(component.activityCallId, result, isError);
+        }
+    }
+    /** An assistant starts as a non-boundary while its text is empty. Visible prose
+     * or a terminal failure turns it into a boundary without recreating either
+     * pi-owned component (their direct-child cache identities remain intact). */
+    promoteStreamingAssistantToBoundary(message, force = false) {
+        if (!this.streamingWasGroupMember || (!force && assistantVisibleText(message).trim() === ''))
+            return;
+        if (this.streamingComponent)
+            this.removeGroupMember(this.streamingComponent);
+        if (this.streamingToolSeparator)
+            this.removeGroupMember(this.streamingToolSeparator);
+        this.streamingWasGroupMember = false;
+        this.closeOpenGroup();
+    }
+    seedToolGroupSummaries(summaries) {
+        this.groupSummaries.clear();
+        for (const [key, summary] of Object.entries(summaries))
+            this.groupSummaries.set(key, summary);
+    }
+    /** Broker frames can arrive before or after their group's events, and snapshot
+     * rebuilding defers them through the single-writer gate, so this stores first
+     * and applies to every currently-rendered matching group. */
+    applyToolGroupSummary(key, summary) {
+        if (this.deferIfBuilding(() => this.applyToolGroupSummary(key, summary)))
+            return;
+        this.projection = projectToolGroupSummary(this.projection, key, summary);
+        const projected = this.projection.toolGroupSummaryDetails[key];
+        if (projected === undefined)
+            return;
+        this.groupSummaries.set(key, projected);
+        this.applyToolDisplay();
+    }
+    applyGroupDisplay(group, turnFolded) {
+        const summary = group.key === undefined ? undefined : this.groupSummaries.get(group.key);
+        const collapsed = this.foldSettledTools &&
+            this.showGroupSummaries &&
+            group.toolCount > 0 &&
+            group.inFlight.size === 0 &&
+            summary !== undefined;
+        group.recap.setRecap(collapsed ? summary : undefined, group.toolCount, group.activity.activity(), this.detailedToolRecaps, this.recapPalette);
+        this.historyContainer.setHidden(group.recap, !collapsed || turnFolded.has(group.recap));
+        for (const member of group.members)
+            this.historyContainer.setHidden(member, collapsed || turnFolded.has(member));
+    }
+    /** Make each separator visible only if its immediately-following tool call is
+     * actually folded; in-flight calls remain flush with their live output. */
+    updateFoldedToolSeparators(inFlight = new Set(this.pendingTools.values())) {
+        const children = this.historyContainer.children;
+        for (let i = 0; i < children.length; i++) {
+            const separator = children[i];
+            if (!(separator instanceof FoldedToolSeparator))
+                continue;
+            const followingTool = children[i + 1];
+            separator.setFolded(this.foldSettledTools &&
+                !this.historyContainer.hiddenChildren.has(separator) &&
+                followingTool instanceof MinimizableToolComponent &&
+                !this.historyContainer.hiddenChildren.has(followingTool) &&
+                !inFlight.has(followingTool));
+            this.historyContainer.markDirty(separator);
+        }
+    }
+    /** Track whether an assistant response contains prose or thinking, then make
+     * its separator eligible only for content the current Ctrl+T setting shows. */
+    setAssistantSeparatorContent(separator, message) {
+        const content = message.content;
+        const parts = Array.isArray(content) ? content : [];
+        const hasText = parts.some((part) => typeof part === 'object' &&
+            part !== null &&
+            part.type === 'text' &&
+            typeof part.text === 'string' &&
+            part.text.trim() !== '');
+        const hasThinking = parts.some((part) => typeof part === 'object' &&
+            part !== null &&
+            part.type === 'thinking' &&
+            typeof part.thinking === 'string' &&
+            part.thinking.trim() !== '');
+        this.foldedToolSeparatorContents.set(separator, { hasText, hasThinking });
+        separator.setSeparatesToolGroup(hasText || (!this.hideThinking && hasThinking));
+    }
+    /** Tool component with native viewer renderers for crouter-owned tool output. */
+    makeToolComponent(name, id, args) {
+        const fold = new FoldedToolCallController();
+        let resultObserver;
+        let toolDefinition;
+        if (name === 'bash') {
+            const crtr = createCrtrBashToolDefinition(args, fold);
+            if (crtr === undefined) {
+                toolDefinition = createCrtrPlainBashToolDefinition(this.cwd, fold, this.backgroundBashHint);
+            }
+            else {
+                toolDefinition = crtr.definition;
+            }
+        }
+        else if (name === 'edit') {
+            const edit = createCrtrEditToolDefinition(this.cwd, fold);
+            toolDefinition = edit.definition;
+            resultObserver = edit.observeResult;
+        }
+        else if (name === 'read') {
+            toolDefinition = createCrtrReadToolDefinition(this.cwd, fold);
+        }
+        else if (name === 'write') {
+            toolDefinition = createCrtrWriteToolDefinition(this.cwd, fold);
+        }
+        let component;
+        component = new MinimizableToolComponent(name, id, args, { showImages: this.showImages, imageWidthCells: this.imageWidthCells }, toolDefinition, this.componentTui(() => component), this.cwd);
+        component.setToolView(toolDefinition === undefined ? undefined : fold, resultObserver);
+        component.setExpanded(this.toolOutputExpanded);
+        return component;
+    }
+    /** Append conversation content above the independent live status area — or into
+     *  the nested container while condensed history is under construction. */
+    append(child) {
+        if (this.outsideTurns === 0 && this.consolidatingHere()) {
+            const turn = this.currentTurn();
+            this.appendTarget.addChild(child);
+            turn.members.add(child);
+            return;
+        }
+        this.appendTarget.addChild(child);
+    }
+    /** Number of rendered conversation components in the container currently being
+     *  appended to (live history or the nested condensed region). */
+    chatChildCount() {
+        return this.appendTarget.children.length;
+    }
+    /** Clear all chat content. */
+    resetChat() {
+        this.setActivity(undefined);
+        this.settleBashComponent();
+        this.streamingComponent = undefined;
+        this.streamingToolSeparator = undefined;
+        this.streamingWasGroupMember = false;
+        this.foldedToolSeparatorContents.clear();
+        this.groups.length = 0;
+        this.openGroup = undefined;
+        this.turns.length = 0;
+        this.openReplyTurn = undefined;
+        this.carriedTurn = { key: START_TURN_KEY, prose: [] };
+        this.turnHidden = new Set();
+        this.groupSummaries.clear();
+        this.nodeRoster.clear();
+        this.pendingTools.clear();
+        this.lastAssistantText = undefined;
+        this.copyBlockRecords.length = 0;
+        this.copyIndex.clear();
+        this.transcriptFilePaths.length = 0;
+        this.transcriptDocRefs.length = 0;
+        this.pageBlocks.clear();
+        this.inboxAnswers.clear();
+        this.historyContainer.clear();
+    }
+    /** Place the transcript block for an inline page a `human send` just raised.
+     *  The block is a plain history child, NOT a tool-group member: collapsing the
+     *  tool group folds the command away and leaves the page itself on screen, the
+     *  way assistant prose stays. Condensed history is skipped deliberately — old
+     *  cycles keep only prose and cycle seams. */
+    maybeAppendPageBlock(result) {
+        if (!this.inlinePageBlocks || this.appendTarget !== this.historyContainer)
+            return;
+        const page = detectInlinePageResult(result);
+        if (page === undefined || this.pageBlocks.has(page.pageId))
+            return;
+        const block = new PageBlockComponent(page.pageId, this.pageOpenHint);
+        this.pageBlocks.set(page.pageId, block);
+        // A page asks the person something; it never folds into the working.
+        this.outsideTurns++;
+        try {
+            this.append(block);
+        }
+        finally {
+            this.outsideTurns--;
+        }
+        // The block is placed empty and fills itself from the daemon: reading a
+        // request is a round trip, and the transcript must not block on one.
+        void this.loadPageBlock(block);
+    }
+    async loadPageBlock(block) {
+        if (!(await block.refresh()))
+            return;
+        this.historyContainer.setHidden(block, this.hidesInboxExchange() && block.settled);
+        this.historyContainer.markDirty(block);
+        this.tui.requestRender();
+    }
+    /** Re-measure the tool calls still in flight. A silent long-running command
+     *  emits no tool-execution update, so nothing else would evict its cached
+     *  lines and its backgrounding hint would never appear. Driven by the
+     *  viewer's existing low-rate chrome poll, and cheap because it touches only
+     *  in-flight tools — usually one, never the transcript. */
+    refreshInFlightTools() {
+        if (this.pendingTools.size === 0)
+            return;
+        for (const component of this.pendingTools.values())
+            this.historyContainer.markDirty(component);
+        this.tui.requestRender();
+    }
+    /** Re-read every placed page through the daemon. Driven by the viewer's
+     *  ticket-activity watcher, so an answer, a cancellation, or a `--replace`
+     *  revision lands on the block already anchored in the transcript. */
+    async refreshPageBlocks() {
+        const blocks = [...this.pageBlocks.values()];
+        const changed = await Promise.all(blocks.map(async (block) => {
+            const moved = await block.refresh();
+            if (moved) {
+                this.historyContainer.setHidden(block, this.hidesInboxExchange() && block.settled);
+                this.historyContainer.markDirty(block);
+            }
+            return moved;
+        }));
+        if (changed.some(Boolean))
+            this.tui.requestRender();
+    }
+    makeLoader(message) {
+        // Loader updates itself on an interval. Its TUI callback has to evict the
+        // status block's cached frame before requesting the next render.
+        let loader;
+        const statusTui = {
+            requestRender: (force) => {
+                if (loader && !this.onActivityChange)
+                    this.statusContainer.markDirty(loader);
+                this.tui.requestRender(force);
+            },
+            terminal: this.tui.terminal,
+        };
+        loader = new Loader(statusTui, this.spinnerStyle, this.dimStyle, message);
+        return loader;
+    }
+    /** Let a self-updating history child invalidate only its own cached lines. */
+    componentTui(component) {
+        return {
+            requestRender: (force) => {
+                this.historyContainer.markDirty(component());
+                this.tui.requestRender(force);
+            },
+            terminal: this.tui.terminal,
+        };
+    }
+    /** Complete and release the live bash component before ChatView gives up ownership. */
+    settleBashComponent(result) {
+        if (!this.bashComponent)
+            return;
+        const component = this.bashComponent;
+        component.setComplete(result?.exitCode, result?.cancelled ?? true, result?.truncated ? { truncated: true } : undefined, result?.fullOutputPath);
+        this.historyContainer.markDirty(component);
+        this.bashComponent = undefined;
+    }
+    /** Swap the single active activity indicator (working/compaction/retry). */
+    setActivity(loader) {
+        this.activityLoader?.stop();
+        this.activityLoader = loader;
+        if (this.onActivityChange) {
+            this.onActivityChange(loader);
+            return;
+        }
+        this.statusContainer.clear();
+        if (loader)
+            this.statusContainer.addChild(loader);
+    }
+    showStatus(message) {
+        this.closeOpenGroup();
+        this.append(new Spacer(1));
+        this.append(new Text(this.dimStyle(message), 1, 0));
+    }
+    /** Append an error to the transcript. pi's own error events land here, and so
+     *  do the broker's `error` frames: their text is the engine's own and is
+     *  routinely multi-line (pi's login help is three lines), which the one-row
+     *  status notice cannot show. */
+    showError(message) {
+        if (this.deferIfBuilding(() => this.showError(message)))
+            return;
+        this.closeOpenGroup();
+        // An error stays in view even when consolidated replies fold the turn.
+        this.outsideTurns++;
+        try {
+            this.append(new Spacer(1));
+            this.append(new Text(this.errorStyle(message), 1, 0));
+        }
+        finally {
+            this.outsideTurns--;
+        }
+        this.tui.requestRender();
+    }
+    crtrOutputTheme() {
+        return {
+            fg: (name, text) => {
+                if (name === 'error')
+                    return this.errorStyle(text);
+                if (name === 'warning' || name === 'accent' || name === 'toolTitle' || name === 'success')
+                    return this.spinnerStyle(text);
+                if (name === 'muted')
+                    return this.dimStyle(text);
+                return text;
+            },
+            bg: (_name, text) => text,
+            bold: (text) => this.labelStyle(text),
+        };
+    }
+    /** Extract the tool-call content items from an assistant message. */
+    assistantToolCalls(message) {
+        const content = message.content;
+        if (!Array.isArray(content))
+            return [];
+        return content.filter((c) => typeof c === 'object' && c !== null && c.type === 'toolCall');
+    }
+    /** Existing file paths from the rendered transcript, newest first. */
+    getTranscriptFilePathsNewestFirst() {
+        return [...this.transcriptFilePaths];
+    }
+    /** `[[ref]]` document references from the transcript, newest first, deduped. */
+    getTranscriptDocRefsNewestFirst() {
+        return [...this.transcriptDocRefs];
+    }
+    /** Re-run every Markdown transform: a document link's rendered target changed. */
+    refreshMarkdown() {
+        this.historyContainer.invalidate();
+        this.tui.requestRender();
+    }
+    /** The text of the most recent assistant message, for `/copy`. Undefined when
+     *  no assistant message has been seen (or it had no text content). */
+    getLastAssistantText() {
+        const t = this.lastAssistantText?.trim();
+        return t ? t : undefined;
+    }
+    /** Copyable source text for a transcript block, if it has any. */
+    blockText(block) {
+        const index = this.copyIndex.get(block);
+        return index === undefined ? undefined : this.copyBlockRecords[index]?.text;
+    }
+    /** The canonical ordered copy record, oldest → newest. */
+    copyBlocks() {
+        return this.copyBlockRecords;
+    }
+    /** Newest tool call's result text (`/copy-tool`). */
+    getLastToolOutputText() {
+        for (let i = this.copyBlockRecords.length - 1; i >= 0; i--) {
+            const copyBlock = this.copyBlockRecords[i];
+            if (copyBlock.kind !== 'tool')
+                continue;
+            return copyBlock.text.trim() === '' ? undefined : copyBlock.text;
+        }
+        return undefined;
+    }
+    /** Every copyable block's text, oldest → newest, joined by blank lines. */
+    getTranscriptPlainText() {
+        return this.copyBlockRecords
+            .map((copyBlock) => copyBlock.text)
+            .filter((text) => text.trim() !== '')
+            .join('\n\n');
+    }
+    registerCopyBlock(block, kind, text) {
+        const condensedCopyBlocks = this.condensedCopyBlocks.get(this.appendTarget);
+        if (condensedCopyBlocks) {
+            const index = condensedCopyBlocks.findIndex((copyBlock) => copyBlock.block === block);
+            if (index === -1)
+                condensedCopyBlocks.push({ block, kind, text });
+            else
+                condensedCopyBlocks[index].text = text;
+            return;
+        }
+        const index = this.copyIndex.get(block);
+        if (index === undefined) {
+            this.copyIndex.set(block, this.copyBlockRecords.length);
+            this.copyBlockRecords.push({ block, kind, text });
+        }
+        else {
+            this.copyBlockRecords[index].text = text;
+        }
+    }
+    unregisterCopyBlock(block) {
+        const condensedCopyBlocks = this.condensedCopyBlocks.get(this.appendTarget);
+        if (condensedCopyBlocks) {
+            const index = condensedCopyBlocks.findIndex((copyBlock) => copyBlock.block === block);
+            if (index !== -1)
+                condensedCopyBlocks.splice(index, 1);
+            return;
+        }
+        const index = this.copyIndex.get(block);
+        if (index === undefined)
+            return;
+        this.copyBlockRecords.splice(index, 1);
+        this.copyIndex.delete(block);
+        for (let i = index; i < this.copyBlockRecords.length; i++) {
+            this.copyIndex.set(this.copyBlockRecords[i].block, i);
+        }
+    }
+    appendCondensedBlock({ component, copyBlocks }) {
+        this.outsideTurns++;
+        try {
+            this.append(component);
+        }
+        finally {
+            this.outsideTurns--;
+        }
+        this.registerCopyBlock(component, 'condensed', copyBlocks.map((copyBlock) => copyBlock.text).filter((text) => text.trim() !== '').join('\n\n'));
+    }
+    /** Flatten arbitrary tool result payloads into the visible text copy target. */
+    toolResultText(result) {
+        if (typeof result === 'string')
+            return result;
+        if (typeof result === 'object' && result !== null && 'content' in result) {
+            const content = result.content;
+            if (typeof content === 'string')
+                return content;
+            if (Array.isArray(content)) {
+                return content
+                    .filter((part) => typeof part === 'object' &&
+                    part !== null &&
+                    part.type === 'text' &&
+                    typeof part.text === 'string')
+                    .map((part) => part.text)
+                    .join('');
+            }
+        }
+        try {
+            const text = JSON.stringify(result);
+            return typeof text === 'string' ? text : '';
+        }
+        catch {
+            return '';
+        }
+    }
+    pushTranscriptText(text) {
+        const trimmed = text.trim();
+        if (trimmed === '')
+            return;
+        const refs = [...new Set(extractDocRefs(trimmed).reverse())];
+        if (refs.length > 0) {
+            const nextRefs = [...refs, ...this.transcriptDocRefs.filter((ref) => !refs.includes(ref))].slice(0, 50);
+            this.transcriptDocRefs.splice(0, this.transcriptDocRefs.length, ...nextRefs);
+        }
+        const paths = extractFilePaths([trimmed], this.cwd);
+        if (paths.length === 0)
+            return;
+        const next = [...paths, ...this.transcriptFilePaths.filter((path) => !paths.includes(path))].slice(0, 50);
+        this.transcriptFilePaths.splice(0, this.transcriptFilePaths.length, ...next);
+    }
+    pushTranscriptValue(value) {
+        try {
+            const text = typeof value === 'string' ? value : JSON.stringify(value);
+            if (typeof text === 'string')
+                this.pushTranscriptText(text);
+        }
+        catch {
+            // Tool payloads that cannot serialize are not transcript text.
+        }
+    }
+    /** Concatenate the text blocks of a user message (string or content array). */
+    userMessageText(message) {
+        const content = message.content;
+        if (typeof content === 'string')
+            return content;
+        if (!Array.isArray(content))
+            return '';
+        return content
+            .filter((c) => typeof c === 'object' && c !== null && c.type === 'text')
+            .map((c) => c.text)
+            .join('');
+    }
+}