talos-code 0.0.1 → 0.2.0

package/dist/tui/transcript-model.js

@@ -0,0 +1,441 @@
+import { describeError, describeRefusal, errorViewLines } from "../i18n/error-view.js";
+import { t, tn } from "../i18n/index.js";
+import { rendererKindFor, toolDisplay } from "./tool-display.js";
+import { toolRowView } from "./components/tool-row.js";
+import { compactTokens } from "./status-bar.js";
+import { lineCount, sanitizeDisplayText, truncatedMarker, visibleEscape, withoutKernelExitLine } from "./tools/shared.js";
+export const MAX_TRANSCRIPT_ITEMS = 768;
+const MAX_MESSAGE_CHARS = 256 * 1024;
+const MAX_TOOL_SUMMARY_CHARS = 8 * 1024;
+const MAX_WARNING_CHARS = 2048;
+/* A file change is kept whole (for the Ctrl+O diff) up to this size per side; beyond it only its summary is kept. */
+const MAX_CHANGE_CHARS = 512 * 1024;
+const MAX_RUNS = 64;
+function tail(value, limit) { if (value.length <= limit)
+    return value; const marker = truncatedMarker() + '\n'; return marker + value.slice(-(limit - marker.length)); }
+export function sanitizeTranscriptText(value) { return sanitizeDisplayText(value); }
+export function transcriptItemText(item) {
+    if (item.kind === 'message')
+        return sanitizeTranscriptText((item.role === 'user' ? 'You' : 'TALOS') + '\n' + item.text);
+    if (item.kind === 'reasoning')
+        return sanitizeTranscriptText('Reasoning\n' + item.text);
+    if (item.kind === 'tool') {
+        /* R3 gate E1: the header is the ONE row formatter's line (tools/row-format.ts), unfitted; the output follows whole for
+           search and copy, without the kernel's `exit N [sandbox: …]` first line (gate E3). The raw item stays in
+           `transcriptItemRaw`. */
+        const output = withoutKernelExitLine(item.finalOutput || item.liveOutput);
+        return sanitizeTranscriptText([toolRowView(item, Number.POSITIVE_INFINITY, false).line, output.trim() ? 'Output\n' + output : ''].filter(Boolean).join('\n'));
+    }
+    if (item.kind === 'warning')
+        return sanitizeTranscriptText(item.outcome ? item.text : 'Warning\n' + item.text);
+    return sanitizeTranscriptText('Run · ' + item.status + (item.runId ? ' · ' + item.runId : '') + (item.message ? '\n' + item.message : ''));
+}
+export function transcriptItemRaw(item) {
+    return JSON.stringify(item, null, 2).replace(/[\x7f-\x9f\u2028\u2029\p{Bidi_Control}]/gu, visibleEscape);
+}
+export function createTranscriptModel() { return { items: [], nextLocalId: 1, pendingApproval: null }; }
+export function clearTranscript(model) { return { items: [], nextLocalId: model.nextLocalId, pendingApproval: null, ...(model.runs ? { runs: model.runs } : {}) }; }
+function activeTool(status) { return status === 'queued' || status === 'approval' || status === 'running' || status === 'streaming'; }
+function active(item) { return (item.kind === 'message' && item.streaming) || (item.kind === 'reasoning' && item.streaming) || (item.kind === 'tool' && activeTool(item.status)) || (item.kind === 'run' && item.status === 'running'); }
+function trim(model) {
+    const items = [...model.items];
+    while (items.length > MAX_TRANSCRIPT_ITEMS) {
+        const index = items.findIndex(item => !active(item));
+        if (index < 0)
+            break;
+        items.splice(index, 1);
+    }
+    return { ...model, items };
+}
+function put(model, item) {
+    const index = model.items.findIndex(row => row.id === item.id);
+    if (index >= 0) {
+        const items = model.items.slice();
+        items[index] = item;
+        return trim({ ...model, items });
+    }
+    return trim({ ...model, items: [...model.items, item] });
+}
+function localId(model, prefix) { return { id: prefix + ':local:' + model.nextLocalId, model: { ...model, nextLocalId: model.nextLocalId + 1 } }; }
+function existing(model, id, kind) {
+    const item = model.items.find(row => row.id === id);
+    return item?.kind === kind ? item : null;
+}
+function toolId(toolCallId) { return 'tool:' + toolCallId; }
+/* ---- R3 contract events (tui/tool-facts.ts; produced by lane SP) ---- */
+function definedFacts(facts) { const out = {}; for (const [key, value] of Object.entries(facts ?? {}))
+    if (value !== undefined)
+        out[key] = value; return out; }
+function withFacts(item, pending) {
+    const next = { ...item };
+    if (pending.origin)
+        next.origin = pending.origin;
+    if (pending.decision !== undefined)
+        next.decision = pending.decision;
+    if (pending.facts)
+        next.facts = { ...(item.facts ?? {}), ...definedFacts(pending.facts) };
+    if (pending.savedOutput)
+        next.savedOutput = pending.savedOutput;
+    if (pending.readCut)
+        next.readCut = pending.readCut;
+    return next;
+}
+const count = (value) => typeof value === 'number' && Number.isFinite(value) && value >= 0 ? Math.floor(value) : null;
+/* R5a S6/S7: the facts of lane R's cut events, kept only when they are whole numbers and a path (a malformed event is
+   dropped, never drawn as a zero). */
+function savedOutputOf(event) {
+    const kept = count(event.keptChars), total = count(event.totalChars);
+    return typeof event.path === 'string' && event.path.trim() && kept !== null && total !== null ? { path: event.path, keptChars: kept, totalChars: total } : null;
+}
+function readCutOf(event) {
+    const shown = count(event.shownLines), limit = count(event.limitChars);
+    return shown !== null && limit !== null && limit > 0 ? { shownLines: shown, totalLines: count(event.totalLines), limitChars: limit } : null;
+}
+/*
+ * R5a S3 (owner decision Q-R5-4, gate E9): a compaction is named on the transcript when it happens — which engine, what
+ * was summarized, the tokens before and after. The Context Engine compacts at half of a KNOWN window (owner, 2026-09-16:
+ * "the threshold is stated to the user"), so its line states the 50 %; the kernel's own rule (every 8 model calls) is the
+ * one that runs when no window is known. An unknown count is said to be unknown, never zero (E1).
+ */
+export function compactionNoticeText(event) {
+    const messages = count(event.messagesSummarized), before = count(event.tokensBefore), after = count(event.tokensAfter);
+    const parts = [messages === null ? t('screen.compaction.messagesUnknown') : tn('screen.compaction.messages', messages)];
+    if (before !== null && after !== null)
+        parts.push(t('screen.compaction.tokens', { before: compactTokens(before), after: compactTokens(after) }));
+    else if (before !== null)
+        parts.push(t('screen.compaction.tokensBefore', { before: compactTokens(before) }));
+    else if (after !== null)
+        parts.push(t('screen.compaction.tokensAfter', { after: compactTokens(after) }));
+    else
+        parts.push(t('screen.compaction.tokensUnknown'));
+    return t(event.engine === 'context-engine' ? 'screen.compaction.contextEngine' : 'screen.compaction.kernel', { summary: parts.join(' · ') });
+}
+/*
+ * Desktop CE fix (aligned 2026-09-25): the pause after a refused summary is said once per failed job, with the local time of
+ * the next automatic try (absolute, so a replayed line does not lie) and that /compact does not wait.
+ */
+export function compactionPausedText(event) {
+    const at = new Date(event.retryAfter);
+    const time = `${String(at.getHours()).padStart(2, '0')}:${String(at.getMinutes()).padStart(2, '0')}`;
+    return tn('screen.compaction.paused', event.attempts && event.attempts > 1 ? event.attempts : 1, { code: event.code, time });
+}
+/** A new tool item, with whatever facts arrived before it (and those facts consumed). */
+function newTool(model, toolCallId, row) {
+    const pending = model.pendingTools?.[toolCallId];
+    let item = { kind: 'tool', id: toolId(toolCallId), ...row };
+    let base = model;
+    if (pending) {
+        item = withFacts(item, pending);
+        const rest = { ...model.pendingTools };
+        delete rest[toolCallId];
+        base = { ...model, pendingTools: rest };
+    }
+    return put(base, item);
+}
+function toolFacts(model, toolCallId, pending) {
+    const current = existing(model, toolId(toolCallId), 'tool');
+    if (current)
+        return put(model, withFacts(current, pending));
+    const all = { ...(model.pendingTools ?? {}) };
+    all[toolCallId] = { ...all[toolCallId], ...pending, ...(pending.facts ? { facts: { ...(all[toolCallId]?.facts ?? {}), ...definedFacts(pending.facts) } } : {}) };
+    const keys = Object.keys(all);
+    if (keys.length > MAX_RUNS)
+        delete all[keys[0]];
+    return { ...model, pendingTools: all };
+}
+/* The path a write/edit row names, for matching a `file.changed` that carries no tool call id. */
+const normalPath = (value) => String(value ?? '').trim().replaceAll('\\', '/').replace(/^\.\//u, '');
+function changedPathOf(item) { try {
+    const args = JSON.parse(item.argsText || '{}');
+    return normalPath(args?.percorso ?? args?.path ?? args?.file ?? args?.filename);
+}
+catch {
+    return '';
+} }
+function fileChanged(model, change) {
+    let target = change.toolCallId ? existing(model, toolId(change.toolCallId), 'tool') : null;
+    if (!target) {
+        const writers = model.items.filter((item) => item.kind === 'tool' && (rendererKindFor(item.name) === 'write' || rendererKindFor(item.name) === 'edit'));
+        const path = normalPath(change.path);
+        target = writers.findLast(item => changedPathOf(item) === path) ?? writers.findLast(item => activeTool(item.status)) ?? null;
+    }
+    if (!target)
+        return model;
+    const small = (change.before ?? '').length <= MAX_CHANGE_CHARS && change.after.length <= MAX_CHANGE_CHARS;
+    return put(model, small ? { ...target, change, changeSummary: null } : { ...target, change: null, changeSummary: { newFile: change.before === null, lines: lineCount(change.after), added: null, removed: null } });
+}
+/* R2 lane E (gate E2, E4): a refused tool's `content` is what the MODEL reads ("REFUSED. <Italian motivo> …") and is never
+   rewritten; the row shows the English reason of the receipt's `via`, and the content stays in `outcome.content`.
+   R3 (gate E9): a refusal is `denied`, not `failed`. */
+function refused(outcome) { return Boolean(outcome && (outcome.allowed === false || outcome.receiptStatus === 'denied')); }
+function terminalTool(model, toolCallId, rawContent, outcome) {
+    const id = toolId(toolCallId), current = existing(model, id, 'tool');
+    const status = refused(outcome) ? 'denied' : outcome?.status ?? (current?.status === 'denied' ? 'denied' : 'completed');
+    const content = refused(outcome) ? describeRefusal({ via: outcome.permissionVia, allowed: outcome.allowed }) : status === 'denied' && current ? current.finalOutput || rawContent : rawContent;
+    const next = current
+        ? put(model, { ...current, status, finalOutput: tail(content, MAX_TOOL_SUMMARY_CHARS), endedAt: Date.now(), outcome })
+        : newTool(model, toolCallId, { name: 'tool', status, argsText: '', liveOutput: '', finalOutput: tail(content, MAX_TOOL_SUMMARY_CHARS), startedAt: null, endedAt: Date.now(), outcome });
+    return next.pendingApproval?.toolCallId === toolCallId ? { ...next, pendingApproval: null } : next;
+}
+/* ---- Runs (R1 lane R; R3 Q-R3-8/9) ---- */
+function runsOf(model) { return model.runs ?? []; }
+function setRun(model, run) {
+    const runs = runsOf(model);
+    return { ...model, runs: runs.some(row => row.key === run.key) ? runs.map(row => row.key === run.key ? run : row) : [...runs, run].slice(-MAX_RUNS) };
+}
+function findRun(model, event) {
+    const runs = runsOf(model);
+    if (event.runId) {
+        const run = runs.find(row => row.runId === event.runId || row.key === event.runId);
+        if (run)
+            return run;
+    }
+    for (let i = runs.length - 1; i >= 0; i--)
+        if (runs[i].status === 'running')
+            return runs[i];
+    return null;
+}
+function anchorIndex(model, run) { return run?.anchor ? model.items.findIndex(item => item.id === run.anchor) : -1; }
+/*
+ * R1 lane R (D-04, gate E9): the person's message is rebuilt from its run's RunStarted and keyed by the run
+ * (`message:user:<runId>`), so a replay from 0 is idempotent. At send time app.ts has already shown a local echo
+ * (`message:local:<n>`): the RunStarted adopts the newest unclaimed echo of the same text sent since the last run, so the
+ * message is never shown twice. When the RunStarted comes first (queued prompt, command-line prompt) the message is created
+ * here and the late echo is absorbed once (`lateEcho`). A replayed history RunStarted (`history`, set by the controller) never
+ * absorbs an echo: a new send with the same text as an old one must stay visible at once.
+ * R3 (Q-R3-9): "since the last run" is "after the last run's anchor" — there is no Run row to stop at any more.
+ */
+function userMessageId(key) { return 'message:user:' + key; }
+function isLocalEcho(item) { return item.kind === 'message' && item.role === 'user' && item.id.startsWith('message:local:'); }
+function adoptOrAddPrompt(model, key, text, history) {
+    const id = userMessageId(key);
+    if (existing(model, id, 'message'))
+        return model;
+    const stop = anchorIndex(model, runsOf(model).at(-1));
+    for (let i = model.items.length - 1; i > stop; i--) {
+        const row = model.items[i];
+        if (row.kind === 'run' || (row.kind === 'message' && row.role === 'user' && !isLocalEcho(row)))
+            break;
+        if (isLocalEcho(row) && row.kind === 'message' && row.text === text) {
+            const items = model.items.slice();
+            items[i] = { ...row, id, streaming: false };
+            return { ...model, items, lateEcho: null };
+        }
+    }
+    const next = put(model, { kind: 'message', id, role: 'user', text: tail(text, MAX_MESSAGE_CHARS), streaming: false });
+    return { ...next, lateEcho: history ? null : { id, text } };
+}
+/* R5a S8: the clock of a reasoning block — now for a live run, none while a history is replayed. */
+function liveClock(model) { const run = runsOf(model).at(-1); return run?.history && run.status === 'running' ? null : Date.now(); }
+function endReasoning(item) {
+    return { ...item, streaming: false, ...(typeof item.startedAt === 'number' && typeof item.endedAt !== 'number' ? { endedAt: Date.now() } : {}) };
+}
+/* A turn that ends closes the reasoning it left open (the kernel may end a run without a reasoning end event). */
+function closeReasoning(model) {
+    if (!model.items.some(item => item.kind === 'reasoning' && item.streaming))
+        return model;
+    return { ...model, items: model.items.map(item => item.kind === 'reasoning' && item.streaming ? endReasoning(item) : item) };
+}
+function closeInterrupted(model) {
+    const now = Date.now();
+    const items = model.items.map(item => {
+        if (item.kind === 'reasoning' && item.streaming)
+            return endReasoning(item);
+        if (item.kind === 'message' && item.streaming)
+            return { ...item, streaming: false };
+        /* Q-R3-8: a tool the stop cut is `interrupted`; one that was still waiting for approval never ran (no duration). */
+        if (item.kind === 'tool' && activeTool(item.status))
+            return { ...item, status: 'interrupted', endedAt: item.endedAt ?? (item.status === 'approval' ? item.startedAt : now) };
+        return item;
+    });
+    return { ...model, items, pendingApproval: null };
+}
+export function appendTranscriptMessage(model, input) {
+    const late = model.lateEcho;
+    if (late && !input.id && input.role === 'user' && late.text === input.text && existing(model, late.id, 'message'))
+        return { ...model, lateEcho: null };
+    let base = model, id = input.id ? 'message:' + input.id : '';
+    if (!id) {
+        const next = localId(model, 'message');
+        id = next.id;
+        base = next.model;
+    }
+    const current = existing(base, id, 'message');
+    return put(base, current ? { ...current, role: input.role, text: tail(input.text, MAX_MESSAGE_CHARS), streaming: false } : { kind: 'message', id, role: input.role, text: tail(input.text, MAX_MESSAGE_CHARS), streaming: false });
+}
+export function appendTranscriptWarning(model, text, id, detail) {
+    let base = model, itemId = id ? 'warning:' + id : '';
+    if (!itemId) {
+        const next = localId(model, 'warning');
+        itemId = next.id;
+        base = next.model;
+    }
+    return put(base, { kind: 'warning', id: itemId, text: tail(text, MAX_WARNING_CHARS), ...(detail ? { detail: tail(detail, MAX_WARNING_CHARS) } : {}) });
+}
+/*
+ * R2 lane E (gate E15): where an interrupted run stopped, read from THIS transcript (the kernel's stop point is Italian free
+ * text). The last row of the run decides: a tool waiting for approval, a tool still running, or the model's answer.
+ */
+function stopPoint(model, run) {
+    const start = anchorIndex(model, run);
+    for (let i = model.items.length - 1; i > start; i--) {
+        const item = model.items[i];
+        if (item.kind === 'tool') {
+            const tool = toolDisplay(item.name).label;
+            if (item.status === 'approval' || model.pendingApproval?.toolCallId === item.id.slice(5))
+                return { kind: 'approval', tool };
+            if (activeTool(item.status))
+                return { kind: 'tool', tool };
+            return null;
+        }
+        if ((item.kind === 'message' && item.role === 'assistant') || item.kind === 'reasoning')
+            return { kind: 'answering' };
+        if (item.kind === 'run' || (item.kind === 'warning' && item.outcome))
+            return null;
+    }
+    return null;
+}
+function stopPhrase(point) {
+    if (point.kind === 'answering')
+        return t('error.run.while.answering');
+    return point.kind === 'approval' ? t('error.run.while.approval', { tool: point.tool }) : t('error.run.while.tool', { tool: point.tool });
+}
+export function reduceTranscriptEvent(model, event) {
+    if (event.type === 'message.started') {
+        const id = 'message:' + event.messageId, current = existing(model, id, 'message');
+        return put(model, current ? { ...current, role: event.role } : { kind: 'message', id, role: event.role, text: '', streaming: true });
+    }
+    if (event.type === 'message.delta') {
+        const id = 'message:' + event.messageId, current = existing(model, id, 'message');
+        return put(model, current ? { ...current, text: tail(current.text + event.delta, MAX_MESSAGE_CHARS), streaming: true } : { kind: 'message', id, role: 'assistant', text: tail(event.delta, MAX_MESSAGE_CHARS), streaming: true });
+    }
+    if (event.type === 'message.end') {
+        const id = 'message:' + event.messageId, current = existing(model, id, 'message');
+        return current ? put(model, { ...current, streaming: false }) : model;
+    }
+    if (event.type === 'reasoning.started') {
+        const id = 'reasoning:' + event.messageId, current = existing(model, id, 'reasoning');
+        return current ? model : put(model, { kind: 'reasoning', id, text: '', streaming: true, startedAt: liveClock(model) });
+    }
+    if (event.type === 'reasoning.delta') {
+        const id = 'reasoning:' + event.messageId, current = existing(model, id, 'reasoning');
+        return put(model, current ? { ...current, text: tail(current.text + event.delta, MAX_MESSAGE_CHARS), streaming: true } : { kind: 'reasoning', id, text: tail(event.delta, MAX_MESSAGE_CHARS), streaming: true, startedAt: liveClock(model) });
+    }
+    if (event.type === 'reasoning.end') {
+        const id = 'reasoning:' + event.messageId, current = existing(model, id, 'reasoning');
+        return current ? put(model, endReasoning(current)) : model;
+    }
+    if (event.type === 'context.summary.requested') {
+        const live = runsOf(model).filter(run => run.status === 'running').at(-1);
+        return live ? setRun(model, { ...live, summaryRequests: (live.summaryRequests ?? 0) + 1 }) : model;
+    }
+    if (event.type === 'context.compaction.paused')
+        return appendTranscriptWarning(model, compactionPausedText(event), event.noticeId ? `paused:${event.noticeId}` : event.eventId ? `paused:${event.eventId}` : undefined);
+    if (event.type === 'context.compacted') {
+        const live = event.engine === 'context-engine' ? runsOf(model).filter(run => run.status === 'running').at(-1) : undefined;
+        const base = live ? setRun(model, { ...live, summaryAccepted: true }) : model;
+        return appendTranscriptWarning(base, compactionNoticeText(event), event.eventId ? `compaction:${event.eventId}` : undefined);
+    }
+    if (event.type === 'tool.output.saved') {
+        const saved = savedOutputOf(event);
+        return saved ? toolFacts(model, event.toolCallId, { savedOutput: saved }) : model;
+    }
+    if (event.type === 'tool.read.cut') {
+        const cut = readCutOf(event);
+        return cut ? toolFacts(model, event.toolCallId, { readCut: cut }) : model;
+    }
+    if (event.type === 'tool.started') {
+        const current = existing(model, toolId(event.toolCallId), 'tool');
+        /* A row made by an early `tool.args`/`tool.output` carries the placeholder name until its start names the tool. */
+        if (current)
+            return current.name === 'tool' && event.toolName !== 'tool' ? put(model, { ...current, name: event.toolName }) : model;
+        return newTool(model, event.toolCallId, { name: event.toolName, status: 'queued', argsText: '', liveOutput: '', finalOutput: '', startedAt: Date.now(), endedAt: null, outcome: null });
+    }
+    if (event.type === 'tool.args') {
+        const current = existing(model, toolId(event.toolCallId), 'tool');
+        return current ? put(model, { ...current, argsText: tail(current.argsText + event.delta, MAX_TOOL_SUMMARY_CHARS) }) : newTool(model, event.toolCallId, { name: 'tool', status: 'queued', argsText: tail(event.delta, MAX_TOOL_SUMMARY_CHARS), liveOutput: '', finalOutput: '', startedAt: Date.now(), endedAt: null, outcome: null });
+    }
+    if (event.type === 'tool.output') {
+        const current = existing(model, toolId(event.toolCallId), 'tool');
+        return current ? put(model, { ...current, status: 'streaming', liveOutput: tail(current.liveOutput + event.delta, MAX_TOOL_SUMMARY_CHARS) }) : newTool(model, event.toolCallId, { name: 'tool', status: 'streaming', argsText: '', liveOutput: tail(event.delta, MAX_TOOL_SUMMARY_CHARS), finalOutput: '', startedAt: Date.now(), endedAt: null, outcome: null });
+    }
+    if (event.type === 'tool.completed')
+        return terminalTool(model, event.toolCallId, event.content, event.outcome ?? null);
+    if (event.type === 'tool.origin')
+        return toolFacts(model, event.toolCallId, { origin: event.origin });
+    if (event.type === 'tool.decision')
+        return toolFacts(model, event.toolCallId, { decision: event.decision });
+    if (event.type === 'tool.facts')
+        return toolFacts(model, event.toolCallId, { facts: event.facts });
+    if (event.type === 'file.changed')
+        return 'change' in event && event.change ? fileChanged(model, event.change) : model;
+    if (event.type === 'approval.required') {
+        if (!event.toolCallId)
+            return model;
+        const id = toolId(event.toolCallId), current = existing(model, id, 'tool');
+        const next = current ? put(model, { ...current, status: 'approval', askedPerson: true }) : model;
+        return { ...next, pendingApproval: { requestId: event.requestId, toolCallId: event.toolCallId } };
+    }
+    if (event.type === 'approval.resolved') {
+        const pending = model.pendingApproval;
+        if (!pending || pending.requestId !== event.requestId)
+            return model;
+        const id = toolId(pending.toolCallId), current = existing(model, id, 'tool');
+        let next = model;
+        if (current) {
+            /* R3: an approved tool starts running now — its running clock does not count the time the person took to answer. */
+            if (event.approved === true)
+                next = put(model, { ...current, status: 'running', startedAt: Date.now() });
+            /* R3 gate E9: the person's "no" is `denied` with its English reason until the receipt names the exact one. */
+            else if (event.approved === false)
+                next = put(model, { ...current, status: 'denied', endedAt: current.endedAt ?? Date.now(), finalOutput: current.finalOutput || t('error.refused.notApproved') });
+        }
+        return { ...next, pendingApproval: null };
+    }
+    if (event.type === 'warning')
+        return appendTranscriptWarning(model, event.message, event.eventId, event.raw);
+    if (event.type === 'run.started') {
+        let base = model, key = event.runId ?? event.eventId ?? '';
+        if (!key) {
+            const next = localId(model, 'run');
+            key = next.id.slice(4);
+            base = next.model;
+        }
+        if (event.prompt)
+            base = adoptOrAddPrompt(base, key, event.prompt, event.history === true);
+        const known = runsOf(base).find(run => run.key === key);
+        return setRun(base, known ? { ...known, status: 'running' } : { key, runId: event.runId ?? null, status: 'running', history: event.history === true, anchor: base.items.at(-1)?.id ?? null });
+    }
+    if (event.type === 'run.completed' || event.type === 'run.failed' || event.type === 'run.cancelled') {
+        const run = findRun(model, event);
+        let base = model, key = run?.key ?? event.runId ?? event.eventId ?? '';
+        if (!key) {
+            const next = localId(model, 'run');
+            key = next.id.slice(4);
+            base = next.model;
+        }
+        const noticeId = 'run:' + key;
+        /* R5b: before the run's own ending line, the summaries it asked for and none accepted (each one billed). */
+        const current = run ? runsOf(model).find(entry => entry.key === run.key) ?? run : null;
+        if (current?.summaryRequests && !current.summaryAccepted)
+            base = appendTranscriptWarning(base, tn('screen.compaction.summaryNotAccepted', current.summaryRequests), `summary:${key}`);
+        const settle = (next, status) => run ? setRun(next, { ...(current ?? run), status }) : next;
+        /* Q-R3-9: a turn that ended normally leaves no line; one that a stop had marked but then completed drops the mark. */
+        if (event.type === 'run.completed')
+            return settle(closeReasoning({ ...base, items: base.items.filter(item => !(item.id === noticeId && item.kind === 'warning')) }), 'completed');
+        if (event.type === 'run.failed') {
+            base = closeReasoning(base);
+            /* R2 lane E: a failure is worded from its CODE with the stop point of this transcript; the kernel text is the detail. */
+            const view = event.error ? describeError(event.error, { stopPoint: stopPoint(base, run) }) : null;
+            const text = tail(view ? errorViewLines(view).join('\n') : event.message, MAX_WARNING_CHARS);
+            const detail = view?.raw ?? null;
+            return settle(put(base, { kind: 'warning', id: noticeId, text, outcome: 'failed', ...(detail ? { detail: tail(detail, MAX_WARNING_CHARS) } : {}) }), 'failed');
+        }
+        /* Q-R3-8: an interrupt is one neutral line naming where it stopped. A replayed run the kernel reports cut off (TALOS
+           closed mid-answer, R1 lane R D-08) says so; the stop closes whatever the run left streaming. */
+        const point = stopPoint(base, run);
+        const text = event.interrupted === true && run?.history ? t('tool.turn.closed') : point ? t('tool.turn.interruptedWhile', { while: stopPhrase(point) }) : t('tool.turn.interrupted');
+        return settle(put(closeInterrupted(base), { kind: 'warning', id: noticeId, text, outcome: 'interrupted' }), 'interrupted');
+    }
+    return model;
+}

package/dist/tui/ui-preferences.js

@@ -0,0 +1,79 @@
+import { loadEffectiveConfig, writeConfigScope } from "../config/load.js";
+import { DEFAULT_BUSY_INPUT, parseBusyInput } from "./busy-input.js";
+export const DEFAULT_UI_PREFERENCES = Object.freeze({ busyInput: DEFAULT_BUSY_INPUT, reasoning: 'collapsed' });
+export function parseReasoning(value) { return value === 'collapsed' || value === 'visible' ? value : null; }
+/** The effective choices; a configuration that cannot be read gives the defaults (a screen choice never blocks the TUI). */
+export async function loadUiPreferences({ paths, projectRoot }) {
+    try {
+        const ui = (await loadEffectiveConfig({ paths, projectRoot })).value.ui;
+        return { busyInput: parseBusyInput(ui?.busyInput) ?? DEFAULT_UI_PREFERENCES.busyInput, reasoning: parseReasoning(ui?.reasoning) ?? DEFAULT_UI_PREFERENCES.reasoning };
+    }
+    catch {
+        return { ...DEFAULT_UI_PREFERENCES };
+    }
+}
+/* R5a (owner 2026-09-24, as Hermes's `onboarding.seen.busy_input_prompt`): the busy tip is shown once per install. */
+export async function loadBusyTipSeen({ paths, projectRoot }) {
+    try {
+        return (await loadEffectiveConfig({ paths, projectRoot })).value.ui?.busyTipSeen === true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Remember one choice in the user configuration. Throws what the writer throws; the caller says it was not saved. */
+export async function saveUiPreference({ paths, projectRoot, patch }) {
+    const ui = {};
+    if (patch.theme)
+        ui.theme = patch.theme;
+    if (patch.busyInput)
+        ui.busyInput = patch.busyInput;
+    if (patch.reasoning)
+        ui.reasoning = patch.reasoning;
+    if (patch.busyTipSeen === true)
+        ui.busyTipSeen = true;
+    await writeConfigScope({ paths, projectRoot, scope: 'user', patch: { ui } });
+}
+/*
+ * The app's side (E-05: app.ts only wires): the busy-input mode as React state with a ref for the key handlers, the one
+ * read of the remembered choices when main.ts did not pass them (a choice the person makes meanwhile wins), the writes,
+ * and the one-time busy tip. `applyReasoning` shows or hides the reasoning (app state); `onSaveError` reports a write that
+ * failed (the choice still holds for this session).
+ */
+export function useUiPreferences(React, { paths, projectRoot, given, applyReasoning, onSaveError }) {
+    const [busyInput, setBusyInputState] = React.useState(given.busyInput ?? DEFAULT_UI_PREFERENCES.busyInput);
+    const ref = React.useRef({ busyInput, touchedBusy: false, touchedReasoning: false, tipShown: false, onSaveError });
+    ref.current.busyInput = busyInput;
+    ref.current.onSaveError = onSaveError;
+    React.useEffect(() => {
+        if (given.busyInput && given.reasoning)
+            return;
+        let alive = true;
+        void loadUiPreferences({ paths, projectRoot }).then(prefs => {
+            if (!alive)
+                return;
+            if (!given.busyInput && !ref.current.touchedBusy) {
+                ref.current.busyInput = prefs.busyInput;
+                setBusyInputState(prefs.busyInput);
+            }
+            if (!given.reasoning && !ref.current.touchedReasoning)
+                applyReasoning(prefs.reasoning === 'visible');
+        });
+        return () => { alive = false; };
+    }, []);
+    /* R5a: a tip seen in an earlier launch is not shown again. */
+    React.useEffect(() => { let alive = true; void loadBusyTipSeen({ paths, projectRoot }).then(seen => { if (alive && seen)
+        ref.current.tipShown = true; }); return () => { alive = false; }; }, []);
+    const remember = (patch) => { void saveUiPreference({ paths, projectRoot, patch }).catch(error => ref.current.onSaveError(error)); };
+    return {
+        busyInput,
+        /** The mode now, for handlers that run outside a render (a key, a queued command). */
+        currentBusyInput: () => ref.current.busyInput,
+        setBusyInput(mode) { ref.current.touchedBusy = true; ref.current.busyInput = mode; setBusyInputState(mode); remember({ busyInput: mode }); },
+        /** Ctrl+T was pressed: `visible` is the state it leads to. */
+        rememberReasoning(visible) { ref.current.touchedReasoning = true; remember({ reasoning: visible ? 'visible' : 'collapsed' }); },
+        /** True the first time only, per install (the one-time busy tip, Q-R5-7; owner 2026-09-24). */
+        firstBusyEnter() { if (ref.current.tipShown)
+            return false; ref.current.tipShown = true; remember({ busyTipSeen: true }); return true; },
+    };
+}

package/dist/tui/usage-view.js

@@ -0,0 +1,77 @@
+/*
+ * R5a lane S — S1 data wiring and the `/usage` view (owner decisions Q-R5-2, Q-R5-5, Q-R5-8; gate E1).
+ *
+ * `usageFacts` asks lane R's two frozen contracts — `modelProfile({provider,model})` and
+ * `usageSnapshot({state,contextStatus,profile})` — for what the status row and `/usage` show. Before R5a the layout replaced
+ * the turn's usage with the context status (`layoutState={...state,usage:contextStatus??state.usage}`, app.ts:1564 at
+ * 4676d2f59), so a reported `1200 in / 340 out` never reached the screen (gate finding 1); both now go to the snapshot.
+ * A contract body that throws is a figure nobody knows, never a crash of the screen (E1: unknown stays unknown).
+ * `/usage` is a view (Q-R5-8: it runs at once during a turn): tokens, the window with its source and date, the cost with
+ * its source or `cost unknown`, and the compaction count with the rule that produced it (E9: the 50 % threshold is stated
+ * where the window is known).
+ */
+import { t } from "../i18n/index.js";
+import { CONTEXT_ENGINE_MIN_WINDOW, modelProfile } from "../runtime/model-profile.js";
+import { usageSnapshot } from "../runtime/usage-snapshot.js";
+import { shellSafeText } from "./components/terminal-shell.js";
+import { compactTokens, costText, percentText } from "./status-bar.js";
+/** `ollama:qwen3` → {provider:'ollama',model:'qwen3'}; the part after the first colon is the provider's own model id (the
+ *  shape runtime/talos-composition.ts `profileForSelection` matches). A sentinel (`none · /provider`) has no provider. */
+export function splitModelId(id) {
+    const text = String(id ?? ''), at = text.indexOf(':');
+    if (at <= 0 || at === text.length - 1 || /\s/u.test(text))
+        return null;
+    return { provider: text.slice(0, at), model: text.slice(at + 1) };
+}
+export function usageFacts({ model, usage, contextStatus, compactions = 0 }) {
+    let profile = null;
+    const selected = splitModelId(model);
+    try {
+        profile = selected ? modelProfile(selected) : null;
+    }
+    catch {
+        profile = null;
+    }
+    let snapshot = null;
+    try {
+        snapshot = usageSnapshot({ state: { usage, compactions }, contextStatus, profile, model });
+    }
+    catch {
+        snapshot = null;
+    }
+    return { snapshot, profile };
+}
+const number = (value) => typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : null;
+const full = (value) => new Intl.NumberFormat('en-US').format(Math.round(value));
+function sourceWords(profile) {
+    if (!profile)
+        return t('screen.usageView.sourceUnnamed');
+    const id = `screen.usageView.source.${profile.source}`;
+    const named = ['registry', 'provider', 'ollama-show', 'override', 'models.dev'].includes(profile.source) ? t(id) : t('screen.usageView.sourceUnnamed');
+    return profile.date ? t('screen.usageView.sourceDated', { source: named, date: shellSafeText(profile.date) }) : named;
+}
+/** The `/usage` block. Every figure nobody reported says so; nothing is computed here that lane R did not provide. */
+export function usageViewText({ model, facts }) {
+    const { snapshot, profile } = facts;
+    const estimated = (text) => snapshot?.estimated ? t('screen.usageView.estimated', { text }) : text;
+    const input = number(snapshot?.inputTokens), output = number(snapshot?.outputTokens), cached = number(snapshot?.cachedTokens);
+    const unknown = t('screen.statusbar.unknown');
+    const tokens = input === null && output === null ? t('screen.usageView.tokensUnknown') : estimated(cached
+        ? t('screen.usageView.tokensCached', { input: input === null ? unknown : full(input), output: output === null ? unknown : full(output), cached: full(cached) })
+        : t('screen.usageView.tokens', { input: input === null ? unknown : full(input), output: output === null ? unknown : full(output) }));
+    const window = number(snapshot?.windowTokens), percent = number(snapshot?.percent), inUse = number(snapshot?.contextTokens);
+    const context = window === null || window === 0 ? t('screen.usageView.contextUnknown')
+        : inUse === null || percent === null ? t('screen.usageView.contextUsedUnknown', { window: compactTokens(window), source: sourceWords(profile) })
+            : t('screen.usageView.context', { used: estimated(full(inUse)), window: full(window), percent: percentText(percent), source: sourceWords(profile) });
+    const usd = number(snapshot?.costUsd), costSource = typeof snapshot?.costSource === 'string' && snapshot.costSource.trim() ? shellSafeText(snapshot.costSource) : null;
+    const cost = snapshot?.local ? t('screen.usageView.local') : usd !== null && costSource ? t('screen.usageView.cost', { cost: costText(usd), source: costSource }) : t('screen.usageView.costUnknown');
+    const compactions = number(snapshot?.compactions) ?? 0;
+    const rule = window && window >= CONTEXT_ENGINE_MIN_WINDOW ? t('screen.usageView.compactionsEarly', { count: compactions }) : window ? t('screen.usageView.compactionsSmallWindow', { count: compactions }) : t('screen.usageView.compactionsKernel', { count: compactions });
+    return t('screen.usageView.block', { model: shellSafeText(model), tokens, context, cost, compactions: rule });
+}
+/** R5a (owner 2026-09-24): said once per model when its known window is below the Context Engine's 64k; null otherwise. */
+export function smallWindowNotice(profile, model) {
+    if (!profile || profile.windowTokens >= CONTEXT_ENGINE_MIN_WINDOW)
+        return null;
+    return t('screen.context.smallWindow', { model: shellSafeText(model), window: compactTokens(profile.windowTokens), min: compactTokens(CONTEXT_ENGINE_MIN_WINDOW) });
+}