@aragon-agent/cli 0.6.47 → 0.6.48

package/dist/agent/reducer.js

@@ -1,1646 +0,0 @@
-/**
- * Pure event → view reducer (spec §3.4 / §6.2).
- *
- * `reduceEvent(event)` maps a raw core `AgentEvent` into zero or more view
- * actions; `viewReducer(state, action)` folds an action into the immutable
- * `ViewState`. Keeping this pure lets the whole UI be tested without a live LLM.
- *
- * Two load-bearing behaviors from R2 (silent-failure surfacing) live here:
- *   - the `error` StreamEvent is rendered as an error notice, and
- *   - `agent_end` after a turn that produced no `turn_end` and no error notice
- *     synthesizes a generic error notice (a swallowed throw is never a no-op).
- */
-import process from 'node:process';
-import { reconcileSteeringReceipt } from './queued-messages.js';
-import { emptyContextUsage } from '../compaction/meter.js';
-import { addUsage, computeCost } from './usage.js';
-import { ENTRY_LIMITS, appendBounded, entryRetain, trimEntries } from './entry-limits.js';
-import { isGovernedDispatch } from '../governance/governed-dispatch.js';
-import { adoptPosture, foldGovernanceSnapshot } from './governance-view.js';
-/** Default auto-dismiss window for a toast. */
-export const DEFAULT_TOAST_TTL_MS = 2500;
-/**
- * The zero session total.
- *
- * ONE LITERAL FOR TWO SITES (`initialViewState` and `resetConversation`). They
- * used to spell the object out twice, which is how `cacheReadTokens` would have
- * been added to one of them and not the other.
- */
-export const EMPTY_USAGE_TOTAL = {
-    inputTokens: 0,
-    outputTokens: 0,
-    cacheReadTokens: 0,
-    cacheWriteTokens: 0,
-    costUsd: 0,
-};
-/**
- * The initial view state, optionally seeded from config.
- *
- * THE DEFAULT IS `false`, NOT `true`, AND THAT IS THE WHOLE SAFETY ARGUMENT
- * (D-2). There is exactly one production call site — `App`'s `useReducer`, which
- * passes `cfg.showThinking`. Every other caller is a test. A future call site
- * that forgets the seed fails CLOSED, toward the product default, rather than
- * silently restoring the reasoning firehose for one code path with nothing
- * reporting it.
- *
- * The seed is a PARAMETER rather than a post-mount dispatch so that `/resume`
- * cannot flash a restored thinking block on frame 1.
- */
-export function initialViewState(seed = {}) {
-    return {
-        entries: [],
-        pendingSteering: [],
-        seenSteeringIds: new Set(),
-        runPhase: 'idle',
-        runOutcome: 'none',
-        status: 'idle',
-        usageTotal: EMPTY_USAGE_TOTAL,
-        context: emptyContextUsage(),
-        overlay: null,
-        thinkingVisible: seed.thinkingVisible ?? false,
-        toasts: [],
-        expandedToolIds: {},
-        // Seeded to the default posture; the App overrides it once on mount from
-        // `controller.getAgentMode()` so `--plan` renders on the first frame.
-        agentMode: 'build',
-        pendingAgentMode: null,
-        posture: 'build',
-        pendingPosture: null,
-        governance: null,
-        team: null,
-        todos: null,
-        retry: null,
-        fast: null,
-        compaction: null,
-        taskSummary: null,
-        taskSummaryPending: false,
-        seq: 0,
-        teamEntryId: undefined,
-        todoEntryId: undefined,
-        retryEntryId: undefined,
-        fastEntryId: undefined,
-        compactionEntryId: undefined,
-        streamingId: undefined,
-        turnProduced: false,
-        errorNoticed: false,
-        aborted: false,
-        droppedEntries: 0,
-    };
-}
-// ---------------------------------------------------------------------------
-// Event → actions
-// ---------------------------------------------------------------------------
-// Stored preview caps (spec §3.7 / P1-3). Raised from 16 / 800 so a `Ctrl+O`
-// expansion can actually reveal lines 9…200 and the bash `[exit code N]` footer
-// survives ≥16-line output. The *collapsed* view still shows only 8 lines
-// (COLLAPSED_LINES in ToolCard).
-export const STORED_PREVIEW_CHARS = 8000;
-export const STORED_PREVIEW_LINES = 200;
-/**
- * Marker appended to a truncated tool preview. ASCII on purpose: this string is
- * produced outside `src/ui/**`, where no terminal capabilities are available, so
- * it must be safe on a legacy `cmd.exe` (spec §4.1 tier A). `ToolPreview` dims
- * this line and imports the constant rather than re-spelling it — the two used
- * to be a matched pair of `…` literals, and splitting the spelling would break
- * the dimming silently.
- */
-export const PREVIEW_TRUNCATION_MARK = '...';
-/**
- * Flatten a ToolResult into a stored preview string. Truncation appends
- * `PREVIEW_TRUNCATION_MARK` (line- or char-based) so a card footer never
- * over-promises how much more is expandable.
- */
-export function buildToolPreview(result) {
-    const text = result.content
-        .map((c) => (c.type === 'text' ? c.text : `[image: ${c.mediaType}]`))
-        .join('\n');
-    const allLines = text.split('\n');
-    const lines = allLines.slice(0, STORED_PREVIEW_LINES);
-    let preview = lines.join('\n');
-    const lineTruncated = allLines.length > STORED_PREVIEW_LINES;
-    if (preview.length > STORED_PREVIEW_CHARS) {
-        preview = `${preview.slice(0, STORED_PREVIEW_CHARS)}${PREVIEW_TRUNCATION_MARK}`;
-    }
-    else if (lineTruncated) {
-        preview = `${preview}\n${PREVIEW_TRUNCATION_MARK}`;
-    }
-    return preview;
-}
-/** The first line of a stored preview, without its trailing newline. */
-function firstLine(text) {
-    const at = text.indexOf('\n');
-    return at === -1 ? text : text.slice(0, at);
-}
-/**
- * Map one core `AgentEvent` to view actions. `cost` (the active model's cost
- * table) lets `turn_end` accumulate USD cost; omit it in tests that only assert
- * token totals. `patches` is the CLI-local diff side channel (§3.3.7); omitting
- * it — every existing test, and headless mode — produces byte-identical actions.
- */
-export function reduceEvent(event, cost, patches) {
-    switch (event.type) {
-        case 'steering_accepted':
-            return [{ type: 'steeringAccepted', ids: event.ids }];
-        case 'agent_start':
-            return [{ type: 'runStart' }];
-        case 'turn_start':
-            return [{ type: 'turnStart' }];
-        case 'turn_end':
-            return [
-                {
-                    type: 'turnEnd',
-                    usage: event.usage,
-                    costDelta: computeCost(event.usage, cost),
-                },
-            ];
-        case 'agent_end':
-            return [{ type: 'runEnd' }];
-        case 'tool_execution_start':
-            return [{ type: 'toolExecStart', toolCallId: event.toolCallId, toolName: event.toolName }];
-        case 'tool_execution_end': {
-            const patch = patches?.take(event.toolCallId);
-            const preview = buildToolPreview(event.result);
-            return [
-                {
-                    type: 'toolExecEnd',
-                    toolCallId: event.toolCallId,
-                    isError: event.isError,
-                    duration: event.duration,
-                    // AN ENTRY CARRIES A PATCH OR A FULL PREVIEW, NEVER BOTH (D-19). This
-                    // is not a budget compromise, it is deleting a duplicate: `ToolCard`
-                    // renders `DiffView` INSTEAD of `ToolPreview` when a patch exists, so
-                    // the stored preview is never drawn on that card — and for `edit_file`
-                    // it is literally the same diff, as text. Keeping the first line
-                    // preserves the one thing outside `DiffView` that still reads it,
-                    // `entryRevision`'s `preview?.length` term.
-                    preview: patch ? firstLine(preview) : preview,
-                    ...(patch ? { patch } : {}),
-                },
-            ];
-        }
-        case 'message_update':
-            return reduceStreamEvent(event.streamEvent);
-        case 'code_execution_start':
-        case 'code_execution_end':
-            // CodeAct sandbox is off by default; no dedicated view surface in v1.
-            return [];
-        default:
-            return [];
-    }
-}
-/**
- * Tools that render their own transcript entry, so the generic tool card would
- * be a duplicate. `task` is the second member (F-8 A'3): every dispatch opens
- * a TeamCard immediately after, so the pair read as TWO dispatches - the first
- * failed, the second succeeded - when there was only ever one. `todo_write`'s
- * reasons (todo-plan-execution §3.8 / D-10) carry over unchanged.
- *
- * SUPPRESSING ONLY `tool_call_start` IS SUFFICIENT, AND THAT IS THE WHOLE REASON
- * THIS IS SAFE (D-10). Every later handler — `toolCallDelta` / `toolCallEnd` /
- * `toolExecStart` / `toolExecEnd` — resolves its target through
- * `findToolEntryId`, which returns `undefined` when no entry was created, and
- * every one of them already early-returns on that. There is no fifth handler.
- * Blast radius verified: headless and `exec` writers key on EVENTS, not tool
- * names, and `transcript-text` renders `kind:'team'` on its own.
- */
-const SELF_RENDERING_TOOLS = new Set(['todo_write', 'task']);
-function reduceStreamEvent(se) {
-    switch (se.type) {
-        case 'thinking_start':
-            return [{ type: 'thinkingStart' }];
-        case 'thinking_delta':
-            return [{ type: 'thinkingDelta', delta: se.delta }];
-        case 'text_delta':
-            return [{ type: 'textDelta', delta: se.delta }];
-        case 'tool_call_start':
-            return [
-                { type: 'toolCallStart', toolCallId: se.toolCallId, toolName: se.toolName },
-            ];
-        case 'tool_call_delta':
-            return [
-                { type: 'toolCallDelta', toolCallId: se.toolCallId, argsDelta: se.argsDelta },
-            ];
-        case 'tool_call_end':
-            return [{ type: 'toolCallEnd', toolCallId: se.toolCallId, args: se.args }];
-        case 'error':
-            return [
-                { type: 'runError' },
-                {
-                    type: 'notice',
-                    level: 'error',
-                    text: formatStreamError(se.error),
-                },
-            ];
-        case 'done':
-            // Authoritative usage is redundant with `turn_end`; nothing to add.
-            return [];
-        // --- API retry (llm-api-retry-backoff §6.4) ---------------------------
-        case 'retry_scheduled':
-            return [
-                {
-                    type: 'retryScheduled',
-                    attempt: se.attempt,
-                    maxRetries: se.maxRetries,
-                    delayMs: se.delayMs,
-                    resumeAt: se.resumeAt,
-                    errorType: se.errorType,
-                    message: se.message,
-                },
-            ];
-        case 'retry_attempt':
-            return [{ type: 'retryAttempt', attempt: se.attempt, maxRetries: se.maxRetries }];
-        case 'stream_restart':
-            return [{ type: 'streamRestart', discardedToolCallIds: se.discardedToolCallIds }];
-        default:
-            return [];
-    }
-}
-/**
- * The opening words of the `context_overflow` banner.
- *
- * A SHARED CONSTANT RATHER THAN TWO LITERALS, because `compactionStart` matches
- * on it to rewrite the notice a successful reactive recovery would otherwise
- * leave behind (P1-4). Two spellings that must agree, with nothing checking that
- * they do, is how that rewrite silently stops matching — at which point the red
- * "start over" banner comes back and only on the recovery path, which is the one
- * place nobody re-tests.
- */
-export const CONTEXT_OVERFLOW_NOTICE_PREFIX = 'Context length exceeded';
-/** Turn a provider error into a friendly banner, mapping LLMError.errorType. */
-export function formatStreamError(error) {
-    const errorType = error.errorType;
-    const base = error.message || 'Unknown error';
-    switch (errorType) {
-        case 'auth_error':
-            return `Authentication failed - check your API key. (${base})`;
-        case 'rate_limit':
-            return `Rate limited by the provider - please retry shortly. (${base})`;
-        case 'overloaded':
-            return `Provider overloaded - please retry shortly. (${base})`;
-        case 'context_overflow':
-            // `/compact` IS NAMED FIRST, and adding it is the second half of P1-4's
-            // fix. This remedy list predates context compaction and was, until it
-            // existed, complete: throwing the conversation away really was the only
-            // exit. It is not any more, and a banner that offers only `/reset` now
-            // tells the user to discard a session the very next line of code may be
-            // about to save.
-            return `${CONTEXT_OVERFLOW_NOTICE_PREFIX} - try /compact, or start over with /reset. (${base})`;
-        case 'network_error':
-            return `Network error reaching the provider. (${base})`;
-        case 'timeout':
-            return `The request timed out. (${base})`;
-        default:
-            return base;
-    }
-}
-// ---------------------------------------------------------------------------
-// Reducer
-// ---------------------------------------------------------------------------
-const GENERIC_RUN_FAILURE = 'The run ended without producing a response - check your API key, model, and network.';
-function nextId(state) {
-    const seq = state.seq + 1;
-    return { id: `e${seq}`, seq };
-}
-function mapEntry(entries, id, fn) {
-    return entries.map((e) => (e.id === id ? fn(e) : e));
-}
-/**
- * Seal `thinkingMs`, once, as a spreadable patch (§3.1.2).
- *
- * Returns an EMPTY object when there is nothing to seal — no reasoning happened,
- * or the clock has already stopped — so the three call sites can spread it
- * unconditionally and none of them can re-seal a settled duration.
- */
-function sealThinkingMs(entry) {
-    if (entry.thinkingStartedAt === undefined || entry.thinkingMs !== undefined)
-        return {};
-    return { thinkingMs: Math.max(0, Date.now() - entry.thinkingStartedAt) };
-}
-/**
- * Append one entry and ring-trim the result (tui-render-performance L1).
- *
- * TRIMMING HAPPENS ONLY AT APPEND POINTS, and that is the whole reason this is a
- * helper rather than a line in `viewReducer`. A mid-turn trim triggered by an
- * UPDATE action could drop the entry `streamingId` / `teamEntryId` /
- * `todoEntryId` points at while it is still being written to; appending is the
- * only moment at which the tail is by definition the newest thing.
- *
- * I-L1-1 — the trim must never drop a live target. With `retain >= 200` and a
- * trim that only ever removes from the head this is structurally true, but a
- * future clamp change would break it SILENTLY (the `mapEntry` calls would simply
- * stop matching), so development builds assert it.
- */
-function appendEntry(state, entries, entry) {
-    const trimmed = trimEntries([...entries, entry], entryRetain());
-    if (trimmed.dropped > 0 && process.env.NODE_ENV !== 'production') {
-        // `retryEntryId` IS PART OF THIS LIST. A fourth live card that is not in it is
-        // a fourth card I-L1-1 does not cover — the trim would silently turn its
-        // `mapEntry` into a no-op instead of failing loudly.
-        const live = [
-            state.streamingId,
-            state.teamEntryId,
-            state.todoEntryId,
-            state.retryEntryId,
-            // `fastEntryId` IS PART OF THIS LIST for the reason the note above gives:
-            // a fifth live card left out of it is a card I-L1-1 does not cover.
-            state.fastEntryId,
-            // And `compactionEntryId` is the sixth. Same reason, and it is the one
-            // whose absence would be hardest to notice: a compaction card is rare, so
-            // a `mapEntry` that silently stopped matching would be found by a user
-            // rather than by a test.
-            state.compactionEntryId,
-        ].filter((id) => typeof id === 'string');
-        for (const id of live) {
-            if (!trimmed.entries.some((e) => e.id === id)) {
-                throw new Error(`trimEntries dropped a live entry (${id}) - see I-L1-1`);
-            }
-        }
-    }
-    return {
-        entries: trimmed.entries,
-        droppedEntries: state.droppedEntries + trimmed.dropped,
-    };
-}
-/**
- * Settle the turn's retry card, if it has one (llm-api-retry-backoff §6.4).
- *
- * SETTLING IS DERIVED HERE, NOT SENT BY CORE. Core knows it scheduled a retry; it
- * does not know whether the turn eventually succeeded, was interrupted, or ran out
- * of budget — that is the consumer's own timeline.
- *
- * FOUR PATHS REACH THIS, and the fourth is what makes the set exhaustive rather
- * than enumerated: `turnEnd` (recovered), an error `notice` (exhausted),
- * `abortMark` (interrupted) and `runEnd` (interrupted). The rule is "every path
- * that reaches `status: 'idle'` settles the card", because a card left at
- * `phase: 'waiting'` pins `Transcript`'s MONOTONIC settled boundary and re-renders
- * the tail every frame for the rest of the session (R-10).
- *
- * Returning `retry: null` / `retryEntryId: undefined` unconditionally is
- * deliberate: both are already that when there is no card, so every caller can
- * spread the result without a branch of its own.
- */
-function settleRetryCard(state, entries, phase) {
-    if (!state.retryEntryId)
-        return { entries, retry: null, retryEntryId: undefined };
-    const now = Date.now();
-    return {
-        entries: mapEntry(entries, state.retryEntryId, (e) => e.kind === 'retry'
-            ? {
-                ...e,
-                phase,
-                totalRetries: e.attempt,
-                elapsedMs: Math.max(0, now - e.startedAt),
-                resumeAt: undefined,
-            }
-            : e),
-        retry: null,
-        retryEntryId: undefined,
-    };
-}
-function releaseLiveTails(entries) {
-    let touched = false;
-    const next = entries.map((e) => {
-        // `!e.live && !e.wait`, NOT `!e.live` (extended-job-wait RV-2): a `job_wait`
-        // never streams, so its `live` is always empty and the old guard would skip it,
-        // leaving a wait card that says "running" in the transcript forever.
-        if (e.kind !== 'tool' || (!e.live && !e.wait))
-            return e;
-        if (e.status !== 'running' && e.status !== 'pending')
-            return e;
-        touched = true;
-        return {
-            ...e,
-            live: undefined,
-            lastOutputAt: undefined,
-            liveSeq: (e.liveSeq ?? 0) + 1,
-            wait: undefined,
-            waitSeq: (e.waitSeq ?? 0) + 1,
-        };
-    });
-    return touched ? next : entries;
-}
-/**
- * Drop settled assistant entries that render nothing at all (defect 5).
- *
- * `turnStart` ALWAYS creates an entry, so a turn that only called a tool leaves a
- * bubble behind that `AssistantEntry` then refuses to draw. A rendered absence is
- * not the same thing as an absent entry: `virtual-window.ts:305` still estimates a
- * row for it (two when `aborted`, and nothing draws the second), and `/save`
- * exports a blank bubble. Settle is the only safe moment to prune — before it the
- * entry is still the target of every `textDelta` / `thinkingDelta`.
- *
- * I-L1-1 — `streamingId` COMES BACK WITH THE ARRAY. If the dropped entry is the
- * one that id pointed at, the id is cleared: leaving it set would point the whole
- * reducer at an entry no `mapEntry` can ever match again, silently, because a
- * `mapEntry` on a missing id is a no-op. `turnEnd` and `runEnd` clear the id
- * themselves; `abortMark` does not, which is why the caller writes this back.
- *
- * Returns the SAME array when nothing was dropped, so every settled entry keeps
- * its identity and `EntryView`'s memo boundary stays intact.
- */
-function pruneEmptyAssistant(entries, streamingId) {
-    const isEmptySettledAssistant = (entry) => entry.kind === 'assistant' &&
-        !entry.streaming &&
-        entry.text.trim() === '' &&
-        (entry.thinking ?? '').trim() === '';
-    const kept = entries.filter((entry) => !isEmptySettledAssistant(entry));
-    if (kept.length === entries.length)
-        return { entries, streamingId };
-    const liveGone = streamingId !== undefined && !kept.some((entry) => entry.id === streamingId);
-    return { entries: kept, streamingId: liveGone ? undefined : streamingId };
-}
-function findToolEntryId(state, toolCallId) {
-    for (let i = state.entries.length - 1; i >= 0; i -= 1) {
-        const e = state.entries[i];
-        if (e && e.kind === 'tool' && e.toolCallId === toolCallId)
-            return e.id;
-    }
-    return undefined;
-}
-/** Runtime facts outlive transcript cards and are independent of command/clipboard notices. */
-function reduceRunFacts(state, action) {
-    switch (action.type) {
-        case 'runStarting': return { ...state, runPhase: 'starting', runOutcome: 'none' };
-        case 'runStart': return { ...state, runPhase: 'waiting', runOutcome: 'none', activeTool: undefined };
-        case 'turnStart': return { ...state, runPhase: 'waiting' };
-        case 'thinkingStart':
-        case 'thinkingDelta': return { ...state, runPhase: 'thinking' };
-        case 'textDelta': return { ...state, runPhase: 'generating' };
-        case 'toolCallStart':
-        case 'toolCallDelta':
-        case 'toolCallEnd': return { ...state, runPhase: 'preparing-tool' };
-        case 'toolExecStart': {
-            const card = state.entries.find((entry) => entry.kind === 'tool' && entry.toolCallId === action.toolCallId);
-            return { ...state, runPhase: 'tool', activeTool: {
-                    toolCallId: action.toolCallId,
-                    name: action.toolName ?? (card?.kind === 'tool' ? card.name : 'tool'),
-                } };
-        }
-        case 'toolExecEnd': return state.activeTool?.toolCallId === action.toolCallId
-            ? { ...state, runPhase: 'waiting', activeTool: undefined } : state;
-        case 'runError': return { ...state, runOutcome: 'failed' };
-        case 'abortMark': return { ...state, runOutcome: 'interrupted' };
-        case 'runEnd': return { ...state, runPhase: 'idle', activeTool: undefined,
-            runOutcome: state.runOutcome !== 'none' ? state.runOutcome
-                : !state.turnProduced && !state.errorNoticed && !state.aborted ? 'failed' : 'ended' };
-        case 'resetConversation':
-        case 'restoreEntries': return { ...state, runPhase: 'idle', activeTool: undefined,
-            runOutcome: 'none', seenSteeringIds: new Set() };
-        default: return state;
-    }
-}
-export function viewReducer(state, action) {
-    state = reduceRunFacts(state, action);
-    switch (action.type) {
-        case 'submit': {
-            const { id, seq } = nextId(state);
-            const entry = {
-                id, kind: 'user', text: action.text,
-                ...(action.invocation ? { invocation: action.invocation } : {}),
-            };
-            return {
-                ...state,
-                seq,
-                ...appendEntry(state, state.entries, entry),
-                streamingId: undefined,
-                // A new turn gets its own card, in that turn's position in the
-                // transcript. The PREVIOUS card stays exactly where it is — it is
-                // history, and history is not retracted.
-                todoEntryId: undefined,
-                // Same rule for the retry card. `runStart` clears NONE of the three (it
-                // never has), and `runEnd`'s settle rule below is what makes that safe
-                // rather than merely lucky.
-                retryEntryId: undefined,
-                turnProduced: false,
-                errorNoticed: false,
-                aborted: false,
-            };
-        }
-        case 'steerQueued': {
-            if (state.seenSteeringIds.has(action.queueId))
-                return state;
-            const { id, seq } = nextId(state);
-            const entry = {
-                id, kind: 'queued', queueId: action.queueId, text: action.text,
-                ...(action.invocation ? { invocation: action.invocation } : {}),
-            };
-            // NOTHING ELSE RESETS. This is not a new turn -- `turnProduced`,
-            // `errorNoticed` and `aborted` describe the run that is still in
-            // flight, and clearing them here would let the next `runEnd` failure
-            // guard misfire on a turn that produced plenty.
-            return {
-                ...state, seq, ...appendEntry(state, state.entries, entry),
-                seenSteeringIds: new Set([...state.seenSteeringIds, action.queueId]),
-                pendingSteering: [...state.pendingSteering, {
-                        queueId: action.queueId, text: action.text,
-                        ...(action.invocation ? { invocation: action.invocation } : {}),
-                    }],
-            };
-        }
-        case 'steeringAccepted': {
-            const receipt = reconcileSteeringReceipt({
-                entries: state.entries, pending: state.pendingSteering, ids: action.ids,
-            });
-            if (!receipt.changed)
-                return state;
-            const trimmed = trimEntries(receipt.entries, entryRetain());
-            return { ...state, pendingSteering: receipt.pending, entries: trimmed.entries,
-                droppedEntries: state.droppedEntries + trimmed.dropped };
-        }
-        case 'runStart':
-            return {
-                ...state,
-                status: 'running',
-                turnProduced: false,
-                errorNoticed: false,
-                aborted: false,
-            };
-        case 'turnStart': {
-            const { id, seq } = nextId(state);
-            const entry = {
-                id,
-                kind: 'assistant',
-                text: '',
-                thinking: undefined,
-                thinkingOpen: false,
-                streaming: true,
-            };
-            return { ...state, seq, ...appendEntry(state, state.entries, entry), streamingId: id };
-        }
-        case 'thinkingStart': {
-            if (!state.streamingId)
-                return state;
-            return {
-                ...state,
-                entries: mapEntry(state.entries, state.streamingId, (e) => e.kind === 'assistant'
-                    ? {
-                        ...e,
-                        thinking: e.thinking ?? '',
-                        thinkingOpen: true,
-                        // `Date.now()` in the reducer is not a new impurity class: the
-                        // retry card's `startedAt` already reads the clock here.
-                        thinkingStartedAt: e.thinkingStartedAt ?? Date.now(),
-                    }
-                    : e),
-            };
-        }
-        case 'thinkingDelta': {
-            if (!state.streamingId)
-                return state;
-            return {
-                ...state,
-                entries: mapEntry(state.entries, state.streamingId, (e) => e.kind === 'assistant'
-                    ? { ...e, thinking: appendBounded(e.thinking ?? '', action.delta, ENTRY_LIMITS.thinking) }
-                    : e),
-            };
-        }
-        case 'textDelta': {
-            if (!state.streamingId)
-                return state;
-            return {
-                ...state,
-                entries: mapEntry(state.entries, state.streamingId, (e) => e.kind === 'assistant'
-                    ? {
-                        ...e,
-                        text: appendBounded(e.text, action.delta, ENTRY_LIMITS.text),
-                        // FIRST TEXT DELTA ONLY. Thinking is over the moment the answer
-                        // starts; re-sealing on every delta would make the number climb
-                        // with the answer's length.
-                        ...sealThinkingMs(e),
-                    }
-                    : e),
-            };
-        }
-        case 'toolCallStart': {
-            if (SELF_RENDERING_TOOLS.has(action.toolName))
-                return state;
-            const { id, seq } = nextId(state);
-            const entry = {
-                id,
-                kind: 'tool',
-                toolCallId: action.toolCallId,
-                name: action.toolName,
-                label: action.label ?? action.toolName,
-                argsRaw: '',
-                status: 'pending',
-            };
-            return { ...state, seq, ...appendEntry(state, state.entries, entry) };
-        }
-        case 'toolCallDelta': {
-            const id = findToolEntryId(state, action.toolCallId);
-            if (!id)
-                return state;
-            return {
-                ...state,
-                entries: mapEntry(state.entries, id, (e) => e.kind === 'tool'
-                    ? { ...e, argsRaw: appendBounded(e.argsRaw, action.argsDelta, ENTRY_LIMITS.argsRaw) }
-                    : e),
-            };
-        }
-        case 'toolCallEnd': {
-            const id = findToolEntryId(state, action.toolCallId);
-            if (!id)
-                return state;
-            return {
-                ...state,
-                entries: mapEntry(state.entries, id, (e) => e.kind === 'tool'
-                    ? { ...e, args: action.args, argsRaw: safeStringify(action.args) }
-                    : e),
-            };
-        }
-        case 'toolExecStart': {
-            const id = findToolEntryId(state, action.toolCallId);
-            if (!id)
-                return state;
-            return {
-                ...state,
-                entries: mapEntry(state.entries, id, (e) => e.kind === 'tool' ? { ...e, status: 'running' } : e),
-            };
-        }
-        /**
-         * THE STATUS GUARD IS WHAT KEEPS A LATE CHUNK FROM RESURRECTING A SETTLED
-         * CARD. The child's last write and its `close` event race, so a chunk can
-         * legitimately arrive after `tool_execution_end`; without the guard it would
-         * reattach a tail to a card whose authoritative preview is already drawn.
-         */
-        case 'toolOutputDelta': {
-            const id = findToolEntryId(state, action.toolCallId);
-            if (!id)
-                return state;
-            return {
-                ...state,
-                entries: mapEntry(state.entries, id, (e) => e.kind === 'tool' && (e.status === 'running' || e.status === 'pending')
-                    ? {
-                        ...e,
-                        live: action.rows,
-                        liveSeq: (e.liveSeq ?? 0) + 1,
-                        lastOutputAt: action.at,
-                    }
-                    : e),
-            };
-        }
-        /**
-         * ONLY A RUNNING, MATCHING ENTRY. `begin` travels from the controller and can
-         * beat `tool_execution_start` through the agent-event pipe, so a miss is
-         * normal and is dropped on purpose: the next 1 Hz beat repairs it (RV-5).
-         */
-        case 'waitUpdate': {
-            const id = findToolEntryId(state, action.toolCallId);
-            if (!id)
-                return state;
-            const target = state.entries.find((e) => e.id === id);
-            if (!target || target.kind !== 'tool' || target.status !== 'running')
-                return state;
-            return {
-                ...state,
-                entries: mapEntry(state.entries, id, (e) => e.kind === 'tool' ? { ...e, wait: action.view, waitSeq: (e.waitSeq ?? 0) + 1 } : e),
-            };
-        }
-        case 'toolExecEnd': {
-            const id = findToolEntryId(state, action.toolCallId);
-            if (!id)
-                return state;
-            return {
-                ...state,
-                entries: mapEntry(state.entries, id, (e) => e.kind === 'tool'
-                    ? {
-                        ...e,
-                        status: action.isError ? 'error' : 'done',
-                        isError: action.isError,
-                        durationMs: action.duration,
-                        preview: action.preview,
-                        ...(action.patch ? { patch: action.patch } : {}),
-                        // THE TAIL IS NEVER MERGED INTO `preview` (D-23): the
-                        // authoritative result already contains everything it held, in
-                        // full, and concatenating them would double the output and break
-                        // `bashBadge`'s last-line parse (`ToolPreview.tsx:35-54`).
-                        live: undefined,
-                        lastOutputAt: undefined,
-                        wait: undefined,
-                        waitSeq: undefined,
-                    }
-                    : e),
-            };
-        }
-        case 'turnEnd': {
-            const entries = state.streamingId
-                ? mapEntry(state.entries, state.streamingId, (e) => e.kind === 'assistant'
-                    ? {
-                        ...e,
-                        streaming: false,
-                        thinkingOpen: false,
-                        usage: action.usage,
-                        // The turn that thought and then called a tool without emitting
-                        // any text never saw a `textDelta`, so this is where its clock
-                        // is sealed.
-                        ...sealThinkingMs(e),
-                    }
-                    : e)
-                : state.entries;
-            return {
-                ...state,
-                streamingId: undefined,
-                turnProduced: true,
-                // `contextTokens` IS NOT WRITTEN HERE ANY MORE (I-1). The occupancy this
-                // turn produced reaches the view through `ContextMeter`, which subscribes
-                // to the same `turn_end` and publishes the measured pressure - window,
-                // percentage and approximation markers included, none of which this
-                // branch ever had. Two branches writing one number is what P0-1 was.
-                usageTotal: addUsage(state.usageTotal, action.usage, action.costDelta),
-                // The turn produced an answer, so whatever it had to retry, it recovered.
-                // Defect 5: prune AFTER the mapEntry above has settled the entry, so an
-                // assistant bubble this turn never filled in is gone before the retry card
-                // is settled and before the height table ever sees it.
-                ...settleRetryCard(state, pruneEmptyAssistant(entries, state.streamingId).entries, 'recovered'),
-            };
-        }
-        case 'runEnd': {
-            // Finalize any still-streaming entry.
-            let entries = state.streamingId
-                ? mapEntry(state.entries, state.streamingId, (e) => e.kind === 'assistant' ? { ...e, streaming: false, ...sealThinkingMs(e) } : e)
-                : state.entries;
-            /*
-             * Defect 5, and BEFORE the silent-failure guard below so the guard and the
-             * retry settle both see the pruned array. `streamingId: undefined` is set in
-             * the returned state either way, so the returned id is not needed here.
-             */
-            entries = pruneEmptyAssistant(entries, state.streamingId).entries;
-            let seq = state.seq;
-            let droppedEntries = state.droppedEntries;
-            // Silent-failure guard (R2): a swallowed throw shows nothing otherwise.
-            // A user abort is an expected empty run, not a failure — skip the guard.
-            if (!state.turnProduced && !state.errorNoticed && !state.aborted) {
-                const next = nextId({ ...state, seq });
-                seq = next.seq;
-                const appended = appendEntry(state, entries, {
-                    id: next.id,
-                    kind: 'notice',
-                    level: 'error',
-                    text: GENERIC_RUN_FAILURE,
-                });
-                entries = appended.entries;
-                droppedEntries = appended.droppedEntries;
-            }
-            // The card may now reach `<Static>` (C-5 / I-6): the turn that owns it is
-            // over, so nothing will rewrite it.
-            if (state.todoEntryId) {
-                entries = mapEntry(entries, state.todoEntryId, (e) => e.kind === 'todo' ? { ...e, live: false } : e);
-            }
-            return {
-                ...state,
-                seq,
-                droppedEntries,
-                status: 'idle',
-                streamingId: undefined,
-                // THE TERMINAL BACKSTOP, and it is not redundant with `abortMark`
-                // (llm-api-retry-backoff P1-8 / AC-25b). `abortMark` is dispatched only
-                // from the Esc handler, but the ENGINE also aborts itself: the idle
-                // watchdog calls `Agent.abort()` directly, the run unwinds, and the UI
-                // sees `agent_end` -> `runEnd` with no `abortMark`, no `turn_end` and no
-                // error notice. A card left at `phase: 'waiting'` then pins
-                // `Transcript`'s monotonic boundary and re-renders the tail every frame
-                // for the rest of the session. By the time this runs the three other
-                // settle paths have already cleared `retryEntryId`, so this only fires on
-                // a genuinely unsettled card.
-                //
-                // `releaseLiveTails` rides the same argument one entry kind over (D-35):
-                // a tool card stranded at `running` by this very path would otherwise
-                // keep a tail and a frozen stall clock for the rest of the session.
-                ...settleRetryCard(state, releaseLiveTails(entries), 'interrupted'),
-            };
-        }
-        case 'notice': {
-            const { id, seq } = nextId(state);
-            const entry = { id, kind: 'notice', level: action.level, text: action.text };
-            const appended = appendEntry(state, state.entries, entry);
-            // A terminal error notice is what an EXHAUSTED ladder looks like from here:
-            // the retry wrapper forwards the provider's own error once it stops
-            // retrying, and that error always precedes any `turn_end` because a failed
-            // turn has none. A non-error notice leaves the card alone.
-            const settled = action.level === 'error'
-                ? settleRetryCard(state, appended.entries, 'exhausted')
-                : { entries: appended.entries };
-            return {
-                ...state,
-                seq,
-                droppedEntries: appended.droppedEntries,
-                errorNoticed: action.level === 'error' ? true : state.errorNoticed,
-                ...settled,
-            };
-        }
-        case 'abortMark': {
-            // Mark the run aborted even when no assistant entry is streaming (e.g. an
-            // abort during a tool call) so the runEnd failure guard stays suppressed.
-            const marked = state.streamingId
-                ? mapEntry(state.entries, state.streamingId, (e) => e.kind === 'assistant' ? { ...e, streaming: false, aborted: true } : e)
-                : state.entries;
-            // Defect 5 / I-L1-1: prune AFTER the entry is settled, and write the
-            // returned id back below -- `abortMark` is the one settle path that does
-            // NOT clear `streamingId`, so a prune without that write-back would leave
-            // it naming an entry this branch has just removed.
-            const pruned = pruneEmptyAssistant(marked, state.streamingId);
-            return {
-                ...state,
-                aborted: true,
-                streamingId: pruned.streamingId,
-                // An abort during a tool call is the COMMON way a tail is stranded --
-                // `Esc` while `npm test` runs -- so this is the clause manual row 9
-                // exercises (D-35 / AC-40).
-                ...settleRetryCard(state, releaseLiveTails(pruned.entries), 'interrupted'),
-            };
-        }
-        // `teamEntryId` is dropped with the entries it pointed at. Keeping it would
-        // leave `teamUpdate` mapping an id that no longer exists — harmless today,
-        // and a dangling reference the next reader has to reason about.
-        case 'clearTranscript':
-            return {
-                ...state,
-                entries: [],
-                // The count describes what the RETAIN RING removed from the visible
-                // transcript. `/clear screen` empties it by intent, so carrying the number
-                // over would make the exported transcript claim a loss that did not
-                // happen.
-                droppedEntries: 0,
-                streamingId: undefined,
-                expandedToolIds: {},
-                teamEntryId: undefined,
-                // The list goes with the screen it was on. `/clear screen` is an explicit
-                // user instruction, which is I-2's standing exception (`TodoClearReason`
-                // `'user'`, the same door `/todo clear` uses) - so the command clears the
-                // STORE via `controller.clearTodos()` and this clears the MIRROR, exactly
-                // the pairing `resetConversation` below has always had.
-                //
-                // The mirror write is same-valued with the store's own `todoCleared`
-                // dispatch rather than redundant with it: it is what makes this action
-                // stand on its own. `commands/clear-command.ts` is its only dispatcher
-                // TODAY - `/clear` itself now goes through `resetConversation`, because
-                // clearing the SCREEN and clearing the SESSION are different intentions
-                // (clear-command-context-reset D-3) - and a hypothetical second one would
-                // otherwise bring the bug back in identical form and in silence.
-                //
-                // KEPT RATHER THAN FOLDED INTO `resetConversation` for the same reason:
-                // a user who wants the screen back must not have to destroy their context
-                // to get it, and an action with no dispatcher is dead code by `CLAUDE.md`
-                // section 4 - which is what `/clear screen` prevents.
-                //
-                // The entry id is dropped because the entry it pointed at is gone.
-                todos: null,
-                todoEntryId: undefined,
-                // Same reasoning for the retry card: the entry is gone, so the id must go
-                // with it or `retryScheduled` would `mapEntry` an id that no longer
-                // exists. `retry` goes too — unlike `todos` it is not a belief the model
-                // holds, it is a projection of an entry that has just been erased.
-                retryEntryId: undefined,
-                retry: null,
-                // Same reasoning again for the compaction card: the entry is gone, so the
-                // id must go with it or `compactionEnd` would `mapEntry` an id that no
-                // longer exists. `compaction` STAYS — unlike `retry` it is not a
-                // projection of an entry, it is the live state of a subsystem that is
-                // still running. `/clear screen` clears the screen, not the session.
-                compactionEntryId: undefined,
-            };
-        case 'resetUsage':
-            // The one field, for the one reason: a new id bills from zero (D-10).
-            return { ...state, usageTotal: EMPTY_USAGE_TOTAL };
-        case 'resetConversation':
-            return {
-                ...state,
-                pendingSteering: [],
-                entries: [],
-                droppedEntries: 0,
-                streamingId: undefined,
-                expandedToolIds: {},
-                // `context` IS DELIBERATELY UNTOUCHED (I-1). `clear-command.ts` calls
-                // `controller.resetConversation()` BEFORE dispatching this, and that marks
-                // the meter dirty and schedules a publication; zeroing here would make the
-                // final state `0` rather than the meter's real answer - which for an
-                // emptied conversation is the system prompt's own couple of percent, not
-                // nothing. `usageTotal` DOES reset: that is session spend, not occupancy.
-                usageTotal: EMPTY_USAGE_TOTAL,
-                teamEntryId: undefined,
-                // `/clear` clears `messages`, so the belief is gone and the list goes
-                // with it - the other half of I-2. `controller.clearMessages()` clears
-                // the STORE; this clears the mirror.
-                todos: null,
-                todoEntryId: undefined,
-                retryEntryId: undefined,
-                retry: null,
-                compactionEntryId: undefined,
-                // THE SIX RUN FACTS THIS BRANCH USED TO KEEP (clear-command-context-reset
-                // §3.6 / P0-3). `reduceRunFacts` above already zeroes `runPhase`,
-                // `activeTool`, `runOutcome` and `seenSteeringIds`, so nothing here
-                // repeats those four - these six are the actual gap, and each one
-                // otherwise describes a run that no longer exists.
-                //
-                // `status` is the status bar: a late `runEnd` would correct it a moment
-                // later, and until then the user is told a conversation that is over is
-                // still running. `team` is a dispatch panel with nothing dispatching.
-                // `fastEntryId` points at a `kind: 'fast'` card that `entries: []` just
-                // deleted, the same dangling-id rule `retryEntryId` and
-                // `compactionEntryId` above already follow.
-                //
-                // `turnProduced` / `errorNoticed` / `aborted` are ALSO cleared by
-                // `submit`, which is not a reason to leave them out: clearing is an
-                // independent entry point, so a user who clears and then only reads the
-                // panel would carry the previous turn's three facts into a conversation
-                // they never submitted into - and `runEnd`'s settle rule reads exactly
-                // those three.
-                status: 'idle',
-                team: null,
-                // The live run snapshot goes with the conversation it was shown in (the run itself
-                // survives on disk and announces itself again on its next event).
-                governance: null,
-                fastEntryId: undefined,
-                turnProduced: false,
-                errorNoticed: false,
-                aborted: false,
-                // THE TASK LABEL IS PART OF THE TASK (D-13). `/clear`, `/reset` and a
-                // session switch all land here, so the header loses its label without the
-                // App needing a second cleanup path. `/clear screen` does NOT come here -
-                // it keeps the conversation, so it keeps the label.
-                taskSummary: null,
-                taskSummaryPending: false,
-            };
-        case 'setOverlay':
-            return { ...state, overlay: action.overlay };
-        // --- Task summary (tui-shortcut-drawer-and-task-summary §7.1) ----------
-        //
-        // TWO FIELDS, ONE DIRECTION: `pending` is a latch the App raises before the
-        // call and releases on the result, and `taskSummary` is only ever replaced
-        // wholesale. Neither is persisted and neither is derived from `entries`, so a
-        // resumed conversation shows nothing until the App rebuilds the label.
-        case 'taskSummaryPending':
-            return { ...state, taskSummaryPending: true };
-        case 'taskSummaryReady':
-            return { ...state, taskSummary: action.view, taskSummaryPending: false };
-        // Pure mirror write. The App only ever dispatches what
-        // `controller.setAgentMode()` reported it ADOPTED, so this reducer has no
-        // deferral logic of its own to get out of step with (§3.1 / R-P7).
-        case 'setAgentMode':
-            return {
-                ...state,
-                agentMode: action.mode,
-                pendingAgentMode: action.pending,
-                ...adoptPosture(state.posture, action),
-            };
-        // --- Governance (governance-mode 14.4) -------------------------------------
-        case 'govSnapshot': {
-            const governance = foldGovernanceSnapshot(state.governance, action.snapshot);
-            return governance === state.governance ? state : { ...state, governance };
-        }
-        case 'govEnd':
-            return state.governance === null ? state : { ...state, governance: null };
-        case 'governanceCard': {
-            const { id, seq } = nextId(state);
-            const entry = { id, kind: 'governance', at: action.at ?? Date.now(), card: action.card };
-            return { ...state, seq, ...appendEntry(state, state.entries, entry) };
-        }
-        case 'toggleThinking':
-            return { ...state, thinkingVisible: !state.thinkingVisible };
-        case 'pushToast': {
-            const { seq } = nextId(state);
-            const toast = {
-                id: `t${seq}`,
-                level: action.level,
-                text: action.text,
-                ttlMs: action.ttlMs ?? DEFAULT_TOAST_TTL_MS,
-            };
-            return { ...state, seq, toasts: [...state.toasts, toast] };
-        }
-        case 'dismissToast':
-            return { ...state, toasts: state.toasts.filter((t) => t.id !== action.id) };
-        case 'toggleExpand': {
-            const next = { ...state.expandedToolIds };
-            if (next[action.id])
-                delete next[action.id];
-            else
-                next[action.id] = true;
-            return { ...state, expandedToolIds: next };
-        }
-        // --- Team mode (team-subagents §5.3) ---------------------------------
-        case 'teamStart': {
-            const { id, seq } = nextId(state);
-            const runs = action.specs.map((spec) => ({
-                label: spec.label,
-                description: spec.description,
-                phase: 'queued',
-                turns: 0,
-                toolCalls: 0,
-                usage: { inputTokens: 0, outputTokens: 0 },
-                filesTouched: [],
-                messagesSent: 0,
-            }));
-            const entry = {
-                id,
-                kind: 'team',
-                dispatchId: action.dispatchId,
-                requested: action.requested,
-                runs,
-                aborted: false,
-                active: true,
-            };
-            const team = {
-                dispatchId: action.dispatchId,
-                active: true,
-                runs,
-                requested: action.requested,
-                startedAt: Date.now(),
-                messageCount: 0,
-            };
-            // A GOVERNED DISPATCH LEAVES NO TRANSCRIPT CARD (RV-3): a run is 10-20 dispatches,
-            // and a `TeamCard` for each would bury the conversation. The live snapshot is still
-            // written - the legion panel and `/agents` read it - and with no `teamEntryId`,
-            // `teamUpdate` / `teamEnd` already pass `entries` through untouched.
-            if (isGovernedDispatch(action.specs))
-                return { ...state, team };
-            return {
-                ...state,
-                seq,
-                ...appendEntry(state, state.entries, entry),
-                teamEntryId: id,
-                team,
-            };
-        }
-        case 'teamUpdate': {
-            // One `mapEntry` on the KNOWN id, never a scan: this action arrives at up
-            // to `maxConcurrent` x 8/s and a reverse search over a long transcript on
-            // every one of them is exactly the cost the coalescer exists to avoid.
-            const entries = state.teamEntryId
-                ? mapEntry(state.entries, state.teamEntryId, (e) => e.kind === 'team' ? { ...e, runs: action.snapshot.runs } : e)
-                : state.entries;
-            return { ...state, entries, team: action.snapshot };
-        }
-        case 'teamUsage':
-            // `usageTotal` AND NOTHING ELSE (§3.9 / AC-15). In particular NOT
-            // `context`: that gauge shows the LEAD's context occupancy against
-            // the model's window, and folding five children into it would read 180%
-            // on a perfectly healthy session. Child spend is real money and has to
-            // appear in the cost readout; it is not the lead's context.
-            return { ...state, usageTotal: addUsage(state.usageTotal, action.usage, action.costDelta) };
-        case 'teamEnd': {
-            const { outcome } = action;
-            const entries = state.teamEntryId
-                ? mapEntry(state.entries, state.teamEntryId, (e) => e.kind === 'team'
-                    ? {
-                        ...e,
-                        runs: outcome.runs,
-                        aborted: outcome.aborted,
-                        durationMs: Math.max(0, outcome.endedAt - outcome.startedAt),
-                        active: false,
-                    }
-                    : e)
-                : state.entries;
-            // `team: null` is what makes the panel disappear — the requirement's
-            // "(dang you de shi hou)": it renders only while a dispatch is running.
-            return { ...state, entries, team: null, teamEntryId: undefined };
-        }
-        // --- Todo planning (todo-plan-execution §5.2) -------------------------
-        case 'todoUpdate': {
-            // TYPED AS THE TODO MEMBER, NOT AS `Entry`. The rewrite below spreads this
-            // and overrides `live: boolean`; while the return type was the whole union
-            // that spread also produced a TOOL entry carrying `live: boolean`, which
-            // stopped type-checking the moment the tool member gained its own `live`
-            // (agent-activity-presentation-live). Narrowing here is what keeps the
-            // override honest rather than accidentally legal.
-            const entry = (id) => ({
-                id,
-                kind: 'todo',
-                items: action.snapshot.items,
-                doneCount: action.snapshot.doneCount,
-                total: action.snapshot.total,
-                acceptance: action.snapshot.acceptance,
-                live: true,
-            });
-            // Rewrite the turn's card when there is one; otherwise append and record
-            // its id. One `mapEntry` on the KNOWN id, never a scan.
-            if (state.todoEntryId) {
-                const known = state.todoEntryId;
-                return {
-                    ...state,
-                    todos: action.snapshot,
-                    entries: mapEntry(state.entries, known, (e) => e.kind === 'todo' ? { ...entry(known), live: e.live } : e),
-                };
-            }
-            const { id, seq } = nextId(state);
-            return {
-                ...state,
-                seq,
-                todos: action.snapshot,
-                ...appendEntry(state, state.entries, entry(id)),
-                todoEntryId: id,
-            };
-        }
-        // THE ENTRY STAYS. It is history, and history is not retracted — only the
-        // live projection goes away, which is what unmounts the rail.
-        case 'todoCleared':
-            return { ...state, todos: null, todoEntryId: undefined };
-        // --- Fast model tier (fast-model-tier §5.4) ---------------------------
-        case 'fastStart': {
-            const { id, seq } = nextId(state);
-            const entry = {
-                id,
-                kind: 'fast',
-                reviewIndex: action.index,
-                model: action.model,
-                status: 'running',
-                turn: action.turn,
-                live: true,
-            };
-            return {
-                ...state,
-                seq,
-                ...appendEntry(state, state.entries, entry),
-                fastEntryId: id,
-            };
-        }
-        case 'fastEnd': {
-            const { review } = action;
-            const settle = (e) => e.kind === 'fast'
-                ? {
-                    ...e,
-                    status: review.kind,
-                    ...(review.text !== undefined ? { text: review.text } : {}),
-                    ...(review.detail !== undefined ? { detail: review.detail } : {}),
-                    durationMs: review.durationMs,
-                    // SETTLED. `Transcript`'s boundary is monotonic, so a card that
-                    // never settles is re-rendered on every frame for the rest of the
-                    // session (C-5).
-                    live: false,
-                }
-                : e;
-            // Rewrite the card this review opened when there is one; otherwise append
-            // a settled card. THE SECOND BRANCH IS NOT DEFENSIVE PADDING: a review
-            // that is dropped as `stranded` is emitted from `agent_end` and never had
-            // a `review_start`, and a run restored from `/resume` has no live id at
-            // all — "it did nothing" must never be the observable outcome (R-8).
-            if (state.fastEntryId) {
-                return {
-                    ...state,
-                    entries: mapEntry(state.entries, state.fastEntryId, settle),
-                    fastEntryId: undefined,
-                };
-            }
-            const { id, seq } = nextId(state);
-            const entry = {
-                id,
-                kind: 'fast',
-                reviewIndex: review.index,
-                model: review.model,
-                status: review.kind,
-                ...(review.text !== undefined ? { text: review.text } : {}),
-                ...(review.detail !== undefined ? { detail: review.detail } : {}),
-                turn: review.turn,
-                durationMs: review.durationMs,
-                live: false,
-            };
-            return { ...state, seq, ...appendEntry(state, state.entries, entry) };
-        }
-        case 'fastUsage':
-            // `usageTotal` AND NOTHING ELSE, exactly as `teamUsage` (§3.6 / AC-18). In
-            // particular NOT `context`: that gauge shows the LEAD's context
-            // occupancy against the lead model's window, and a review is a separate
-            // conversation with a different model entirely.
-            return { ...state, usageTotal: addUsage(state.usageTotal, action.usage, action.costDelta) };
-        case 'fastTier':
-            return { ...state, fast: action.snapshot };
-        // --- Context compaction (context-auto-compaction §5.5) ----------------
-        // THE TRANSCRIPT NOW CARRIES ONE CARD PER ATTEMPT (context-compaction-never-
-        // fires C). Before this change a declined `pressure` checkpoint dispatched
-        // NOTHING, which is what made "95 % and nothing happens" unreportable: the
-        // feature was trying, failing and saying nothing. The flood the old rule
-        // feared is bounded by `maxPerRun` / `stuckLimit` in `compaction/limits.ts`.
-        case 'compactionStart': {
-            const { id, seq } = nextId(state);
-            let entries = state.entries;
-            // RESPONSIBILITY 1 — SEAL ANY LIVE `streamingId` ENTRY, defensively.
-            // C-8's failure mode, and reachable here: `provider.ts` records that
-            // Anthropic can deliver an error IN-STREAM, after the connection is open
-            // and therefore after text deltas have already been emitted. An entry that
-            // never settles pins `Transcript`'s monotonic boundary and re-renders the
-            // tail forever.
-            if (state.streamingId) {
-                entries = mapEntry(entries, state.streamingId, (e) => e.kind === 'assistant' ? { ...e, streaming: false, ...sealThinkingMs(e) } : e);
-            }
-            // RESPONSIBILITY 2 — REWRITE A TRAILING `context_overflow` ERROR NOTICE
-            // (P1-4). `agent-loop.ts` emits `message_update` for EVERY stream event
-            // before the `error` branch throws, and `reduceStreamEvent`'s `case 'error'`
-            // turns that into a `level: 'error'` notice reading "Context length
-            // exceeded". So the HAPPY PATH of the reactive recovery would otherwise end
-            // with a red banner telling the user to throw away the session we are one
-            // frame from saving.
-            //
-            // IT REWRITES RATHER THAN REMOVES, because `<Static>` cannot un-print an
-            // entry it has already drawn — and it matches ONLY when that notice is the
-            // TAIL entry, so it can never touch an older, genuine error. If the
-            // recovery then fails, the ladder's own notice or the re-thrown 400 is what
-            // the user is left with, so neither direction lies.
-            if (action.trigger === 'overflow') {
-                const tail = entries[entries.length - 1];
-                if (tail &&
-                    tail.kind === 'notice' &&
-                    tail.level === 'error' &&
-                    tail.text.startsWith(CONTEXT_OVERFLOW_NOTICE_PREFIX)) {
-                    entries = mapEntry(entries, tail.id, (e) => e.kind === 'notice'
-                        ? { ...e, level: 'info', text: 'Context window exceeded - compacting and retrying.' }
-                        : e);
-                }
-            }
-            const entry = {
-                id,
-                kind: 'compaction',
-                index: action.index,
-                trigger: action.trigger,
-                mode: 'none',
-                applied: false,
-                messagesBefore: 0,
-                messagesAfter: 0,
-                tokensBefore: 0,
-                tokensAfter: 0,
-                model: action.model,
-                startedAt: Date.now(),
-                phase: 'planning',
-                live: true,
-            };
-            return {
-                ...state,
-                seq,
-                ...appendEntry(state, entries, entry),
-                compactionEntryId: id,
-                streamingId: undefined,
-            };
-        }
-        case 'compactionEnd': {
-            const { record } = action;
-            const settle = (e) => e.kind === 'compaction'
-                ? {
-                    ...e,
-                    index: record.index,
-                    trigger: record.trigger,
-                    mode: record.mode,
-                    applied: record.applied,
-                    ...(record.reason !== undefined ? { reason: record.reason } : {}),
-                    messagesBefore: record.messagesBefore,
-                    messagesAfter: record.messagesAfter,
-                    tokensBefore: record.tokensBefore,
-                    tokensAfter: record.tokensAfter,
-                    ...(record.summary !== undefined ? { summary: record.summary } : {}),
-                    ...(record.tailRelief ? { tailRelief: record.tailRelief } : {}),
-                    ...(record.decision ? { decision: record.decision } : {}),
-                    ...(record.memoryVersion ? { memoryVersion: record.memoryVersion } : {}),
-                    ...(record.keepRelaxed ? { keepRelaxed: record.keepRelaxed } : {}),
-                    ...(record.retainedTurns !== undefined
-                        ? { retainedTurns: record.retainedTurns } : {}),
-                    ...(record.retainedMessages !== undefined
-                        ? { retainedMessages: record.retainedMessages } : {}),
-                    ...(record.retainedMessages !== undefined
-                        ? { retainedMessages: record.retainedMessages } : {}),
-                    ...(record.keepRecentTurnsUsed !== undefined
-                        ? { keepRecentTurnsUsed: record.keepRecentTurnsUsed } : {}),
-                    ...(record.elidedMessages ? { elidedMessages: record.elidedMessages } : {}),
-                    model: record.model,
-                    durationMs: record.durationMs,
-                    // SETTLED. `Transcript`'s boundary is monotonic, so a card that
-                    // never settles is re-rendered on every frame for the rest of the
-                    // session (C-8).
-                    live: false,
-                }
-                : e;
-            // THE SECOND BRANCH IS NOT DEFENSIVE PADDING, exactly as `fastEnd`'s is
-            // not: the IDLE `/compact` path settles a record for a card this session
-            // may never have opened, and "it did nothing" must never be the observable
-            // outcome (R-8 / §6.4).
-            if (state.compactionEntryId) {
-                return {
-                    ...state,
-                    entries: mapEntry(state.entries, state.compactionEntryId, settle),
-                    compactionEntryId: undefined,
-                };
-            }
-            const { id, seq } = nextId(state);
-            const entry = {
-                id,
-                kind: 'compaction',
-                index: record.index,
-                trigger: record.trigger,
-                mode: record.mode,
-                applied: record.applied,
-                ...(record.reason !== undefined ? { reason: record.reason } : {}),
-                messagesBefore: record.messagesBefore,
-                messagesAfter: record.messagesAfter,
-                tokensBefore: record.tokensBefore,
-                tokensAfter: record.tokensAfter,
-                ...(record.summary !== undefined ? { summary: record.summary } : {}),
-                ...(record.tailRelief ? { tailRelief: record.tailRelief } : {}),
-                ...(record.decision ? { decision: record.decision } : {}),
-                ...(record.memoryVersion ? { memoryVersion: record.memoryVersion } : {}),
-                ...(record.keepRelaxed ? { keepRelaxed: record.keepRelaxed } : {}),
-                ...(record.retainedTurns !== undefined ? { retainedTurns: record.retainedTurns } : {}),
-                ...(record.keepRecentTurnsUsed !== undefined
-                    ? { keepRecentTurnsUsed: record.keepRecentTurnsUsed } : {}),
-                ...(record.elidedMessages ? { elidedMessages: record.elidedMessages } : {}),
-                model: record.model,
-                durationMs: record.durationMs,
-                live: false,
-            };
-            return { ...state, seq, ...appendEntry(state, state.entries, entry) };
-        }
-        case 'compactionPhase': {
-            // THE LIVE CARD'S STAGE, AND NOTHING ELSE. It must not open a card (a phase
-            // can arrive for an entry that a fast settle already closed) and must not
-            // resurrect a settled one: `live` is left untouched, so a late phase on a
-            // settled card changes nothing the renderer shows.
-            if (!state.compactionEntryId)
-                return state;
-            const phase = action.phase;
-            return {
-                ...state,
-                entries: mapEntry(state.entries, state.compactionEntryId, (e) => e.kind === 'compaction' && e.live ? { ...e, phase } : e),
-            };
-        }
-        case 'compactionUsage':
-            // `usageTotal` AND NOTHING ELSE, exactly as `teamUsage` and `fastUsage`. In
-            // particular NOT `context`: that gauge shows the LEAD's context
-            // occupancy against the lead model's window, and a summarization is a
-            // separate conversation with a possibly different model entirely.
-            return { ...state, usageTotal: addUsage(state.usageTotal, action.usage, action.costDelta) };
-        case 'compactionSnapshot':
-            return { ...state, compaction: action.snapshot };
-        /**
-         * THE ONE WRITER OF `state.context` (I-1).
-         *
-         * THE IDENTITY SHORT-CIRCUIT BELOW IS LOAD-BEARING, NOT A MICRO-OPTIMISATION
-         * (§5.2 / R-3). The meter publishes on a 400 ms tick throughout a turn and
-         * most of those ticks measure the same number - the history did not change
-         * between two tool calls of the same size, or the percentage rounded to the
-         * same integer. Returning the SAME state object lets React skip the whole
-         * subtree; returning a fresh one would make a permanently visible row into a
-         * 2.5 Hz re-render source and walk the render governor up its ladder for no
-         * visible change at all.
-         *
-         * `ContextUsageSnapshot` carries no timestamp for exactly this reason: a
-         * field that moves every tick would make this comparison never hold.
-         */
-        case 'contextUsage': {
-            const prev = state.context;
-            const next = action.snapshot;
-            if (prev.occupied === next.occupied &&
-                prev.window === next.window &&
-                prev.pct === next.pct &&
-                prev.source === next.source &&
-                prev.deltaTokens === next.deltaTokens &&
-                prev.windowKnown === next.windowKnown &&
-                prev.windowSource === next.windowSource &&
-                prev.windowOverridden === next.windowOverridden) {
-                return state;
-            }
-            return { ...state, context: next };
-        }
-        // --- API retry (llm-api-retry-backoff §6.4) ---------------------------
-        case 'retryScheduled': {
-            const snapshot = {
-                attempt: action.attempt,
-                maxRetries: action.maxRetries,
-                resumeAt: action.resumeAt,
-                phase: 'waiting',
-                errorType: action.errorType,
-            };
-            // ONE CARD PER TURN, REWRITTEN IN PLACE. One `mapEntry` on the KNOWN id,
-            // never a scan — the same discipline `todoUpdate` follows.
-            if (state.retryEntryId) {
-                const known = state.retryEntryId;
-                return {
-                    ...state,
-                    retry: snapshot,
-                    entries: mapEntry(state.entries, known, (e) => e.kind === 'retry'
-                        ? {
-                            ...e,
-                            attempt: action.attempt,
-                            maxRetries: action.maxRetries,
-                            errorType: action.errorType,
-                            message: action.message,
-                            delayMs: action.delayMs,
-                            resumeAt: action.resumeAt,
-                            phase: 'waiting',
-                        }
-                        : e),
-                };
-            }
-            const { id, seq } = nextId(state);
-            const entry = {
-                id,
-                kind: 'retry',
-                attempt: action.attempt,
-                maxRetries: action.maxRetries,
-                errorType: action.errorType,
-                message: action.message,
-                delayMs: action.delayMs,
-                resumeAt: action.resumeAt,
-                phase: 'waiting',
-                // The clock the settled card's `elapsedMs` is measured from: the FIRST
-                // retry of the turn, not the last.
-                startedAt: Date.now(),
-            };
-            return {
-                ...state,
-                seq,
-                retry: snapshot,
-                ...appendEntry(state, state.entries, entry),
-                retryEntryId: id,
-            };
-        }
-        case 'retryAttempt': {
-            if (!state.retryEntryId)
-                return state;
-            const known = state.retryEntryId;
-            return {
-                ...state,
-                // `resumeAt` is CLEARED: the wait is over, so a countdown would tick
-                // downward past zero while the request is already in flight.
-                retry: state.retry ? { ...state.retry, phase: 'retrying', resumeAt: undefined } : null,
-                entries: mapEntry(state.entries, known, (e) => e.kind === 'retry' ? { ...e, phase: 'retrying', resumeAt: undefined } : e),
-            };
-        }
-        case 'streamRestart': {
-            const discarded = new Set(action.discardedToolCallIds);
-            const entries = state.entries.filter((e) => !(e.kind === 'tool' && discarded.has(e.toolCallId)));
-            return {
-                ...state,
-                entries: state.streamingId
-                    ? mapEntry(entries, state.streamingId, (e) => e.kind === 'assistant'
-                        ? {
-                            ...e,
-                            text: '',
-                            thinking: undefined,
-                            thinkingOpen: false,
-                            // A restarted stream re-thinks from scratch. Carrying the old
-                            // clock forward would report a duration for reasoning that
-                            // was discarded.
-                            thinkingStartedAt: undefined,
-                            thinkingMs: undefined,
-                        }
-                        : e)
-                    : entries,
-            };
-        }
-        /**
-         * The 1 Hz countdown tick. NO VALUE CHANGES — the card is refreshed by
-         * IDENTITY so that React re-renders exactly one entry.
-         *
-         * A FLAT NONCE ON `ViewState` WOULD NOT WORK, and this is the trap worth
-         * naming: `EntryView` is `React.memo`'d with an explicit comparator whose
-         * first clause is `a.entry === b.entry`, so a state field the card does not
-         * receive as a prop changes nothing at all — the countdown would freeze at
-         * whatever second it was first drawn on, and the transcript would keep
-         * re-rendering around it for no benefit. Rewriting the entry is what breaks
-         * that boundary, and `EntryView` reads the clock for this kind only.
-         *
-         * `entryRevision` is deliberately NOT extended: the card is one row in every
-         * phase, so the cached height stays correct and no re-measure is wanted.
-         *
-         * Returning `state` unchanged when nothing is waiting is what keeps a stray
-         * tick from costing a render at all.
-         */
-        case 'retryTick': {
-            if (state.retry?.phase !== 'waiting' || !state.retryEntryId)
-                return state;
-            const known = state.retryEntryId;
-            return {
-                ...state,
-                entries: mapEntry(state.entries, known, (e) => (e.kind === 'retry' ? { ...e } : e)),
-            };
-        }
-        case 'restoreEntries': {
-            // Adopt a seq beyond any restored id to keep future ids unique.
-            const maxSeq = action.entries.reduce((acc, e) => {
-                const n = Number.parseInt(e.id.replace(/^e/, ''), 10);
-                return Number.isFinite(n) ? Math.max(acc, n) : acc;
-            }, state.seq);
-            // A session file can be longer than the retain ring; trimming it here is
-            // the one append-free place the bound still has to hold, and the count
-            // starts from this restore rather than inheriting the previous session's.
-            const restored = trimEntries([...action.entries], entryRetain());
-            return {
-                ...state,
-                entries: restored.entries,
-                pendingSteering: [],
-                droppedEntries: restored.dropped,
-                seq: maxSeq,
-                teamEntryId: undefined,
-                // As for `team`: the restored cards are history and no turn owns them.
-                // The LIST itself arrives separately, through `controller.restoreTodos`
-                // and the store's own event (§3.13).
-                todoEntryId: undefined,
-                // Same for the retry card. `normalizeLoadedEntries` has already forced any
-                // in-flight phase to `interrupted`, so nothing restored is live.
-                retryEntryId: undefined,
-                retry: null,
-                // Same again for the fast card: `normalizeLoadedEntries` has already
-                // forced `live: false`, so nothing restored is live. `state.fast` is
-                // NOT cleared — it is the session's own tier projection, which a
-                // `/resume` does not change.
-                fastEntryId: undefined,
-                // `/resume` ADOPTS ANOTHER CONVERSATION, so the previous conversation's
-                // label describes something that is no longer on screen. The reducer only
-                // CLEARS it; the App's `makeCtx().dispatch` wrapper rebuilds one from
-                // `action.entries` (D-13), because it is the only layer that sees the
-                // restored entries BEFORE this branch runs.
-                taskSummary: null,
-                taskSummaryPending: false,
-                // Same rule for a live governed run: `/resume` adopts another conversation, and
-                // a snapshot of the old one's run must not be drawn over it. Settlement cards
-                // arrive with the restored `entries`.
-                governance: null,
-            };
-        }
-        // --- Background services (§3.10 / D-11) -----------------------------
-        case 'serviceStart': {
-            const { id, seq } = nextId(state);
-            const entry = { id, ...serviceFields(action.service) };
-            const appended = appendEntry(state, state.entries, entry);
-            return {
-                ...state,
-                seq,
-                entries: appended.entries,
-                droppedEntries: appended.droppedEntries,
-            };
-        }
-        case 'serviceUpdate': {
-            const target = findServiceEntryId(state, action.service.id);
-            if (!target)
-                return state;
-            return {
-                ...state,
-                entries: mapEntry(state.entries, target, (e) => e.kind === 'service' ? { ...e, ...serviceFields(action.service) } : e),
-            };
-        }
-        case 'serviceEnd': {
-            const target = findServiceEntryId(state, action.service.id);
-            const settled = target
-                ? mapEntry(state.entries, target, (e) => e.kind === 'service' ? { ...e, ...serviceFields(action.service) } : e)
-                : state.entries;
-            const { id, seq } = nextId(state);
-            const appended = appendEntry(state, settled, {
-                id,
-                ...serviceFields(action.service),
-                terminal: true,
-            });
-            return {
-                ...state,
-                seq,
-                entries: appended.entries,
-                droppedEntries: appended.droppedEntries,
-            };
-        }
-        default:
-            return state;
-    }
-}
-/**
- * Project a supervisor snapshot onto the entry's own fields.
- *
- * ONE PROJECTION FOR ALL THREE ACTIONS, so a field that reaches the card through
- * `serviceStart` can never fail to reach it through `serviceUpdate` — the kind of
- * asymmetry that produces a card frozen at its first values with nothing
- * reporting it.
- */
-function serviceFields(service) {
-    return {
-        kind: 'service',
-        serviceId: service.id,
-        jobKind: service.kind,
-        command: service.command,
-        status: service.status,
-        ...(service.url !== undefined ? { url: service.url } : {}),
-        ...(service.port !== undefined ? { port: service.port } : {}),
-        exitCode: service.exitCode,
-        startedAt: service.startedAt,
-        ...(service.readyAt !== undefined ? { readyAt: service.readyAt } : {}),
-        ...(service.endedAt !== undefined ? { endedAt: service.endedAt } : {}),
-        rows: service.rows,
-        rowsSeen: service.rowsSeen,
-        ...(service.killIncomplete ? { killIncomplete: true } : {}),
-        // The four fields long-task-jobs adds, in the SAME projection for all three
-        // actions - which is the property this function exists to guarantee.
-        lastOutputAt: service.lastOutputAt,
-        ...(service.progress ? { progress: service.progress.text } : {}),
-        ...(service.stalled ? { stalled: true } : {}),
-        ...(service.logPath !== undefined ? { logPath: service.logPath } : {}),
-    };
-}
-/** The LIVE card for a service id, newest first; terminal records are skipped. */
-function findServiceEntryId(state, serviceId) {
-    for (let i = state.entries.length - 1; i >= 0; i -= 1) {
-        const e = state.entries[i];
-        if (e && e.kind === 'service' && e.serviceId === serviceId && !e.terminal)
-            return e.id;
-    }
-    return undefined;
-}
-function safeStringify(value) {
-    try {
-        return JSON.stringify(value);
-    }
-    catch {
-        return String(value);
-    }
-}