talos-code 0.0.1 → 0.2.0

package/dist/tui/event-adapter.js

@@ -0,0 +1,436 @@
+import { createRedactor } from "../diagnostics/redact.js";
+import { createV2EventBridge } from "../protocol/v2/events.js";
+import { describeError, describeKernelNotice, describeKernelRefusalReason, describeKernelToolText, errorViewLines } from "../i18n/error-view.js";
+import { t } from "../i18n/index.js";
+import { REFUSAL_VIA, looksItalian } from "../i18n/kernel-map.js";
+import { toolDisplay } from "./tool-display.js";
+function objectValue(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+}
+function stringValue(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function booleanValue(value) {
+    return typeof value === 'boolean' ? value : undefined;
+}
+function isCanonicalEvent(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const row = value;
+    return row.schema === 'talos.cli.event.v2' && row.version === 2 && typeof row.sessionId === 'string'
+        && typeof row.eventId === 'string' && typeof row.type === 'string' && Boolean(row.data && typeof row.data === 'object');
+}
+function asToolResult(data) {
+    const receipt = objectValue(data.receipt);
+    const status = data.status;
+    if (typeof data.toolCallId !== 'string' || typeof data.content !== 'string' || typeof status !== 'string' || !receipt)
+        return null;
+    return data;
+}
+function compactToolOutcome(result) {
+    const structured = result.status !== 'completed' || result.receipt.status !== null || result.receipt.allowed !== null
+        || result.receipt.via !== null || result.receipt.reason !== null || result.receipt.risk !== null || result.enforcement !== null;
+    if (!structured)
+        return undefined;
+    return {
+        toolCallId: result.toolCallId,
+        status: result.status,
+        content: result.content,
+        receiptStatus: result.receipt.status,
+        exitCode: result.enforcement?.exitCode ?? null,
+        enforcement: result.enforcement?.sandbox ?? null,
+        allowed: result.receipt.allowed,
+        permissionVia: result.receipt.via,
+        permissionReason: result.receipt.reason,
+        risk: result.receipt.risk,
+    };
+}
+function canonicalError(data) {
+    const row = objectValue(data.error);
+    const envelope = objectValue(row?.envelope);
+    return row && typeof row.message === 'string' && envelope ? row : undefined;
+}
+function identity(event) { return { eventId: event.eventId }; }
+/*
+ * R1 lane R (D-04, gate E9): the kernel records the person's prompt ONLY as `RunStarted.input.consegna` (measured through the
+ * real composition, r1-resume-history.test.ts); no `TextMessageStart role:user` exists, so a replay rebuilt no user message.
+ * The prompt is shown as it was typed: the project-reference blocks `renderPromptWithAttachments` appends
+ * (runtime/attachments.ts:65-70) are cut, the `@path` the person wrote stays. The local runtime passes chat messages instead.
+ */
+const REFERENCE_BLOCKS = '\n\n[TALOS project reference: ', REFERENCE_END = '[End TALOS project reference]';
+function typedPrompt(value) { const cut = value.indexOf(REFERENCE_BLOCKS); return cut >= 0 && value.endsWith(REFERENCE_END) ? value.slice(0, cut) : value; }
+function messageText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return undefined;
+    const parts = content.map(part => objectValue(part)).filter(part => part?.type === 'text' && typeof part.text === 'string').map(part => String(part.text));
+    return parts.length ? parts.join('\n') : undefined;
+}
+export function runPrompt(input) {
+    if (Array.isArray(input)) {
+        for (let i = input.length - 1; i >= 0; i--) {
+            const row = objectValue(input[i]);
+            if (row?.role === 'user')
+                return stringValue(messageText(row.content));
+        }
+        return undefined;
+    }
+    /* R2 lane J (E11): protocol v2 renames `consegna` to `prompt`; the TUI reads both. */
+    const text = stringValue(objectValue(input)?.prompt) ?? stringValue(objectValue(input)?.consegna);
+    return text === undefined ? undefined : stringValue(typedPrompt(text));
+}
+function role(value) { return value === 'user' ? 'user' : 'assistant'; }
+function countOrNull(value) { return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? Math.round(value) : null; }
+/* R5a lane R (S10): a kernel tool id in the screen's words, for the English refusal reasons. */
+const toolLabel = (id) => { try {
+    return toolDisplay(id).label;
+}
+catch {
+    return id;
+} };
+/** The screen's copy of a tool result: the kernel's Italian refusal reason in English (display only; v2 keeps the kernel's). */
+function displayReceipt(result) {
+    const reason = result.receipt.reason;
+    if (!reason)
+        return result;
+    const english = describeKernelRefusalReason(reason, { toolLabel });
+    return english && english !== reason ? { ...result, receipt: { ...result.receipt, reason: english } } : result;
+}
+function projectCanonical(event) {
+    const id = identity(event);
+    const data = event.data;
+    switch (event.type) {
+        case 'run.started': {
+            const runId = stringValue(data.runId), prompt = runPrompt(data.input);
+            return { type: 'run.started', sessionId: event.sessionId, ...(runId ? { runId } : {}), ...(prompt ? { prompt } : {}), ...id };
+        }
+        case 'message.started':
+            return { type: 'message.started', messageId: String(data.messageId ?? 'assistant'), role: role(data.role), ...id };
+        case 'message.delta': {
+            /* R2 lane E (gate E4): a kernel notice arrives as one whole assistant message (no code); only its exact template is
+               replaced, so the model's own words are never touched. */
+            const delta = String(data.delta ?? '');
+            return { type: 'message.delta', messageId: String(data.messageId ?? 'assistant'), delta: describeKernelNotice(delta) ?? delta, ...id };
+        }
+        case 'message.completed':
+            return { type: 'message.end', messageId: String(data.messageId ?? 'assistant'), ...id };
+        case 'reasoning.started':
+            return { type: 'reasoning.started', messageId: String(data.messageId ?? 'reasoning'), ...id };
+        case 'reasoning.delta':
+            return { type: 'reasoning.delta', messageId: String(data.messageId ?? 'reasoning'), delta: String(data.delta ?? ''), ...id };
+        case 'reasoning.completed':
+            return { type: 'reasoning.end', messageId: String(data.messageId ?? 'reasoning'), ...id };
+        case 'tool.started':
+            return { type: 'tool.started', toolCallId: String(data.toolCallId ?? ''), toolName: String(data.toolName ?? 'tool'), ...id };
+        case 'tool.args':
+            return { type: 'tool.args', toolCallId: String(data.toolCallId ?? ''), delta: String(data.delta ?? ''), ...id };
+        case 'tool.output':
+            return { type: 'tool.output', toolCallId: String(data.toolCallId ?? ''), delta: String(data.delta ?? ''), ...id };
+        case 'tool.completed': {
+            const canonical = asToolResult(data);
+            if (!canonical)
+                return null;
+            /* R3 Q-R3-8 (R3-INT): the kernel's stop sentences in English, on the display copy only; a tool the person stopped is
+               `cancelled` (shown as interrupted), never `failed`. The canonical v2 result is untouched. */
+            const shown = describeKernelToolText(canonical.content);
+            const result = displayReceipt(shown.text === canonical.content && !shown.stopped ? canonical : { ...canonical, content: shown.text, ...(shown.stopped ? { status: 'cancelled' } : {}) });
+            const outcome = compactToolOutcome(result);
+            return {
+                type: 'tool.completed', toolCallId: result.toolCallId, content: result.content, result,
+                ...(outcome ? { outcome } : {}), ...id
+            };
+        }
+        case 'file.changed':
+            return { type: 'file.changed', data: { ...data }, ...id };
+        case 'approval.required': {
+            const payload = objectValue(data.azione ?? data.action) ?? {};
+            const toolCallId = stringValue(payload.toolCallId);
+            return {
+                type: 'approval.required',
+                requestId: String(data.requestId ?? ''),
+                payload: { ...payload },
+                ...(toolCallId ? { toolCallId } : {}),
+                ...id
+            };
+        }
+        case 'approval.resolved': {
+            const approved = booleanValue(data.approvato) ?? booleanValue(data.approved);
+            return { type: 'approval.resolved', requestId: String(data.requestId ?? ''), ...(approved !== undefined ? { approved } : {}), ...id };
+        }
+        case 'usage.updated': {
+            /* R5a lane R (S1): the last request's own usage and the run's declared cost ride inside the value (additive keys), so the
+               state keeps one usage object and `usageSnapshot` reads them there. */
+            const value = objectValue(data.value);
+            const lastRequest = objectValue(data.lastRequest);
+            const declared = countOrNull(data.declaredCostUsd) === null ? null : Number(data.declaredCostUsd);
+            if (!value || (!lastRequest && declared === null))
+                return { type: 'usage.updated', value: data.value, ...id };
+            return { type: 'usage.updated', value: { ...value, ...(lastRequest ? { lastRequest: { ...lastRequest } } : {}), ...(declared !== null ? { declaredCostUsd: declared } : {}) }, ...id };
+        }
+        case 'provider.attempt': {
+            const attempt = countOrNull(data.attempt), maxAttempts = countOrNull(data.maxAttempts);
+            if (attempt === null || maxAttempts === null)
+                return null;
+            return { type: 'provider.attempt', attempt, maxAttempts, status: countOrNull(data.status), retryAfterMs: countOrNull(data.retryAfterMs), waitMs: countOrNull(data.waitMs), ...id };
+        }
+        case 'context.summary.requested': return { type: 'context.summary.requested', ...id };
+        case 'context.compaction.paused': {
+            const code = typeof data.code === 'string' ? data.code : '', retryAfter = typeof data.retryAfter === 'string' ? data.retryAfter : '';
+            if (!code || !Number.isFinite(Date.parse(retryAfter)))
+                return null;
+            return { type: 'context.compaction.paused', noticeId: typeof data.noticeId === 'string' ? data.noticeId : null, code, attempts: countOrNull(data.attempts), waitSeconds: countOrNull(data.waitSeconds), retryAfter, ...id };
+        }
+        case 'context.compacted': {
+            const trigger = data.trigger === 'manual' || data.trigger === 'automatic' ? data.trigger : null;
+            return { type: 'context.compacted', engine: data.engine === 'context-engine' ? 'context-engine' : 'kernel', messagesSummarized: countOrNull(data.messagesSummarized),
+                tokensBefore: countOrNull(data.tokensBefore), tokensAfter: countOrNull(data.tokensAfter), ...(trigger ? { trigger } : {}), ...id };
+        }
+        case 'warning': {
+            /* R2 lane E (Q-R2-2): a kernel notice has no code (`onAvviso`, RuntimeFallback): Italian text is replaced by one English
+               sentence and kept as `raw` for the expanded view and the log; the CLI's own English notices pass unchanged. */
+            const message = String(data.message ?? 'warning');
+            return looksItalian(message) ? { type: 'warning', message: t('error.warning.untranslated'), raw: message, ...id } : { type: 'warning', message, ...id };
+        }
+        case 'session.snapshot':
+            return { type: 'session.snapshot', data: { ...data }, ...id };
+        case 'run.completed': {
+            const runId = stringValue(data.runId);
+            return { type: 'run.completed', ...(runId ? { runId } : {}), ...id };
+        }
+        case 'run.failed': {
+            const error = canonicalError(data);
+            const runId = stringValue(data.runId);
+            /* R2 lane E (gate E4, Q-R2-4): the message is the English three-part view of the CODE; the kernel's text rides along
+               only inside `error` (the transcript keeps it as the row's raw detail). */
+            const view = describeError(error ?? { message: String(data.message ?? 'run failed'), code: data.code });
+            return {
+                type: 'run.failed',
+                message: errorViewLines(view).join('\n'),
+                ...(error ? { error } : {}),
+                ...(runId ? { runId } : {}),
+                ...id
+            };
+        }
+        case 'run.cancelled': {
+            const runId = stringValue(data.runId);
+            const reason = stringValue(data.reason);
+            return { type: 'run.cancelled', ...(runId ? { runId } : {}), ...(reason ? { reason } : {}), ...id };
+        }
+        default:
+            return null;
+    }
+}
+/*
+ * R3 gate E3 (Q-R3-1/2): the facts of a finished tool, from structured fields only: the receipt's exit code, the kernel's
+ * measured `durataMs` (v2 `details.durationMs`, talosHarness.mjs:8661), and the isolation named by the glyph the CLI's own
+ * executor puts first in its annotation (`EXECUTION_TEXT.isolation`: ⛉ sandbox, ⛶ host). An absent fact stays absent: a
+ * zero would say "instant" or "exit 0" where the truth is unknown (agui-events.mjs OSS-1).
+ */
+const SANDBOX_GLYPH = '⛉', HOST_GLYPH = '⛶';
+export function isolationOf(enforcement) {
+    if (typeof enforcement !== 'string')
+        return null;
+    const head = enforcement.trimStart();
+    return head.startsWith(SANDBOX_GLYPH) ? 'sandbox' : head.startsWith(HOST_GLYPH) ? 'host' : null;
+}
+function toolFacts(result, noted = null) {
+    const exitCode = result.enforcement?.exitCode, durationMs = objectValue(result.details)?.durationMs, isolation = isolationOf(result.enforcement?.sandbox);
+    const denial = noted ?? kernelDenial(result);
+    const facts = {
+        ...(typeof exitCode === 'number' && Number.isInteger(exitCode) ? { exitCode } : {}),
+        ...(typeof durationMs === 'number' && Number.isFinite(durationMs) && durationMs >= 0 ? { durationMs: Math.round(durationMs) } : {}),
+        ...(isolation ? { isolation } : {}),
+        ...(denial ? { denial } : {}),
+    };
+    return Object.keys(facts).length ? facts : null;
+}
+/*
+ * R5a lane R (S10, gate finding 15). Why a refused tool did not run, from the receipt alone, only when the receipt can say
+ * it: the session's own level (read-only, research, workspace writes, a tool turned off) is `mode`; the kernel's floors (a
+ * command that cannot be undone, the checkpoint guard) are `policy`. An "asked" via is NOT decided here: the kernel writes
+ * the same via and the same sentence whether the person said no or the permission engine answered alone (finding 15), so
+ * only the session controller, which asked, can say which (`noteDenial`). A stop is not a denial.
+ */
+const MODE_VIAS = new Set(['toolOff', 'readOnly', 'research', 'workspaceWrite']);
+const POLICY_VIAS = new Set(['noRecovery', 'checkpoint']);
+function kernelDenial(result) {
+    if (result.receipt.allowed !== false && result.receipt.status !== 'denied')
+        return null;
+    const key = result.receipt.via ? REFUSAL_VIA[result.receipt.via] : undefined;
+    if (!key || (!MODE_VIAS.has(key) && !POLICY_VIAS.has(key)))
+        return null;
+    const english = result.receipt.reason ? describeKernelRefusalReason(result.receipt.reason, { toolLabel }) : null;
+    const reason = english ?? (result.receipt.reason && !looksItalian(result.receipt.reason) ? result.receipt.reason : null);
+    return { by: MODE_VIAS.has(key) ? 'mode' : 'policy', ...(reason ? { reason } : {}) };
+}
+/**
+ * R5a lane R (S10): the denial fact for a decision the permission engine made ALONE (`ApprovalDecision` deny,
+ * security/permission-engine.ts:36-44), in English. A matched deny rule is `rule` with its text (`explain.rule`, e.g. the
+ * rule `simulatePermission` names) and scope; a command the policy cannot split (`unsupported shell composition`,
+ * security/evaluate.ts:134-140) or a path outside the project is `policy`; plan mode, a mode that never asks and the automatic
+ * classifier are `mode`. The person's own "no" is `{by:'person'}`, and nothing else is.
+ */
+export function denialFromEngine(decision, explain = {}) {
+    const code = String(decision?.code ?? '');
+    const message = String(decision?.message ?? '');
+    const because = (id) => ({ by: code === 'PATH_NOT_ALLOWED' || id === 'error.denial.reason.unsupportedShell' || id === 'error.denial.reason.pathOutside' ? 'policy' : 'mode', reason: t(id) });
+    if (code === 'PLAN_MODE_READ_ONLY')
+        return because('error.denial.reason.planMode');
+    if (code === 'PERMISSION_REQUIRED')
+        return because('error.denial.reason.noAsking');
+    if (code === 'PERMISSION_AUTO_DENIED')
+        return because('error.denial.reason.autoDenied');
+    if (code === 'PATH_NOT_ALLOWED')
+        return because('error.denial.reason.pathOutside');
+    if (/(?:^|: )matched deny rule$/u.test(message)) {
+        let rule = null;
+        try {
+            rule = explain.rule?.() ?? null;
+        }
+        catch {
+            rule = null;
+        }
+        let scope = null;
+        try {
+            scope = rule ? explain.scope?.(rule) ?? null : null;
+        }
+        catch {
+            scope = null;
+        }
+        return { by: 'rule', ...(rule ? { rule } : {}), ...(scope ? { scope } : {}) };
+    }
+    if (/unsupported shell composition$/u.test(message))
+        return because('error.denial.reason.unsupportedShell');
+    if (/write path is outside the authorized project$/u.test(message))
+        return because('error.denial.reason.pathOutside');
+    return { by: 'policy', ...(message && !looksItalian(message) ? { reason: message } : {}) };
+}
+/*
+ * R3 gate E10 (Q-R3-4): a file the kernel wrote arrives as `StateDelta` rows `/file/<path>` with the text after and, for a
+ * file that existed, the text before (`prima`) (agui-events.mjs:427-436); the v2 bridge keeps only `/usage`, so the TUI
+ * reads the rows here, through the same redactor as every v2 string. A replaced file whose before is unknown is skipped
+ * (it must not look new); texts over MAX_FILE_CHANGE_CHARS are skipped (the diff of a huge file is not a screen). The change
+ * belongs to the open tool call whose arguments name the same path, or else to the only open call.
+ */
+const MAX_FILE_CHANGE_CHARS = 1_000_000, MAX_OPEN_ARGS_CHARS = 65_536;
+function samePath(value) { return value.replace(/\\/gu, '/').replace(/^\.\//u, ''); }
+function argsPath(args) {
+    try {
+        const parsed = objectValue(JSON.parse(args));
+        const value = parsed?.percorso ?? parsed?.path ?? parsed?.file_path;
+        return typeof value === 'string' && value ? samePath(value) : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function createTuiEventAdapter(secretValues = []) {
+    let currentSessionId = null;
+    let bridge = null;
+    const redactor = createRedactor(secretValues);
+    const openTools = new Map();
+    /* R5a lane R (S10): the denial facts the session controller noted, by tool call, until the tool's result arrives. */
+    const noted = new Map();
+    /* R5a lane R (S3): the kernel compactions seen live in this run (the fetch observer's event). */
+    let liveKernelCompactions = 0;
+    function bindSession(sessionId) {
+        if (typeof sessionId !== 'string' || sessionId.length === 0)
+            throw new Error('SESSION_ID_REQUIRED');
+        if (sessionId === currentSessionId && bridge)
+            return;
+        currentSessionId = sessionId;
+        openTools.clear();
+        noted.clear();
+        liveKernelCompactions = 0;
+        bridge = createV2EventBridge(sessionId, undefined, secretValues);
+    }
+    function canonicalOf(raw) {
+        if (isCanonicalEvent(raw))
+            return raw;
+        if (!raw || typeof raw !== 'object' || !bridge)
+            return null;
+        return bridge.translate(raw);
+    }
+    function translate(raw) {
+        const canonical = canonicalOf(raw);
+        return canonical ? projectCanonical(canonical) : null;
+    }
+    /**
+     * R5a lane R (S10): the session controller tells the adapter who refused a tool BEFORE its result arrives — the person
+     * (`{by:'person'}`, only after asking) or the engine alone (`denialFromEngine`). The next `tool.facts` of that call carries it.
+     */
+    function noteDenial(toolCallId, denial) {
+        if (typeof toolCallId !== 'string' || !toolCallId || !denial)
+            return;
+        noted.set(toolCallId, denial);
+        if (noted.size > 256)
+            noted.delete(noted.keys().next().value);
+    }
+    function fileChanges(raw) {
+        if (raw.type !== 'StateDelta' || !Array.isArray(raw.delta))
+            return [];
+        const out = [];
+        for (const entry of raw.delta) {
+            const row = objectValue(entry);
+            const where = stringValue(row?.path);
+            if (!row || !where?.startsWith('/file/') || typeof row.value !== 'string' || (row.op !== 'add' && row.op !== 'replace'))
+                continue;
+            const before = row.op === 'add' ? null : typeof row.prima === 'string' ? row.prima : undefined;
+            if (before === undefined || row.value.length > MAX_FILE_CHANGE_CHARS || (before?.length ?? 0) > MAX_FILE_CHANGE_CHARS)
+                continue;
+            const path = where.slice('/file/'.length);
+            const owners = [...openTools].filter(([, args]) => argsPath(args) === samePath(path)).map(([id]) => id);
+            /* The call whose arguments name the path; failing that, the only open call (lane RD matches by path otherwise). */
+            const owner = owners.length === 1 ? owners[0] : owners.length === 0 && openTools.size === 1 ? [...openTools.keys()][0] : undefined;
+            const change = { path: redactor.text(path), before: before === null ? null : redactor.text(before), after: redactor.text(row.value), ...(owner ? { toolCallId: owner } : {}) };
+            out.push({ type: 'file.changed', change });
+        }
+        return out;
+    }
+    function translateAll(raw) {
+        const canonical = canonicalOf(raw);
+        const event = canonical ? projectCanonical(canonical) : null;
+        const out = event ? [event] : [];
+        if (event?.type === 'run.started')
+            liveKernelCompactions = 0;
+        else if (event?.type === 'context.compacted' && event.engine === 'kernel' && event.trigger !== 'manual')
+            liveKernelCompactions++;
+        if (event?.type === 'run.completed') {
+            /* R5a lane R (S3): the kernel counts its own compactions in the run's result (`compattazioni` → v2 `compactions`,
+               agent-service.mjs:182). A compaction the live observer did not report — every one, in a replay, where live events do
+               not exist — is named here, before the run ends, with what is known: nothing but that it happened. */
+            const total = countOrNull(objectValue(objectValue(canonical?.data)?.result)?.compactions) ?? 0;
+            const missing = Math.max(0, total - liveKernelCompactions);
+            for (let i = 0; i < missing; i++)
+                out.unshift({ type: 'context.compacted', engine: 'kernel', messagesSummarized: null, tokensBefore: null, tokensAfter: null, trigger: 'automatic' });
+            liveKernelCompactions = 0;
+        }
+        if (event?.type === 'tool.started')
+            openTools.set(event.toolCallId, '');
+        else if (event?.type === 'run.completed' || event?.type === 'run.failed' || event?.type === 'run.cancelled')
+            openTools.clear();
+        else if (event?.type === 'tool.args' && openTools.has(event.toolCallId))
+            openTools.set(event.toolCallId, (openTools.get(event.toolCallId) + event.delta).slice(0, MAX_OPEN_ARGS_CHARS));
+        else if (event?.type === 'tool.completed') {
+            openTools.delete(event.toolCallId);
+            const denial = noted.get(event.toolCallId) ?? null;
+            noted.delete(event.toolCallId);
+            const facts = event.result ? toolFacts(event.result, denial) : null;
+            if (facts)
+                out.push({ type: 'tool.facts', toolCallId: event.toolCallId, facts });
+            /* R5a lane R (Q-R5-10/11): the cut the model read, as facts the row states (the v2 result carries them). */
+            const saved = event.result?.outputSaved;
+            if (saved?.path)
+                out.push({ type: 'tool.output.saved', toolCallId: event.toolCallId, path: saved.path, keptChars: saved.keptChars, totalChars: saved.totalChars });
+            const cut = event.result?.readCut;
+            if (cut)
+                out.push({ type: 'tool.read.cut', toolCallId: event.toolCallId, shownLines: cut.shownLines, totalLines: cut.totalLines, limitChars: cut.limitChars });
+        }
+        const row = objectValue(raw);
+        if (row && !isCanonicalEvent(raw))
+            out.push(...fileChanges(row));
+        return out;
+    }
+    return { bindSession, translate, translateAll, noteDenial };
+}

package/dist/tui/exit-output.js

@@ -0,0 +1,58 @@
+import { sanitizeTranscriptText } from "./transcript-model.js";
+import { toolRowView } from "./components/tool-row.js";
+/* The resume line is pasted into a shell, so the id must be one shell word: the pattern `talos session import`
+   already enforces for archive ids (session-cli.ts), no leading dash, no `..`. */
+const SESSION_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u;
+const TOOL_ARGS_MAX = 72;
+/* R3 gate E1: a tool row is the ONE row formatter's line, fitted to this width (the target is cut in the middle first). */
+export const EXIT_TOOL_WIDTH = 120;
+const hasText = (item) => item.kind === 'message' && item.text.trim().length > 0;
+/** The id worth printing as `talos --resume <id>`: valid, and only for a session that holds a message (Qwen gating,
+ *  startInteractiveUI.tsx:421-449 @2026-09-15, gate C10). */
+export function resumableSessionId(snapshot) {
+    const id = snapshot?.sessionId;
+    if (!id || !SESSION_ID.test(id) || id.includes('..'))
+        return null;
+    return snapshot.items.some(hasText) ? id : null;
+}
+const oneLine = (value, max) => { const text = sanitizeTranscriptText(value).replace(/\s+/gu, ' ').trim(); return text.length > max ? text.slice(0, max - 1) + '…' : text; };
+export function formatExitOutput(snapshot, { mode = 'transcript', color = false } = {}) {
+    if (!snapshot || !snapshot.items.some(hasText))
+        return '';
+    const bold = (text) => color ? `\u001b[1m${text}\u001b[22m` : text;
+    const dim = (text) => color ? `\u001b[2m${text}\u001b[22m` : text;
+    const id = resumableSessionId(snapshot);
+    const resume = id ? `${dim('To resume this session:')} talos --resume ${id}\n` : '';
+    if (mode === 'resume')
+        return resume;
+    /* Blocks are separated by one blank line; consecutive one-line rows (tools, run outcomes) stay together. Reasoning
+       and local notices (help, /status, warnings) are screen chrome, not the conversation, so they are left out. */
+    const blocks = [];
+    let rows = null;
+    const row = (text) => { if (!rows) {
+        rows = [];
+        blocks.push(rows);
+    } rows.push(dim(text)); };
+    for (const item of snapshot.items) {
+        if (item.kind === 'message') {
+            if (!hasText(item))
+                continue;
+            rows = null;
+            blocks.push([bold(item.role === 'user' ? 'You' : 'TALOS'), ...sanitizeTranscriptText(item.text).replace(/\s+$/u, '').split('\n')]);
+        }
+        else if (item.kind === 'tool') {
+            /* R3 gate E1 (R2 Q-R2-3 kept): the same header row as the screen — English label, primary argument, facts; never the
+               kernel name, raw JSON or the enum. The detail lines stay on the screen. */
+            row(toolRowView(item, EXIT_TOOL_WIDTH, false).line);
+        }
+        else if (item.kind === 'warning' && item.outcome) {
+            /* R3 Q-R3-8/9: a turn that did not end normally leaves its one line (its first line: the headline). */
+            row(oneLine(item.text.split(/\r?\n/u)[0] ?? '', EXIT_TOOL_WIDTH));
+        }
+        else if (item.kind === 'run' && (item.status === 'failed' || item.status === 'cancelled')) {
+            const message = oneLine(item.message.split(/\r?\n/u)[0] ?? '', TOOL_ARGS_MAX);
+            row(`Run ${item.status}${message ? ` · ${message}` : ''}`);
+        }
+    }
+    return blocks.map(block => block.join('\n') + '\n').join('\n') + (resume ? `\n${resume}` : '');
+}

package/dist/tui/external-editor.js

@@ -0,0 +1,53 @@
+import { spawnSync } from 'node:child_process';
+import { readFile, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+export function parseEditorCommand(value) { const out = []; let token = '', quote = ''; for (let i = 0; i < value.length; i++) {
+    const ch = value[i];
+    if (quote) {
+        if (ch === quote) {
+            quote = '';
+            continue;
+        }
+        if (ch === '\\' && quote === '"' && i + 1 < value.length) {
+            token += value[++i];
+            continue;
+        }
+        token += ch;
+        continue;
+    }
+    if (ch === '"' || ch === "'") {
+        quote = ch;
+        continue;
+    }
+    if (/\s/u.test(ch)) {
+        if (token) {
+            out.push(token);
+            token = '';
+        }
+        continue;
+    }
+    if (ch === '\\' && i + 1 < value.length) {
+        token += value[++i];
+        continue;
+    }
+    token += ch;
+} if (quote)
+    throw Object.assign(new Error('EXTERNAL_EDITOR_PARSE_FAILED'), { code: 'EXTERNAL_EDITOR_PARSE_FAILED' }); if (token)
+    out.push(token); if (out.length === 0)
+    throw Object.assign(new Error('EXTERNAL_EDITOR_NOT_CONFIGURED'), { code: 'EXTERNAL_EDITOR_NOT_CONFIGURED' }); return out; }
+export async function editExternally({ text, editor, tmpRoot, spawn = spawnSync }) {
+    if (!editor?.trim())
+        throw Object.assign(new Error('EXTERNAL_EDITOR_NOT_CONFIGURED'), { code: 'EXTERNAL_EDITOR_NOT_CONFIGURED' });
+    const [command, ...args] = parseEditorCommand(editor);
+    const file = join(tmpRoot, `talos-editor-${process.pid}-${Date.now()}.txt`);
+    await writeFile(file, text, { encoding: 'utf8', mode: 0o600 });
+    try {
+        const result = spawn(command, [...args, file], { stdio: 'inherit', shell: false, windowsHide: false });
+        if (result.status !== 0)
+            throw Object.assign(new Error('EXTERNAL_EDITOR_FAILED'), { code: 'EXTERNAL_EDITOR_FAILED' });
+        return await readFile(file, 'utf8');
+    }
+    finally {
+        await rm(file, { force: true });
+    }
+}

package/dist/tui/file-completion.js

@@ -0,0 +1,89 @@
+import { readdir, stat } from 'node:fs/promises';
+import { isAbsolute, resolve } from 'node:path';
+import { t } from "../i18n/index.js";
+import { isPathInsideWorkspace, resolvePathInsideWorkspace, resolveWorkspaceIdentity } from "../security/workspace-identity.js";
+import { pickerSection } from "./overlays/scroll-window.js";
+import { buildProjectFileIndex, rankProjectFiles } from "./project-file-index.js";
+/** The most rows the list takes, border and title included (E13: inside the R1 budget, which may give it fewer). */
+export const FILE_COMPLETION_MAX_ROWS = 10;
+const UNSAFE_NAME = /[\x00-\x1f\x7f\p{Zl}\p{Zp}\p{Bidi_Control}]/u;
+/** The typed path after `@`: quotes removed, `\` read as `/`, repeated slashes collapsed; `folder` keeps its final `/`. */
+export function projectPathQuery(token) {
+    const raw = (token.startsWith('@') ? token.slice(1) : token).replace(/^['"]|['"]$/gu, '').replace(/\\/gu, '/').replace(/\/{2,}/gu, '/');
+    const slash = raw.lastIndexOf('/');
+    return { path: raw, folder: slash >= 0 ? raw.slice(0, slash + 1) : '', prefix: raw.slice(slash + 1) };
+}
+function displayValue(path, directory) { const value = path + (directory ? '/' : ''); return /\s/u.test(value) ? `@"${value}"` : `@${value}`; }
+export async function completeProjectPath(projectRoot, token) {
+    const workspace = await resolveWorkspaceIdentity({ projectRoot });
+    const { path: raw, folder, prefix } = projectPathQuery(token);
+    if (isAbsolute(raw) || /^[A-Za-z]:/u.test(raw))
+        return [];
+    const logicalParent = resolve(workspace.requestedRoot, folder || '.');
+    if (!isPathInsideWorkspace(workspace, logicalParent))
+        return [];
+    const parent = await resolvePathInsideWorkspace(workspace, logicalParent);
+    if (!parent)
+        return [];
+    let entries;
+    try {
+        entries = await readdir(parent, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const rows = [];
+    for (const entry of entries) {
+        if (!entry.name.startsWith(prefix) || UNSAFE_NAME.test(entry.name))
+            continue;
+        const canonical = await resolvePathInsideWorkspace(workspace, resolve(parent, entry.name));
+        if (!canonical)
+            continue;
+        let info;
+        try {
+            info = await stat(canonical);
+        }
+        catch {
+            continue;
+        }
+        if (!info.isDirectory() && !info.isFile())
+            continue;
+        rows.push({ name: entry.name, directory: info.isDirectory() });
+    }
+    return rows.sort((a, b) => Number(a.directory) - Number(b.directory) || a.name.localeCompare(b.name)).map(entry => ({ value: displayValue(folder + entry.name, entry.directory), directory: entry.directory }));
+}
+/*
+ * R5b D6 (Q-R5-16; plan Part III items 2 and 5): `@` with part of a name searches the whole project (project-file-index.ts);
+ * `@` alone and `@folder/` still browse one folder (R4). The list says where its rows come from and how many it found, and
+ * shows at most PROJECT_COMPLETION_SHOWN of them, saying so when there are more.
+ */
+export const PROJECT_COMPLETION_SHOWN = 50;
+export async function completeProjectFiles(projectRoot, token, { index } = {}) {
+    const query = projectPathQuery(token);
+    if (!query.path || query.path.endsWith('/'))
+        return { rows: await completeProjectPath(projectRoot, token), source: { kind: 'folder', folder: query.folder } };
+    if (isAbsolute(query.path) || /^[A-Za-z]:/u.test(query.path) || query.path.split('/').includes('..'))
+        return { rows: [], source: { kind: 'project', found: 0, shown: 0, capped: false, max: 0 } };
+    const built = await (index ? index() : buildProjectFileIndex(projectRoot));
+    const ranked = rankProjectFiles(built, query.path);
+    const shown = ranked.slice(0, PROJECT_COMPLETION_SHOWN);
+    return { rows: shown.map(entry => ({ value: displayValue(entry.path, entry.directory), directory: entry.directory })), source: { kind: 'project', found: ranked.length, shown: shown.length, capped: built.capped, max: built.max } };
+}
+function sourceLine(source) {
+    if (source.kind === 'folder')
+        return { text: t('screen.completion.sourceFolder', { folder: source.folder || t('screen.completion.thisFolder') }), tone: 'dim' };
+    const base = source.shown < source.found ? t('screen.completion.sourceProjectMore', { shown: source.shown, found: source.found }) : t('screen.completion.sourceProject', { found: source.found });
+    return { text: base + (source.capped ? t('screen.completion.sourceCapped', { max: source.max.toLocaleString('en-US') }) : ''), tone: 'dim' };
+}
+/* The list as app.ts draws it (single border, like the command menu), fitted by overlays/scroll-window.ts to at most
+   FILE_COMPLETION_MAX_ROWS and the R1 budget, the highlight kept in view; with nothing to offer, one dim line says so
+   (Q-R4-13: `No files match src/x`, gate §5). */
+export function fileCompletionOverlay({ token, rows, selected, source }) {
+    const head = [{ text: t('screen.completion.title'), tone: 'strong' }, ...(source ? [sourceLine(source)] : [])];
+    if (!rows.length) {
+        const query = projectPathQuery(token);
+        const text = query.prefix ? t('screen.completion.none', { path: query.path }) : t('screen.completion.emptyFolder', { folder: query.folder || t('screen.completion.thisFolder') });
+        return { head, sections: [{ lines: [{ text, tone: 'dim' }] }], borderStyle: 'single' };
+    }
+    return { head, sections: [pickerSection(rows, selected, row => row.value)], borderStyle: 'single' };
+}

package/dist/tui/focus-manager.js

@@ -0,0 +1,5 @@
+export function focusForOverlay(overlay) { return overlay === 'model' ? 'model-picker' : overlay === 'provider' ? 'provider-picker' : overlay === 'session' ? 'session-picker' : overlay; }
+export function createFocusState(initial) { return { current: initial, stack: [] }; }
+export function openFocus(state, next) { return next === state.current ? state : { current: next, stack: [...state.stack, state.current] }; }
+export function closeFocus(state) { const previous = state.stack.at(-1); if (!previous)
+    return state; return { current: previous, stack: state.stack.slice(0, -1) }; }