@deepseek-harness-tui/dsh-tui 0.13.0 → 0.14.0

package/lib/types/dsh-adapter/channel/projection.js

@@ -1,1146 +1,41 @@
-import { replaySelectionAttachment } from './ide-selection.js';
-import { isSubagentToolName, parseJobOutputId, toolCommandOf, BACKGROUND_START_ACK, todoPanelItems } from './projection-helpers.js';
-import { ARGS_PREVIEW_LIMIT, harnessToolResultView, LOCAL_OUTPUT_LIMIT, prepareReplayEvents, preview, RESULT_PREVIEW_LIMIT, toolErrorText } from './transcript.js';
-import { estimateTokens, isTokenDelta, tokenDeltaChars, usageOutputTokens } from './usage.js';
-import { transcriptImagesOf } from '../transcript-images.js';
-import { isCompactionCheckpointSource, toolResultPayload } from '../compat/messages.js';
-import { addUsageToCostBuckets, emptyCostBuckets, isPeakHour } from '../../deepseekPricing.js';
-import { t } from '../../i18n.js';
-import { logForDebugging } from '../../utils/debug.js';
-import { cleanRenderText } from '../sanitize.js';
-import { NOTICE_CELLS } from './decisions.js';
-import { markChannelReadDirty } from '../../adapter/channel/read-view.js';
-import { buildQuestionRecord, parseQuestionRecordAnswers, parseQuestionRecordQuestions, } from './question-record.js';
-/** One authoritative reducer for both durable replay and live session events. */
+import { createChannelProjection as createSharedProjection } from '../../channel/projection.js';
+import { createDshTranslator, dshPricingWindow } from '../backend/translate.js';
+const LIVE = { replay: false };
+const REPLAY = { replay: true };
+/** One reducer for both durable replay and live session events. */
 export function createChannelProjection(state, deps) {
-    /** The in-progress assistant text row; `undefined` when no step is streaming. */
-    let streaming;
-    /** The in-progress reasoning row; `undefined` when no reasoning is streaming. */
-    let reasoning;
-    /** Reasoning rows sealed this turn. Full mode keeps them expanded until
-     *  turn/end without leaving their streaming spinner active. */
-    const sealedReasoning = [];
-    /** Wall-clock start of the current reasoning row (durationMs on settle). */
-    let reasoningStart = 0;
-    /** Decode-throughput fold for the current turn. DSH defines one step as
-     *  one model call plus its tools; summing only first-token → message spans
-     *  excludes tool execution and per-request TTFT from generation speed. */
-    let tpsTurn;
-    let tpsBeforeTurn;
-    let tpsTurnDecodeMs = 0;
-    let tpsTurnDecodeTokens = 0;
-    let tpsTurnSampled = false;
-    let tpsStep;
-    /** Tool cards by callId, so tool/result can settle the running card. */
-    const toolCards = new Map();
-    /**
-     * `ask_user_question` calls by callId, holding their raw arguments. The ask
-     * renders as the interactive panel rather than a tool card, so its result
-     * has no card to settle — but the answered record is still a transcript
-     * fact and must come from the durable log (issue #1009), never from the
-     * view. Remembering the call lets `tool/result` derive that record on the
-     * live stream AND on every replay (`/resume`, rewind, model switch).
-     */
-    const askCalls = new Map();
-    /**
-     * Session events are delivered live and can also be replayed around a
-     * reconnect. A repeated sealed message must not create a second assistant
-     * row for the same durable sequence number.
-     */
-    const handledAssistantMessages = new Set();
-    const handledAssistantChunks = new Set();
-    /** One Agent runs one request at a time. Durable step boundaries also let
-     *  a freshly attached projector accept chunks whose start it missed. */
-    let openStep;
-    let activeAttempt;
-    let lastStreamRevision = -1;
-    /** 最近一次 request/header 的模型：durable usage 的模型归属真源。replay
-     *  会按历史请求逐个还原，因此 /model 切换（reset + replay 整个 seed）
-     *  不会把换模型前的用量重估到新模型；旧日志没有 header 时回退
-     *  事件发生时的 state.model（AC-A4）。 */
-    let eventModel;
-    const assistantRowsByStep = new Map();
-    const lastTextDelta = new Map();
-    const stepKey = (turn, step) => `${turn}:${step}`;
-    const touchRow = (row) => { markChannelReadDirty(row); markChannelReadDirty(state.rows); };
-    const appendRow = (row) => { state.rows.push(row); markChannelReadDirty(state.rows); };
-    const removeRow = (row) => {
-        const index = state.rows.indexOf(row);
-        if (index !== -1) {
-            state.rows.splice(index, 1);
-            markChannelReadDirty(state.rows);
-        }
-        if (streaming === row)
-            streaming = undefined;
-        if (reasoning === row)
-            reasoning = undefined;
-        if (lastReasoningRow?.row === row)
-            lastReasoningRow = undefined;
-        const sealedIndex = sealedReasoning.indexOf(row);
-        if (sealedIndex !== -1)
-            sealedReasoning.splice(sealedIndex, 1);
-        lastTextDelta.delete(row);
+    const translator = createDshTranslator({
+        tools: () => deps.tools,
+        scope: () => deps.agent(),
+        attachments: () => deps.attachments(),
+    });
+    const projector = createSharedProjection(state, {
+        rowIds: deps.rowIds,
+        resetContextWarning: () => deps.resetContextWarning(),
+        checkContextWarning: () => deps.checkContextWarning(),
+        notify: (...args) => deps.notify(...args),
+        jobs: deps.jobs,
+        inputConvergence: deps.inputConvergence,
+        renderer: deps.renderer,
+        selectionAttached: messageId => deps.selectionAttached(messageId),
+        pricingWindow: dshPricingWindow,
+    });
+    return {
+        /** Forget every per-session ledger on both halves. */
+        reset() {
+            translator.reset();
+            projector.reset();
+        },
+        replayEvents(events) {
+            projector.apply(translator.translateReplay(events), REPLAY);
+        },
+        renderEvent(event) {
+            projector.apply(translator.translateEvent(event), LIVE);
+        },
+        renderStreamFrame(frame) {
+            projector.apply(translator.translateFrame(frame), LIVE);
+        },
+        settleStreaming: projector.settleStreaming,
+        updateSpinnerMode: projector.updateSpinnerMode,
     };
-    const discardAttempt = (turn, step) => {
-        const key = stepKey(turn, step);
-        const row = assistantRowsByStep.get(key);
-        if (row !== undefined && row.seq === undefined) {
-            state.responseChars = Math.max(0, state.responseChars - row.text.length);
-            removeRow(row);
-            assistantRowsByStep.delete(key);
-        }
-        if (lastReasoningRow !== undefined && lastReasoningRow.turn === turn && lastReasoningRow.step === step && lastReasoningRow.row.seq === undefined) {
-            removeRow(lastReasoningRow.row);
-        }
-        if (activeAttempt !== undefined && activeAttempt.turn === turn && activeAttempt.step === step)
-            activeAttempt = undefined;
-        if (tpsStep !== undefined && tpsStep.turn === turn && tpsStep.step === step) {
-            tpsStep.firstTokenTime = undefined;
-            tpsStep.outputChars = 0;
-        }
-        updateSpinnerMode();
-    };
-    /** Durable session image blocks, loaded lazily through the attachment
-     *  store. Projection never reads pixels; the UI decodes on demand. */
-    const transcriptImages = (content) => transcriptImagesOf(content, deps.attachments);
-    /** V3 deltas are ordered by frame revision and must stay byte-exact.
-     * Legacy reconnect/proxy events may instead repeat a cumulative prefix. */
-    const appendTextDelta = (row, delta, legacy) => {
-        if (delta === '')
-            return;
-        if (!legacy) {
-            row.text += delta;
-            touchRow(row);
-            return;
-        }
-        if (lastTextDelta.get(row) === delta)
-            return;
-        lastTextDelta.set(row, delta);
-        if (delta.startsWith(row.text)) {
-            row.text = delta;
-            touchRow(row);
-            return;
-        }
-        const maxOverlap = Math.min(row.text.length, delta.length, 4096);
-        for (let size = maxOverlap; size > 0; size--) {
-            if (row.text.endsWith(delta.slice(0, size))) {
-                row.text += delta.slice(size);
-                touchRow(row);
-                return;
-            }
-        }
-        row.text += delta;
-        touchRow(row);
-    };
-    /** The host-plane tools registry (dsh-tools). Resolved once; absent in
-     *  bare embedders — every presenter call soft-fails to undefined and the
-     *  card falls back to raw text. */
-    const toolsRegistry = deps.tools;
-    /** Ask the producing tool how its call should render (diff/terminal/…).
-     *  Scoped to the live agent so preset-owned tool definitions resolve —
-     *  the dsh-host-apiproxy presenter pattern. Unknown tool, unparseable
-     *  args, or a throwing presenter all degrade to the plain text card. */
-    const presentCallView = (name, rawArgs) => {
-        try {
-            const tool = toolsRegistry?.get(name, deps.agent());
-            if (tool?.presentCall === undefined)
-                return undefined;
-            return tool.presentCall(JSON.parse(rawArgs));
-        }
-        catch {
-            return undefined;
-        }
-    };
-    /** Same for the settled result; `meta` is the tool-private presentation
-     *  payload the tool attached to its tool/result event (dsh-tool-fs reads
-     *  its result-time contextual diff back from here). */
-    const presentResultView = (name, rawArgs, data) => {
-        try {
-            // Harness goal/todo tools first: their raw JSON reads as noise in the
-            // transcript — fold recognizable shapes into a summary card before the
-            // registry gets a chance to (not) know them.
-            const local = harnessToolResultView(name, data);
-            if (local !== undefined)
-                return local;
-            const tool = toolsRegistry?.get(name, deps.agent());
-            if (tool?.presentResult === undefined)
-                return undefined;
-            return tool.presentResult(JSON.parse(rawArgs), {
-                ...toolResultPayload(data.message),
-                ...(data.meta !== undefined ? { meta: data.meta } : {}),
-            });
-        }
-        catch {
-            return undefined;
-        }
-    };
-    // ContentBlockMap is merge-extensible: plugin-added block types are
-    // silently skipped (v1 renders text blocks only) — never crashes.
-    const textOf = (content) => (content ?? []).map(block => (block.type === 'text' ? block.text : '')).join('').trim();
-    /**
-     * Transcript-facing text of a user message: the FIRST text block only.
-     * `@`-mention attachments (issue #15) ride as later blocks — model-facing
-     * only — so joining every block would dump file contents into the bubble,
-     * the sticky header, and session titles.
-     */
-    const firstTextOf = (content) => (content ?? []).find(block => block.type === 'text')?.text.trim() ?? '';
-    const ensureStreaming = (seq) => {
-        if (streaming !== undefined)
-            return streaming;
-        // A reconnect can replay the first delta after the sealed message was
-        // already observed. Reuse that durable row instead of opening a second
-        // assistant bubble for the same event sequence.
-        const existing = seq === undefined
-            ? undefined
-            : [...state.rows].reverse().find(row => row.kind === 'assistant' && row.seq === seq);
-        if (existing !== undefined) {
-            existing.streaming = true;
-            touchRow(existing);
-            streaming = existing;
-            return existing;
-        }
-        streaming = { id: deps.rowIds.value, kind: 'assistant', text: '', streaming: true, fresh: true, ...seq !== undefined ? { seq } : {} };
-        deps.rowIds.value += 1;
-        appendRow(streaming);
-        return streaming;
-    };
-    /** Latest reasoning row keyed by its (turn, step) — lets a resumed
-     *  mid-step stream REVIVE the row the replay sealed (crash-orphan tail:
-     *  replay folds the partial row, live continuation chunks would
-     *  otherwise open a SECOND row for the same step, splitting one
-     *  thinking block in two). */
-    let lastReasoningRow;
-    const ensureReasoning = (seq, turn, step) => {
-        if (reasoning === undefined) {
-            // Same-step revive: the sealed row is this step's thinking — continue
-            // it (durationMs carried over via reasoningStart back-dating).
-            if (lastReasoningRow !== undefined &&
-                turn !== undefined &&
-                lastReasoningRow.turn === turn &&
-                lastReasoningRow.step === step) {
-                reasoning = lastReasoningRow.row;
-                reasoning.streaming = true;
-                reasoning.thinkingOpen = false;
-                touchRow(reasoning);
-                const sealedIdx = sealedReasoning.indexOf(reasoning);
-                if (sealedIdx !== -1)
-                    sealedReasoning.splice(sealedIdx, 1);
-                reasoningStart = Date.now() - (reasoning.durationMs ?? 0);
-                logForDebugging('thinking: revived sealed reasoning row for same step');
-                return reasoning;
-            }
-            reasoningStart = Date.now();
-            reasoning = { id: deps.rowIds.value, kind: 'reasoning', text: '', streaming: true, ...seq !== undefined ? { seq } : {} };
-            deps.rowIds.value += 1;
-            appendRow(reasoning);
-            logForDebugging('thinking: reasoning row open (expanded)');
-        }
-        if (turn !== undefined && step !== undefined) {
-            lastReasoningRow = { row: reasoning, turn, step };
-        }
-        return reasoning;
-    };
-    /** Settle live reasoning the moment the model moves PAST
-     *  thinking — the answer's first text token or a tool call — not at
-     *  `assistant/message` (end of step). A long reply pushes the thinking
-     *  block into terminal scrollback long before the message seals, and
-     *  scrollback rows cannot be repainted (the cursor cannot reach them),
-     *  so a late fold leaves a stale unfolded preview frozen above the
-     *  window — the user scrolls up and the thinking looks "not folded".
-     *  Folding while the block still sits in the live window keeps the
-     *  shrink inside the diff engine's reachable region. Full mode keeps the
-     *  settled block open separately, so its spinner can stop immediately. */
-    const settleLiveReasoning = (where) => {
-        if (reasoning === undefined)
-            return;
-        const duration = Math.max(0, Date.now() - reasoningStart);
-        reasoning.durationMs = duration;
-        reasoning.streaming = false;
-        reasoning.thinkingOpen = state.thinkingFold === 'full';
-        touchRow(reasoning);
-        sealedReasoning.push(reasoning);
-        reasoning = undefined;
-        logForDebugging(`thinking: folded at ${where} (${duration}ms)`);
-    };
-    const settleStreaming = () => {
-        if (streaming !== undefined) {
-            streaming.streaming = false;
-            touchRow(streaming);
-        }
-        streaming = undefined;
-        const folded = sealedReasoning.length + (reasoning !== undefined ? 1 : 0);
-        for (const row of sealedReasoning) {
-            row.streaming = false;
-            row.thinkingOpen = false;
-            touchRow(row);
-        }
-        sealedReasoning.length = 0;
-        if (reasoning !== undefined) {
-            reasoning.streaming = false;
-            reasoning.thinkingOpen = false;
-            reasoning.durationMs = Math.max(0, Date.now() - reasoningStart);
-            touchRow(reasoning);
-        }
-        reasoning = undefined;
-        if (folded > 0)
-            logForDebugging(`thinking: folded ${folded} reasoning row(s) at turn settle`);
-    };
-    /**
-     * Project one answered `ask_user_question` result into the transcript.
-     *
-     * The row shape reuses what `pushLocal` emits (`local` title + one
-     * `local-output` per line), so rendering, preview clipping and the local
-     * rows' fold exemption all keep their existing behavior. A failed ask
-     * renders the log's own error text — never a fabricated answer (the ask
-     * was cancelled/aborted, so no human ever chose anything).
-     */
-    const projectAskResult = (event, rawArguments) => {
-        const append = (record) => {
-            appendRow({ id: deps.rowIds.value, kind: 'local', text: record.title, seq: event.seq });
-            deps.rowIds.value += 1;
-            for (const line of record.lines) {
-                appendRow({
-                    id: deps.rowIds.value,
-                    kind: 'local-output',
-                    text: preview(line, LOCAL_OUTPUT_LIMIT),
-                    seq: event.seq,
-                });
-                deps.rowIds.value += 1;
-            }
-        };
-        if (event.data.error !== undefined || toolResultPayload(event.data.message).isError) {
-            const errorText = toolErrorText(event);
-            append({ title: errorText, lines: [] });
-            return;
-        }
-        const answers = parseQuestionRecordAnswers(textOf(toolResultPayload(event.data.message).content));
-        // No parseable answers (unparseable durable payload, or an older host):
-        // `answers: []` still yields the title, so the transcript shows that a
-        // questionnaire happened instead of dropping the fact silently.
-        append(buildQuestionRecord(parseQuestionRecordQuestions(rawArguments), answers ?? []));
-    };
-    /** Recompute the spinner phase from live row/tool state. */
-    const updateSpinnerMode = () => {
-        if (state.activeToolCount > 0) {
-            state.spinnerMode = 'tool-use';
-        }
-        else if (reasoning !== undefined) {
-            // Only LIVE reasoning counts — sealed rows stay streaming=true for
-            // transcript expansion until turn/end but the model is past thinking.
-            state.spinnerMode = 'thinking';
-        }
-        else if (streaming !== undefined) {
-            state.spinnerMode = 'responding';
-        }
-        else {
-            state.spinnerMode = 'requesting';
-        }
-    };
-    /** Fold one goal mutation into the channel's goal projection. */
-    const applyGoalChange = (change) => {
-        if (change.operation === 'clear') {
-            state.goal = undefined;
-        }
-        else if (change.goal !== undefined) {
-            state.goal = {
-                ...change.goal,
-                roundsStarted: change.roundsStarted ?? state.goal?.roundsStarted ?? 0,
-            };
-        }
-    };
-    /**
-     * Fold one goal-sourced message into the channel's goal projection.
-     * Round-zero goal messages may carry the full durable snapshot (or a clear
-     * tombstone) in their source; positive-round messages are admitted
-     * continuation prompts that only advance the rounds counter.
-     */
-    const applyGoalEvent = (event) => {
-        const source = event.data.source;
-        if (source.round > 0) {
-            // Admitted continuation round — the snapshot itself is unchanged.
-            if (state.goal !== undefined) {
-                state.goal = {
-                    ...state.goal,
-                    roundsStarted: Math.max(state.goal.roundsStarted, source.round),
-                };
-            }
-            return;
-        }
-        const change = source.change;
-        // oxlint-disable-next-line typescript/no-unnecessary-condition -- durable replay data may not match the static type
-        if (change === undefined || change.kind !== 'goal/change')
-            return;
-        applyGoalChange(change);
-    };
-    /** Replay paints settled history without the live smooth-reveal animation. */
-    let replaying = false;
-    const replayEvents = (events) => {
-        // Event sequence numbers restart with a replacement session; reset the
-        // idempotency ledger before replay so an old session cannot suppress a
-        // legitimate message in the new transcript.
-        handledAssistantMessages.clear();
-        handledAssistantChunks.clear();
-        openStep = undefined;
-        activeAttempt = undefined;
-        lastStreamRevision = -1;
-        eventModel = undefined;
-        assistantRowsByStep.clear();
-        lastTextDelta.clear();
-        replaying = true;
-        try {
-            for (const event of prepareReplayEvents(events))
-                renderEvent(event);
-        }
-        finally {
-            replaying = false;
-        }
-    };
-    /**
-     * One live stream delta, from a 0.1.5 `agent/assistant-stream` chunk frame
-     * or a legacy `assistant/chunk` session event (pre-0.1.5 hosts and raw
-     * pre-V3 logs). `seq` exists only on the durable-event path.
-     */
-    const renderStreamChunk = (turn, step, chunk, time, seq) => {
-        if (chunk.type === 'text-delta') {
-            if (chunk.text) {
-                // Fold the thinking preview while it is still in the live
-                // window (see settleLiveReasoning) — before this text grows the
-                // transcript and pushes the block into scrollback.
-                settleLiveReasoning('first text token');
-                const key = stepKey(turn, step);
-                const row = assistantRowsByStep.get(key) ?? ensureStreaming(seq);
-                assistantRowsByStep.set(key, row);
-                streaming = row;
-                row.streaming = true;
-                touchRow(row);
-                const before = row.text.length;
-                appendTextDelta(row, chunk.text, seq !== undefined);
-                state.responseChars += Math.max(0, row.text.length - before);
-            }
-        }
-        else if (chunk.type === 'reasoning-delta') {
-            if (chunk.text) {
-                const row = ensureReasoning(seq, turn, step);
-                appendTextDelta(row, chunk.text, seq !== undefined);
-            }
-        }
-        const tps = tpsStep;
-        if (tps !== undefined &&
-            tps.turn === turn &&
-            tps.step === step &&
-            isTokenDelta(chunk)) {
-            tps.firstTokenTime ??= time;
-            tps.outputChars += tokenDeltaChars(chunk);
-            const elapsedMs = Math.max(0, time - tps.firstTokenTime);
-            if (elapsedMs > 500) {
-                const decodeMs = tpsTurnDecodeMs + elapsedMs;
-                const outputTokens = tpsTurnDecodeTokens + Math.ceil(tps.outputChars / 4);
-                state.tps = outputTokens / (decodeMs / 1000);
-            }
-        }
-        updateSpinnerMode();
-    };
-    /**
-     * Live assistant stream frame (0.1.5+): the transient per-token counterpart
-     * of the durable `assistant/message`/`assistant/attempt` settlement. Start
-     * frames own the attempt's (turn, step); a reattach rebuilds that pair
-     * from the open durable step. Settlement owns the text; an abandoned end
-     * must discard provisional rows even when no durable event was written.
-     */
-    const renderStreamFrame = (frame) => {
-        if (frame.revision <= lastStreamRevision)
-            return;
-        lastStreamRevision = frame.revision;
-        if (frame.type === 'start') {
-            if (activeAttempt !== undefined)
-                discardAttempt(activeAttempt.turn, activeAttempt.step);
-            activeAttempt = { attemptId: frame.attemptId, turn: frame.turn, step: frame.step };
-            return;
-        }
-        if (frame.type === 'end') {
-            if (activeAttempt?.attemptId !== frame.attemptId)
-                return;
-            if (frame.outcome.kind === 'abandoned' || frame.outcome.eventType === 'assistant/attempt') {
-                discardAttempt(activeAttempt.turn, activeAttempt.step);
-            }
-            activeAttempt = undefined;
-            return;
-        }
-        if (activeAttempt === undefined && openStep !== undefined) {
-            activeAttempt = { attemptId: frame.attemptId, ...openStep };
-        }
-        const where = activeAttempt?.attemptId === frame.attemptId ? activeAttempt : undefined;
-        if (where === undefined)
-            return;
-        renderStreamChunk(where.turn, where.step, frame.chunk, frame.time);
-    };
-    const renderEvent = (event) => {
-        // Top-level `goal/change` events are how the goal service actually
-        // records durable goal mutations (create/edit/pause/resume/complete/
-        // block/clear) — confirmed in production logs. The pinned peer's
-        // SessionEvent union predates the type, so admit it structurally: the
-        // goal chip and panel stay dark without this fold.
-        if (event.type === 'goal/change') {
-            applyGoalChange(event.data);
-            return;
-        }
-        switch (event.type) {
-            case 'user/message': {
-                // Both legacy and V4 checkpoints render as a folded summary rather
-                // than disappearing with the other injected context.
-                if (isCompactionCheckpointSource(event.data.source)) {
-                    const summary = textOf(event.data.content);
-                    appendRow({ id: deps.rowIds.value, kind: 'notice', text: t('compact-done') });
-                    deps.rowIds.value += 1;
-                    if (summary) {
-                        appendRow({ id: deps.rowIds.value, kind: 'compact', text: summary });
-                        deps.rowIds.value += 1;
-                    }
-                    // The checkpoint replaces the whole pre-compact surface. Occupancy
-                    // needs no rewriting here: the official token meter folds this same
-                    // event and reprices the surface by its logged shadow price, so the
-                    // channel's `contextOccupancy` drops the moment the checkpoint lands
-                    // (the projection's change feed republishes the footer). The old
-                    // chars/4 rewrite below was a worse estimate of a number the host
-                    // already knows: it ignored the retained tail the official
-                    // `compaction-basic` keeps (default `retainRatio` 0.16), ignored the
-                    // tool catalog, and could not see the summary's real size.
-                    //
-                    // The SEGMENTED bar keeps its own heuristic composition (system +
-                    // the summary prompt): it describes what the surface is made of,
-                    // never the occupancy total.
-                    state.contextSegments = {
-                        system: state.contextSegments.system,
-                        prompt: estimateTokens(summary),
-                        assistant: 0,
-                        thinking: 0,
-                        tools: 0,
-                    };
-                    // The latch must release: compaction is the remediation for a low
-                    // context, so the warning has to be able to fire again afterwards.
-                    deps.resetContextWarning();
-                    break;
-                }
-                // Same-session goal domain: goal-sourced messages are the round
-                // driver's continuation prompts (positive rounds advance the
-                // counter); some hosts also inline the durable snapshot in a
-                // round-zero source. They are not transcript bubbles — they drive
-                // the goal panel's live projection (replayed on resume/rewind like
-                // every other event; the snapshot itself arrives as the top-level
-                // `goal/change` event admitted above).
-                if (event.data.source.kind === 'goal') {
-                    applyGoalEvent(event);
-                    break;
-                }
-                // Injected context (plugin/skill source) is not a human bubble; v1
-                // renders direct human prompts only.
-                if (event.data.source.kind !== 'user')
-                    break;
-                const text = firstTextOf(event.data.content);
-                const images = transcriptImages(event.data.content);
-                if (text || images.length > 0) {
-                    // IDE selection indicator: the delivery path remembered what this
-                    // message attached; the durable event carries the same message id.
-                    // On replay (session resumed in a NEW process) the in-memory map
-                    // starts empty, so the indicator falls back to the durable content
-                    // itself — the `<attached-file … selection>` block IS part of the
-                    // persisted event, and the session log is the source of truth
-                    // (maintainer review round 3: the indicator used to vanish after a
-                    // restart because nothing re-derived it from the event).
-                    const selectionAttached = deps.selectionAttached(event.data.id)
-                        ?? replaySelectionAttachment(event.data.content);
-                    appendRow({
-                        id: deps.rowIds.value,
-                        kind: 'user',
-                        text,
-                        ...(images.length === 0 ? {} : { images }),
-                        ...(selectionAttached === undefined ? {} : { selectionAttached }),
-                        seq: event.seq,
-                    });
-                    state.lastUserText = text || t('transcript-image-message', { count: images.length });
-                    // The context estimate counts everything sent to the model —
-                    // typed text AND the `@`-mention attachment blocks.
-                    state.contextSegments.prompt += estimateTokens(textOf(event.data.content));
-                    deps.rowIds.value += 1;
-                }
-                break;
-            }
-            case 'step/start': {
-                openStep = { turn: event.data.turn, step: event.data.step };
-                if (tpsTurn === event.data.turn) {
-                    tpsStep = {
-                        turn: event.data.turn,
-                        step: event.data.step,
-                        firstTokenTime: undefined,
-                        outputChars: 0,
-                    };
-                }
-                break;
-            }
-            case 'assistant/attempt': {
-                discardAttempt(event.data.turn, event.data.step);
-                break;
-            }
-            case 'assistant/message': {
-                if (handledAssistantMessages.has(event.seq))
-                    break;
-                handledAssistantMessages.add(event.seq);
-                // V3 embeds its complete attempt stream; older settlements may omit
-                // reasoning that is still durably recorded in assistant/chunk events.
-                const canonical = Array.isArray(event.data.stream);
-                const text = textOf(event.data.message.content);
-                const images = transcriptImages(event.data.message.content);
-                const reasoningText = event.data.message.content
-                    .map(block => (block.type === 'reasoning' ? block.text : ''))
-                    .join('');
-                const settledReasoning = lastReasoningRow !== undefined && lastReasoningRow.turn === event.data.turn && lastReasoningRow.step === event.data.step
-                    ? lastReasoningRow.row : reasoning;
-                if (settledReasoning !== undefined) {
-                    if (reasoningText === '') {
-                        if (canonical)
-                            removeRow(settledReasoning);
-                    }
-                    else {
-                        settledReasoning.text = reasoningText;
-                        settledReasoning.seq ??= event.seq;
-                        touchRow(settledReasoning);
-                    }
-                }
-                else if (reasoningText !== '') {
-                    // Replays and reattachments may not have seen any reasoning delta.
-                    // Insert before a live text row to preserve message block order.
-                    const rebuilt = {
-                        id: deps.rowIds.value,
-                        kind: 'reasoning',
-                        text: reasoningText,
-                        seq: event.seq,
-                    };
-                    deps.rowIds.value += 1;
-                    const textRow = assistantRowsByStep.get(stepKey(event.data.turn, event.data.step));
-                    const textIndex = textRow === undefined ? -1 : state.rows.indexOf(textRow);
-                    if (textIndex === -1)
-                        appendRow(rebuilt);
-                    else {
-                        state.rows.splice(textIndex, 0, rebuilt);
-                        markChannelReadDirty(state.rows);
-                    }
-                }
-                // Reasoning/tool-only steps emit no text: creating an assistant row
-                // anyway leaves an empty `●` bullet in the transcript. A pre-existing
-                // streaming row always has text (ensureStreaming is only reached on
-                // non-empty text deltas), so only create one when text arrives.
-                // Key the step→row ledger only when the event carries a durable
-                // turn/step; a message without them must never collide onto a
-                // previous step's row (a bare `undefined:undefined` key would make
-                // every turn/step-less message reuse the FIRST one's assistant row).
-                const msgTurn = event.data.turn;
-                const msgStep = event.data.step;
-                const msgKey = msgTurn !== undefined && msgStep !== undefined
-                    ? stepKey(msgTurn, msgStep)
-                    : undefined;
-                const row = (msgKey !== undefined ? assistantRowsByStep.get(msgKey) : undefined) ?? streaming ??
-                    (text || images.length > 0
-                        ? ([...state.rows].reverse().find(candidate => candidate.kind === 'assistant' && candidate.seq === event.seq) ?? ensureStreaming(event.seq))
-                        : undefined);
-                if (row !== undefined && canonical && !text && images.length === 0) {
-                    removeRow(row);
-                    if (msgKey !== undefined)
-                        assistantRowsByStep.delete(msgKey);
-                }
-                else if (row !== undefined) {
-                    if (msgKey !== undefined)
-                        assistantRowsByStep.set(msgKey, row);
-                    row.seq ??= event.seq;
-                    row.time = event.time;
-                    if (text || canonical)
-                        row.text = text;
-                    row.images = images.length === 0 ? undefined : images;
-                    row.streaming = false;
-                    // Live settles keep the smooth-reveal cursor alive (a one-shot
-                    // non-streaming delivery still paints as a flow); replayed
-                    // settles must not — the transcript would typewrite on open.
-                    if (!replaying && text)
-                        row.fresh = true;
-                    touchRow(row);
-                }
-                streaming = undefined;
-                if (reasoning !== undefined) {
-                    // Backstop fold: reasoning whose step ended with no text token
-                    // and no tool call (settleLiveReasoning handles those earlier —
-                    // while the block is still in the repaintable live window;
-                    // here a long reply may already have pushed it into scrollback,
-                    // where the shrink cannot be repainted). `full` mode
-                    // (/settings opt-in) keeps the block expanded until turn settle
-                    // — settleStreaming folds the sealed rows then.
-                    reasoning.durationMs = Math.max(0, Date.now() - reasoningStart);
-                    reasoning.streaming = false;
-                    reasoning.thinkingOpen = state.thinkingFold === 'full';
-                    touchRow(reasoning);
-                    sealedReasoning.push(reasoning);
-                    logForDebugging(`thinking: step sealed (${reasoning.durationMs}ms), expanded until turn/end`);
-                }
-                reasoning = undefined;
-                if (activeAttempt !== undefined && activeAttempt.turn === event.data.turn && activeAttempt.step === event.data.step)
-                    activeAttempt = undefined;
-                updateSpinnerMode();
-                const usage = event.data.usage;
-                if (usage !== undefined) {
-                    // oxlint-disable-next-line typescript/no-unnecessary-condition -- durable replay data may lack tokens
-                    state.tokens.input += usage.inputTokens ?? 0;
-                    // oxlint-disable-next-line typescript/no-unnecessary-condition -- durable replay data may lack tokens
-                    state.tokens.output += usage.outputTokens ?? 0;
-                    // Cache split totals feed the session cost estimate (hit-priced
-                    // input vs. uncached input) — the durable replay may lack them.
-                    state.tokens.cacheRead += usage.cacheReadTokens ?? 0;
-                    state.tokens.cacheWrite += usage.cacheWriteTokens ?? 0;
-                    // Peak/idle bucketing by the request's own time (the durable replay
-                    // replays historical events, so a resumed session prices each
-                    // request at the rate window it actually ran in — the session cost
-                    // estimate never prices the whole session at the current window).
-                    const peak = isPeakHour(new Date(event.time));
-                    {
-                        const bucket = peak
-                            ? state.tokens.peak
-                            : state.tokens.idle;
-                        bucket.input += usage.inputTokens ?? 0;
-                        bucket.output += usage.outputTokens ?? 0;
-                        bucket.cacheRead += usage.cacheReadTokens ?? 0;
-                        bucket.cacheWrite += usage.cacheWriteTokens ?? 0;
-                    }
-                    // 主会话费用分桶（DESIGN D2）：与 tokens 同口径，但按事件发生时
-                    // 的模型归属——replay 用 request/header 还原历史请求模型，旧日志
-                    // 回退 channel 模型；换模型不会把历史 token 重估到新模型。
-                    const costInput = usage.inputTokens ?? 0;
-                    const costOutput = usage.outputTokens ?? 0;
-                    const costCacheRead = usage.cacheReadTokens ?? 0;
-                    const costCacheWrite = usage.cacheWriteTokens ?? 0;
-                    if (costInput !== 0 || costOutput !== 0 || costCacheRead !== 0 || costCacheWrite !== 0) {
-                        const model = eventModel ?? state.model;
-                        const cost = state.mainCost[model] ?? emptyCostBuckets();
-                        addUsageToCostBuckets(cost, {
-                            input: costInput,
-                            output: costOutput,
-                            cacheRead: costCacheRead,
-                            cacheWrite: costCacheWrite,
-                        }, peak);
-                        state.mainCost[model] = cost;
-                    }
-                    // The most recent request's usage describes the CURRENT context:
-                    // input (uncached) + cache hits all occupy the window. Cache hits
-                    // also drive the status-line `cache N` readout.
-                    state.lastUsage = {
-                        // oxlint-disable-next-line typescript/no-unnecessary-condition -- durable replay data may lack tokens
-                        input: usage.inputTokens ?? 0,
-                        // oxlint-disable-next-line typescript/no-unnecessary-condition -- durable replay data may lack tokens
-                        output: usage.outputTokens ?? 0,
-                        cacheRead: usage.cacheReadTokens ?? 0,
-                        cacheWrite: usage.cacheWriteTokens ?? 0,
-                    };
-                }
-                const tpsMessageStep = tpsStep;
-                if (tpsTurn === event.data.turn &&
-                    tpsMessageStep !== undefined &&
-                    tpsMessageStep.turn === event.data.turn &&
-                    tpsMessageStep.step === event.data.step &&
-                    tpsMessageStep.firstTokenTime !== undefined) {
-                    const outputTokens = usageOutputTokens(usage)
-                        ?? (tpsMessageStep.outputChars > 0
-                            ? Math.ceil(tpsMessageStep.outputChars / 4)
-                            : undefined);
-                    if (outputTokens !== undefined) {
-                        tpsTurnDecodeMs += Math.max(0, event.time - tpsMessageStep.firstTokenTime);
-                        tpsTurnDecodeTokens += outputTokens;
-                        tpsTurnSampled = true;
-                        if (tpsTurnDecodeMs > 0) {
-                            state.tps = tpsTurnDecodeTokens / (tpsTurnDecodeMs / 1000);
-                        }
-                    }
-                }
-                if (tpsMessageStep !== undefined &&
-                    tpsMessageStep.turn === event.data.turn &&
-                    tpsMessageStep.step === event.data.step) {
-                    tpsStep = undefined;
-                }
-                // Context-bar segmentation (pi-nano-context style): assistant text
-                // and tool calls in the assistant segment, thinking separately.
-                for (const block of event.data.message.content) {
-                    if (block.type === 'text' && block.text) {
-                        state.contextSegments.assistant += estimateTokens(block.text);
-                    }
-                    else if (block.type === 'reasoning' && block.text) {
-                        state.contextSegments.thinking += estimateTokens(block.text);
-                    }
-                }
-                break;
-            }
-            case 'tool/call': {
-                // The ask-user-question tool renders as the interactive questionnaire
-                // panel (DSH user-interaction seam), not as a tool card: the model is
-                // parked waiting for the human, so no running card, no active-tool
-                // spinner, no args noise in the transcript. Only the ARGUMENTS are
-                // remembered: the paired tool/result below projects the answered
-                // record from them (issue #1009), so `/resume`, rewind and replay
-                // rebuild it from the persisted log like every other transcript row.
-                if (event.data.name === 'ask_user_question') {
-                    askCalls.set(event.data.callId, event.data.arguments);
-                    break;
-                }
-                // The Task tool's plain card is replaced by the live subagent card
-                // (Kimi Code semantics): the delegation itself renders as a subagent
-                // row, so the raw args/result card would only duplicate it. The call
-                // still runs - only its transcript rendering is suppressed.
-                if (isSubagentToolName(event.data.name)) {
-                    // The parent-scoped subagent reducer owns pending descriptions,
-                    // including delegations made while this transcript is parked.
-                    break;
-                }
-                // Reasoning that led to a tool call is done thinking — fold the
-                // preview now, before the tool card grows the transcript past it
-                // (see settleLiveReasoning).
-                settleLiveReasoning('tool call');
-                const card = {
-                    id: deps.rowIds.value,
-                    kind: 'tool',
-                    text: '',
-                    seq: event.seq,
-                    // Smooth-reveal participation flag: live cards animate their body
-                    // in; replayed cards (resume/rewind) paint complete.
-                    fresh: !replaying,
-                    tool: {
-                        callId: event.data.callId,
-                        name: event.data.name,
-                        argsText: preview(event.data.arguments, ARGS_PREVIEW_LIMIT),
-                        argsFull: event.data.arguments,
-                        status: 'running',
-                        callView: presentCallView(event.data.name, event.data.arguments),
-                        startedAt: Date.now(),
-                    },
-                };
-                deps.rowIds.value += 1;
-                toolCards.set(event.data.callId, card);
-                appendRow(card);
-                state.activeToolCount += 1;
-                state.contextSegments.assistant += estimateTokens(`${event.data.name}${event.data.arguments}`);
-                updateSpinnerMode();
-                break;
-            }
-            case 'tool/result': {
-                const callId = event.data.message.source.callId;
-                const card = toolCards.get(callId);
-                const askArguments = askCalls.get(callId);
-                // A call with no card is usually an ask_user_question (above) — its
-                // interaction lives in the panel, but its OUTCOME still belongs in
-                // the transcript. Project it from the durable log here: consumed
-                // before the card branch so the two can never both fire, and deleted
-                // so a repeated replay of the same result cannot double the record.
-                if (card === undefined && askArguments !== undefined) {
-                    projectAskResult(event, askArguments);
-                    askCalls.delete(callId);
-                    break;
-                }
-                if (card !== undefined && card.tool !== undefined) {
-                    const images = transcriptImages(event.data.message.content);
-                    card.images = images.length === 0 ? undefined : images;
-                    card.tool.durationMs = Math.max(0, Date.now() - card.tool.startedAt);
-                    const payload = toolResultPayload(event.data.message);
-                    if (event.data.error !== undefined || payload.isError) {
-                        card.tool.status = 'error';
-                        const errorText = toolErrorText(event);
-                        card.tool.errorText = errorText;
-                        state.contextSegments.tools += estimateTokens(errorText);
-                    }
-                    else {
-                        card.tool.status = 'ok';
-                        const result = textOf(payload.content);
-                        card.tool.resultFull = result || undefined;
-                        card.tool.resultText = result ? preview(result, RESULT_PREVIEW_LIMIT) : undefined;
-                        // The tool's own settled-state view (applied diff, terminal
-                        // output, read content…) wins over the raw text body. argsFull
-                        // pairs the args: live cards are never folded, so it is intact.
-                        card.tool.resultView = presentResultView(card.tool.name, card.tool.argsFull ?? '', event.data);
-                        state.contextSegments.tools += estimateTokens(result);
-                        // A job_output result doubles as the job card's output feed:
-                        // the registry's read() is consuming and reserved for the
-                        // owning agent, so the UI mirrors the tail that already streams
-                        // through the transcript instead of polling the job itself.
-                        if (card.tool.name === 'job_output' && result !== '') {
-                            const id = parseJobOutputId(card.tool.argsFull);
-                            if (id !== undefined)
-                                deps.jobs.onOutputSeen(id, result, event.time ?? Date.now());
-                        }
-                        // A `started background job <id>` ack pairs the job with its
-                        // tool call: capture the FULL command from the args (the
-                        // registry label is the friendly description) for the panel.
-                        const startAck = BACKGROUND_START_ACK.exec(result);
-                        if (startAck !== null) {
-                            const command = toolCommandOf(card.tool.argsFull);
-                            if (command !== undefined)
-                                deps.jobs.onStarted(startAck[1], command);
-                        }
-                    }
-                    state.activeToolCount = Math.max(0, state.activeToolCount - 1);
-                    // The card is settled: no later event looks it up by callId, so
-                    // drop the index entry. The card itself stays in state.rows
-                    // (bounded by MAX_ROWS + foldRows, which also drops the full
-                    // args/result payloads of folded cards).
-                    toolCards.delete(event.data.message.source.callId);
-                    touchRow(card);
-                    updateSpinnerMode();
-                }
-                break;
-            }
-            case 'step/end': {
-                if (openStep !== undefined && openStep.turn === event.data.turn && openStep.step === event.data.step)
-                    openStep = undefined;
-                if (tpsStep !== undefined &&
-                    tpsStep.turn === event.data.turn &&
-                    tpsStep.step === event.data.step) {
-                    tpsStep = undefined;
-                }
-                break;
-            }
-            case 'turn/start': {
-                deps.inputConvergence.cancelInFlight = false;
-                state.cancelPending = false;
-                state.working = true;
-                state.turnStart = Date.now();
-                state.responseChars = 0;
-                state.spinnerMode = 'requesting';
-                // Keep the prior turn visible until this turn produces a measurable
-                // decode span, while starting a fresh weighted step fold.
-                tpsBeforeTurn = state.tps;
-                tpsTurn = event.data.turn;
-                tpsTurnDecodeMs = 0;
-                tpsTurnDecodeTokens = 0;
-                tpsTurnSampled = false;
-                tpsStep = undefined;
-                break;
-            }
-            case 'turn/end': {
-                if (activeAttempt !== undefined)
-                    discardAttempt(activeAttempt.turn, activeAttempt.step);
-                openStep = undefined;
-                deps.inputConvergence.cancelInFlight = false;
-                state.cancelPending = false;
-                settleStreaming();
-                state.working = false;
-                state.activeToolCount = 0;
-                if (tpsTurn !== undefined && tpsTurn === event.data.turn) {
-                    if (tpsTurnSampled && tpsTurnDecodeMs > 0) {
-                        const turnTps = tpsTurnDecodeTokens / (tpsTurnDecodeMs / 1000);
-                        state.tps = turnTps;
-                        state.tpsSamples.push({ tps: turnTps, at: event.time });
-                        if (state.tpsSamples.length > 500)
-                            state.tpsSamples.shift();
-                    }
-                    else {
-                        // Do not leave a chars/4 live estimate behind when no completed
-                        // decode sample exists for this turn.
-                        state.tps = tpsBeforeTurn;
-                    }
-                    tpsTurn = undefined;
-                    tpsStep = undefined;
-                    tpsTurnDecodeMs = 0;
-                    tpsTurnDecodeTokens = 0;
-                    tpsTurnSampled = false;
-                }
-                // Occupancy is evaluated on EVERY turn end, not only a completed one:
-                // the request that overflowed the window is exactly the one whose turn
-                // ends as an error (it writes no successful usage sample at all), and
-                // an aborted turn has still grown the surface. Replay drains a resumed
-                // session's history through the projector; its totals describe the
-                // past, not a live context-low state.
-                if (!replaying)
-                    deps.checkContextWarning();
-                const reason = event.data.reason;
-                if (reason.kind === 'completed') {
-                    break;
-                }
-                if (reason.kind === 'aborted' || reason.kind === 'interrupted') {
-                    // `Agent.cancel()` closes the turn as `aborted`; `interrupted`
-                    // only appears for crash-orphaned turns. Both user-interruption
-                    // paths render as a distinct dim row.
-                    appendRow({
-                        id: deps.rowIds.value,
-                        kind: 'interrupt',
-                        text: t('interrupted-by-user') + t('interrupted-ask-next'),
-                    });
-                    deps.rowIds.value += 1;
-                    break;
-                }
-                // The notice renders as a single-line Divider title: error.message
-                // can carry newlines/control chars, and an embedded \n splits the
-                // rule across rows. cleanRenderText is the render-path single-line
-                // contract (sessionTree's preview() folds likewise for the tree).
-                const detail = reason.kind === 'error' ? cleanRenderText(reason.error.message, NOTICE_CELLS) : '';
-                appendRow({ id: deps.rowIds.value, kind: 'notice', text: `turn ${reason.kind}${detail ? ` · ${detail}` : ''}` });
-                deps.rowIds.value += 1;
-                // Historical failure notices belong to the transcript row above;
-                // re-raising them as a live toast on every /resume re-alarmes the
-                // user over a turn that already ended.
-                if (!replaying)
-                    deps.notify(t('turn-failed', { detail: detail ? ` · ${detail}` : '' }), { color: 'error', timeoutMs: 8000 });
-                break;
-            }
-            case 'request/context':
-                // Adapter-advertised context capacity; drives the context-low
-                // warning when the route reports one.
-                if (event.data.contextWindow !== undefined) {
-                    state.contextWindow = event.data.contextWindow;
-                }
-                break;
-            case 'system/message': {
-                // V3 system prompts are surface nodes, not header fields: the latest
-                // node holds the active instructions (an empty render clears them).
-                // The context bar's system segment tracks that live text.
-                state.contextSegments.system = estimateTokens(textOf(event.data.message.content));
-                break;
-            }
-            case 'request/header': {
-                // Reasoning effort readout (status line): the header carries the
-                // conversation's call config (provider/model/effort/sampling). The
-                // system prompt moved out of the header at V3 (see system/message);
-                // pre-V3 logs still carry it, admitted structurally below.
-                // oxlint-disable-next-line typescript/no-unnecessary-condition -- durable session data may lack header config
-                const effort = event.data.header.config?.reasoningEffort;
-                if (typeof effort === 'string') {
-                    state.reasoningEffort = effort;
-                }
-                // 模型归属真源：该请求的 usage 按这里的 model 计价（replay 时逐请求
-                // 还原；live 时与 state.model 同步更新，AC-A4）。header 缺/空 model
-                // 必须清掉上一条 header 的值——否则后续 usage 会沿用旧模型进错桶；
-                // 归属时再回退 state.model（旧日志没有 header 的既有语义）。
-                const headerModel = event.data.header.config?.model;
-                eventModel = typeof headerModel === 'string' && headerModel !== '' ? headerModel : undefined;
-                const legacySystem = event.data.header.system;
-                if (typeof legacySystem === 'string') {
-                    state.contextSegments.system = estimateTokens(legacySystem);
-                }
-                break;
-            }
-            case 'session/title':
-                state.sessionTitle = event.data.title;
-                break;
-            default:
-                // Pre-0.1.5 live streams and raw pre-V3 logs carry per-token chunks
-                // as durable session events; 0.1.5 moved live chunks to transient
-                // `agent/assistant-stream` frames (renderStreamFrame) and compacts the
-                // durable record into `assistant/message.stream`. Match by name so the
-                // current union (which no longer lists the type) stays compile-clean.
-                if (event.type === 'assistant/chunk') {
-                    if (handledAssistantChunks.has(event.seq))
-                        break;
-                    handledAssistantChunks.add(event.seq);
-                    const data = event.data;
-                    renderStreamChunk(data.turn, data.step, data.chunk, event.time, event.seq);
-                    break;
-                }
-                // dsh-tool-todo owns this optional module augmentation in alpha.2.
-                // Match by name so the TUI remains loadable without that plugin.
-                if (event.type === 'todo/write') {
-                    const todos = todoPanelItems(event.data);
-                    if (todos !== undefined)
-                        state.todos = todos;
-                    break;
-                }
-                // Logged preset switch (blank sessions only, issue #8): a transcript
-                // marker so a replayed log shows which composition produced the
-                // turns after it. Not in dsh-session's typed union — matched here by
-                // name, like the other plugin-defined events above.
-                if (event.type === 'agent-preset/selected') {
-                    const data = event.data;
-                    const recordedPreset = typeof data.agentPreset === 'string' ? data.agentPreset : undefined;
-                    const renamedOfficialPreset = (recordedPreset === 'code' && state.agentPreset === 'ptc') ||
-                        (recordedPreset === 'ptc' && state.agentPreset === 'code');
-                    const preset = renamedOfficialPreset && state.agentPreset !== undefined
-                        ? state.agentPreset
-                        : recordedPreset ?? 'unknown';
-                    appendRow({
-                        id: deps.rowIds.value,
-                        kind: 'notice',
-                        text: t('agent-preset-switched', { preset }),
-                    });
-                    deps.rowIds.value += 1;
-                    break;
-                }
-                // `/color` accent (dsh-tui plugin event, replayed on resume/rewind
-                // like session/title): last write wins, '' clears to the default.
-                if (event.type === 'session/color') {
-                    const data = event.data;
-                    state.sessionColor = typeof data.color === 'string' ? data.color : '';
-                    break;
-                }
-                // The compaction bracket is a plugin-appended event pair (not part of
-                // dsh-session's typed map). Opening it here rather than in the manual
-                // path is what makes an AUTOMATIC pressure compaction visible too: the
-                // host writes `compaction/start` before the summarizer runs and
-                // `compaction/end` once the checkpoint is committed or abandoned.
-                // A manual request already installed its own cancellable row, so this
-                // only fills the gap for one this process did not start.
-                if (event.type === 'compaction/start') {
-                    // Replay is settled history, and a process killed between start and
-                    // end leaves an unmatched start in the log: painting a row for it
-                    // would show a compaction that nothing will ever clear.
-                    if (!replaying && state.compaction === undefined) {
-                        state.compaction = {
-                            startedAt: typeof event.time === 'number' ? event.time : Date.now(),
-                            phase: 'prefill',
-                            outputChars: 0,
-                            cancellable: false,
-                        };
-                    }
-                    break;
-                }
-                if (event.type === 'compaction/end') {
-                    state.compaction = undefined;
-                    break;
-                }
-                // Custom plugin events (tuiRenderers seam): a registered renderer
-                // maps the payload to text rows — title as a local row, body as
-                // preview-clipped local-output rows, same shape pushLocal uses.
-                // Runs on the live stream AND on replay (resume/rewind), so the
-                // projection must stay total; the runtime isolates renderer
-                // crashes per type.
-                if (deps.renderer !== undefined) {
-                    const rendered = deps.renderer.render(event.type, event.data);
-                    if (rendered !== undefined) {
-                        if (rendered.title !== undefined && rendered.title !== '') {
-                            appendRow({ id: deps.rowIds.value, kind: 'local', text: rendered.title });
-                            deps.rowIds.value += 1;
-                        }
-                        for (const line of rendered.lines) {
-                            appendRow({
-                                id: deps.rowIds.value,
-                                kind: 'local-output',
-                                text: preview(String(line), LOCAL_OUTPUT_LIMIT),
-                            });
-                            deps.rowIds.value += 1;
-                        }
-                    }
-                }
-                break;
-        }
-    };
-    function reset() {
-        streaming = undefined;
-        reasoning = undefined;
-        sealedReasoning.length = 0;
-        lastReasoningRow = undefined;
-        toolCards.clear();
-        askCalls.clear();
-        handledAssistantMessages.clear();
-        handledAssistantChunks.clear();
-        openStep = undefined;
-        activeAttempt = undefined;
-        lastStreamRevision = -1;
-        eventModel = undefined;
-        assistantRowsByStep.clear();
-        lastTextDelta.clear();
-        tpsTurn = undefined;
-        tpsStep = undefined;
-        tpsTurnDecodeMs = 0;
-        tpsTurnDecodeTokens = 0;
-        tpsTurnSampled = false;
-    }
-    return { reset, replayEvents, renderEvent, renderStreamFrame, settleStreaming, updateSpinnerMode, presentCallView, presentResultView, textOf, firstTextOf };
 }