talos-code 0.0.1 → 0.2.0

package/dist/tui/session-export.js

@@ -0,0 +1,54 @@
+/*
+ * R5b D1 (owner decision Q-R5-12): `/export [md|json|jsonl] [file]` in the TUI. Markdown by default (the readable form of
+ * sessions/export-format.ts: the person's messages, TALOS's answers, tools in English); JSON and JSONL are the kernel's own
+ * rows. With no file, `talos-session-<first 8 of the id>-<YYYYMMDD-HHMM>.<ext>` in the project folder; a relative file is
+ * taken from the project folder. Secrets are redacted in every format.
+ */
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
+import { createRedactor } from "../diagnostics/redact.js";
+import { exportMarkdown } from "../sessions/export-format.js";
+const FORMATS = ['md', 'json', 'jsonl'];
+/** `/export` arguments: a format word and/or a file, in any order; `format:null` for a word that is not a format or file. */
+export function parseExportArgs(args) {
+    let format = null, file = null;
+    for (const arg of args) {
+        const word = arg.toLowerCase();
+        if (FORMATS.includes(word) && format === null) {
+            format = word;
+            continue;
+        }
+        if (/[\\/.]/u.test(arg) && file === null) {
+            file = arg;
+            continue;
+        }
+        return { format: null, file: null };
+    }
+    if (format === null && file) {
+        const ext = /\.(md|json|jsonl)$/iu.exec(file)?.[1]?.toLowerCase();
+        format = ext ?? 'md';
+    }
+    return { format: format ?? 'md', file };
+}
+const pad = (n) => String(n).padStart(2, '0');
+function defaultName(sessionId, format, now) {
+    const stamp = `${now.getUTCFullYear()}${pad(now.getUTCMonth() + 1)}${pad(now.getUTCDate())}-${pad(now.getUTCHours())}${pad(now.getUTCMinutes())}`;
+    return `talos-session-${sessionId.slice(0, 8)}-${stamp}.${format}`;
+}
+export async function exportSession({ runtime, sessionId, projectRoot, args, now = new Date(), secrets }) {
+    const { format, file } = parseExportArgs(args);
+    if (!format)
+        throw Object.assign(new Error('EXPORT_USAGE'), { code: 'EXPORT_USAGE' });
+    const payload = sessionId ? runtime.export(sessionId) : null;
+    if (!sessionId || !payload)
+        throw Object.assign(new Error('SESSION_NOT_FOUND'), { code: 'SESSION_NOT_FOUND' });
+    const redactor = createRedactor(secrets);
+    const events = Array.isArray(payload.eventi) ? payload.eventi : [];
+    const body = format === 'md' ? exportMarkdown(payload, { secrets })
+        : format === 'json' ? `${JSON.stringify(redactor.value(payload), null, 2)}\n`
+            : events.map(event => JSON.stringify(redactor.value(event))).join('\n') + (events.length ? '\n' : '');
+    const target = file ? (isAbsolute(file) ? file : resolve(projectRoot, file)) : join(projectRoot, defaultName(sessionId, format, now));
+    await mkdir(dirname(target), { recursive: true });
+    await writeFile(target, body, 'utf8');
+    return { path: target, format };
+}

package/dist/tui/setup-wizard.js

@@ -0,0 +1,46 @@
+/*
+ * P17 (owner, 2026-09-25: "mini procedura guidata semplicissima al fresh install"; decisions of 2026-09-26). The first launch
+ * chains the windows that already exist: trust (the screen before anything loads) → provider → key or local engine → model,
+ * one window at a time with "Step N of 4"; Enter goes on, Esc skips the step, Ctrl+C quits, and what was done stays saved.
+ * Only the missing steps run: a key already usable (from the environment too) or a local engine that answers skips them; a
+ * credential that exists but is benched is explained by the first frame's line, not asked again (Hermes #113720).
+ * Read on 2026-09-26: Claude Code (welcome, theme, login, security notes, terminal setup, trust), Codex (welcome, auth,
+ * trust), Hermes (provider + model through the same picker as `hermes model`, skippable, `hermes setup` to redo), Pi (theme
+ * and analytics, providers later), OpenCode (no wizard), Gemini CLI (theme, then auth). `/setup` redoes it (Hermes'
+ * `hermes setup`). Without an interactive terminal it never runs (clig.dev: "never require a prompt").
+ */
+import { t } from "../i18n/index.js";
+export const SETUP_TOTAL = 4;
+const INDEX = { trust: 1, provider: 2, key: 3, model: 4 };
+const NAME = { trust: 'firstrun.setup.stepName.trust', provider: 'firstrun.setup.stepName.provider', key: 'firstrun.setup.stepName.key', model: 'firstrun.setup.stepName.model' };
+/** The line that tells where the person is in the setup; `escSkips:false` when Esc does something else there. */
+export function setupStepLine(step, { escSkips = true } = {}) {
+    return t(escSkips ? 'firstrun.setup.stepLine' : 'firstrun.setup.stepLineOnly', { index: INDEX[step], total: SETUP_TOTAL, name: t(NAME[step]) });
+}
+/** The same window, with the setup's step on top (the window's own title stays under it). */
+export function setupOverlay(content, step, options = {}) {
+    return { ...content, head: [{ text: setupStepLine(step, options), tone: 'title' }, ...(content.head ?? [])] };
+}
+/**
+ * Whether the first launch runs the setup, and from which step. `providerUsable`: the chosen provider has a key usable now
+ * (from the environment too) or needs none; `keyBenched`: it has a key that does not work now (explained, not asked again).
+ */
+export function setupStart(input) {
+    if (!input.firstLaunch)
+        return { start: false };
+    if (!input.providerChosen)
+        return { start: true, from: 'provider' };
+    if (input.keyBenched)
+        return { start: false };
+    if (!input.providerUsable)
+        return { start: true, from: 'key' };
+    if (!input.modelChosen)
+        return { start: true, from: 'model' };
+    return { start: false };
+}
+/** What the setup says when it ends: ready with the model, or where to pick it up again. */
+export function setupEndLines(outcome) {
+    if (!outcome.ready)
+        return [t('firstrun.setup.skipped')];
+    return [t('firstrun.setup.ready', { model: outcome.model }), t('firstrun.setup.readyHints')];
+}

package/dist/tui/shell-input.js

@@ -0,0 +1,35 @@
+import { routeInput } from "./input-router.js";
+/*
+ * R4 Q-R4-4 (owner, 2026-09-24): a key pressed while the boot is on screen.
+ * - Space, Enter and Esc only skip: the person asked for the composer, not for a space, a send or an interrupt. Measured before
+ *   R4: the key that skipped the boot was also typed into the composer (`│> x`, gate §0.5).
+ * - A printable key skips AND stays as type-ahead, also before the runtime is ready (Codex keeps startup drafts, openai/codex
+ *   #46750, 2026-09-20). Once the boot is skipped and TALOS still waits for the runtime, a space is part of what is typed.
+ * - Ctrl+C and Ctrl+D always reach the exit rule (interrupt.ts): the way out is never blocked by the boot.
+ * - Any other key skips; it is routed only once the runtime is ready, as before R4 (an action before the runtime exists had
+ *   nothing to act on). Enter while waiting sends nothing.
+ */
+const CONTROL = /^[\x00-\x1f\x7f]/u;
+function printable(ch, key) {
+    if (typeof ch !== 'string' || ch.length === 0 || CONTROL.test(ch))
+        return false;
+    return !key.ctrl && !key.meta && !key.return && !key.escape && !key.tab && !key.backspace && !key.delete
+        && !key.upArrow && !key.downArrow && !key.leftArrow && !key.rightArrow && !key.pageUp && !key.pageup && !key.pageDown && !key.pagedown && !key.home && !key.end;
+}
+export function decideShellInput(input) {
+    const { ch, key, focus, composerText, commandMenuOpen, trustCenterOpen, approvalExpanded, boot, keymap } = input;
+    const base = { skipBoot: false, closeTrustCenter: false, approvalScrollDelta: null, routed: null };
+    if (trustCenterOpen)
+        return { ...base, closeTrustCenter: Boolean(key.escape || key.return || ch.toLowerCase() === 'q') };
+    if (focus === 'approval' && approvalExpanded && (key.pageUp || key.pageup || key.pageDown || key.pagedown || key.upArrow || key.downArrow)) {
+        const delta = (key.pageDown || key.pagedown) ? 4 : (key.pageUp || key.pageup) ? -4 : key.downArrow ? 1 : -1;
+        return { ...base, approvalScrollDelta: delta };
+    }
+    const lower = typeof ch === 'string' ? ch.toLowerCase() : '';
+    const exitKey = Boolean(key.ctrl && (lower === 'c' || lower === 'd'));
+    const onlySkips = !boot.skipped && Boolean(key.return || key.escape || ch === ' ');
+    const bootActive = boot.phase !== 'ready' && boot.phase !== 'error';
+    const skipBoot = bootActive && !boot.skipped;
+    const forwarded = !bootActive || exitKey || (!onlySkips && (printable(ch, key) || boot.runtimeReady));
+    return { ...base, skipBoot, routed: forwarded ? routeInput({ ch, key, focus, composerText, commandMenuOpen, keymap }) : null };
+}

package/dist/tui/shell-layout.js

@@ -0,0 +1,48 @@
+import { assistantStreamView } from "./components/assistant-stream.js";
+import { composerDisplay } from "./components/composer.js";
+import { mainRosterLine, queueRosterLine, terminalShortcutStrip } from "./components/terminal-shell.js";
+import { thinkingRowText } from "./components/thinking-row.js";
+import { transcriptWindow } from "./components/transcript.js";
+import { deriveLiveActivity } from "./live-activity.js";
+import { queuedActionPreview } from "./shell-model.js";
+import { statusBar } from "./status-bar.js";
+export function shellDimensions(terminalRows, terminalColumns) {
+    const rows = Math.max(8, Number(terminalRows) - 15);
+    const columns = Math.max(20, Number(terminalColumns));
+    return { rows, columns, desiredPageSize: Math.max(4, Math.floor(rows / 2)) };
+}
+export function pickerWindow(rows, selected, size = 10) {
+    const start = Math.max(0, Math.min(Math.max(0, rows.length - size), selected - Math.floor(size / 2)));
+    return { start, rows: rows.slice(start, start + size) };
+}
+/*
+ * The chrome of one frame, Ink-free. R5a (lane S):
+ *   - S1 (Q-R5-2): the last row is the status row — `Full access · No sandbox · model X · ↑in ↓out · ctx … · ~$… · cmp N ·
+ *     N new` — from lane R's usage snapshot. Before R5a the footer held the workspace path and `session <uuid>` and the
+ *     roster's right edge a context label that the context status had replaced (gate finding 1, review D-14).
+ *   - S9 (D-14): the path stays in the header only, the session id is in /status and in the resume line at exit, the main
+ *     roster row no longer repeats the model, and the activity row is shown only when it has something to say.
+ *   - S5 (Q-R5-7): while a turn runs, the shortcut strip says what Enter does in the busy-input mode.
+ */
+export function deriveShellLayout(input) {
+    const { state, appState, viewport, queuedActions, busySince, bullet, branch } = input;
+    const { rows, columns, desiredPageSize } = shellDimensions(input.terminalRows, input.terminalColumns);
+    const messages = transcriptWindow(state.messages, viewport);
+    const live = assistantStreamView(state.streamingAssistant);
+    const reasoning = thinkingRowText(state.reasoning?.text ?? '', appState.reasoningVisible);
+    const bar = statusBar({ snapshot: input.snapshot ?? null, model: state.status.model, width: columns, safety: input.safety ?? { fullAccess: false, noSandbox: false }, unseen: viewport.unseen });
+    const activity = deriveLiveActivity(state, busySince);
+    const visual = composerDisplay(appState.editor);
+    /* While the approval dialog is open Enter and Esc answer the dialog, so the busy line would be wrong: the R3 strip stays. */
+    const busyInput = input.busyInput && !state.waitingForPerson ? input.busyInput : null;
+    const shortcutLine = terminalShortcutStrip({ mode: state.status.permissionMode, running: state.running, queueCount: queuedActions.length, width: columns, ...(busyInput ? { busyInput } : {}) });
+    const rosterLine = mainRosterLine({ kind: activity.kind, model: null, width: columns, marker: bullet });
+    const queueLine = queueRosterLine({ count: queuedActions.length, preview: queuedActions[0] ? queuedActionPreview(queuedActions[0].text) : null, width: columns, marker: branch });
+    return {
+        rows, columns, desiredPageSize, messages, live, reasoning, statusBar: bar, footerLine: bar.text, activity,
+        showActivity: activity.kind !== 'idle' || input.exitHint === true,
+        visual, shortcutLine, rosterLine, queueLine,
+        toolRowsLimit: Math.max(2, Math.floor(rows / 3)),
+        pickerRowsLimit: Math.max(4, Math.min(12, rows - 4)),
+    };
+}

package/dist/tui/shell-model.js

@@ -0,0 +1,98 @@
+import { t } from "../i18n/index.js";
+import { formatPermissionSimulation, simulatePermission } from "../security/permission-explanation.js";
+import { createEditorState, replaceRange } from "./editor.js";
+import { permissionModeLabel } from "./components/terminal-shell.js";
+import { closeFocus, createFocusState, focusForOverlay, openFocus } from "./focus-manager.js";
+import { filterItems } from "./selection-list.js";
+import { parseSlashCommand } from "./slash-commands.js";
+import { statusFactLines } from "./status-view.js";
+const QUEUE_TERMINAL_UNSAFE = /[\x00-\x1f\x7f-\x9f\u2028\u2029\p{Bidi_Control}\p{Default_Ignorable_Code_Point}]/gu;
+export const MODEL_ID = /^[A-Za-z0-9._-]+:[A-Za-z0-9][A-Za-z0-9._/:@-]*$/u;
+/* R2: sentinel values compared by identity AND shown on the status row, so they come from the dictionary once. */
+export const NO_PROVIDER_MODEL = t('screen.model.noneProvider');
+export const NO_MODEL = t('screen.model.noneModel');
+export function queuedActionPreview(value) {
+    return String(value).replace(QUEUE_TERMINAL_UNSAFE, character => {
+        if (character === '\n' || character === '\r' || character === '\t')
+            return ' ';
+        const code = character.codePointAt(0);
+        return code > 0xffff ? `\\u{${code.toString(16)}}` : `\\u${code.toString(16).padStart(4, '0')}`;
+    }).replace(/\s{2,}/gu, ' ').trim();
+}
+export function openOverlay(state, overlay) {
+    return { ...state, overlay, focus: openFocus(state.focus, focusForOverlay(overlay.kind)) };
+}
+export function createTuiAppState(editor = createEditorState('')) { return { editor, overlay: null, focus: createFocusState('composer'), reasoningVisible: false, expandedTools: false, redrawNonce: 0 }; }
+export function closeOverlay(state) { return { ...state, overlay: null, focus: closeFocus(state.focus) }; }
+export function reduceAppAction(state, action) {
+    if (action.type === 'close-overlay')
+        return closeOverlay(state);
+    if (action.action === 'model-picker')
+        return openOverlay(state, { kind: 'model' });
+    if (action.action === 'provider-picker')
+        return openOverlay(state, { kind: 'provider' });
+    if (action.action === 'help')
+        return openOverlay(state, { kind: 'help' });
+    if (action.action === 'reasoning-toggle')
+        return { ...state, reasoningVisible: !state.reasoningVisible };
+    if (action.action === 'tool-details')
+        return { ...state, expandedTools: !state.expandedTools };
+    if (action.action === 'redraw')
+        return { ...state, redrawNonce: state.redrawNonce + 1 };
+    if (action.action === 'overlay-close' || action.action === 'picker-cancel')
+        return closeOverlay(state);
+    return state;
+}
+export function slashCommandIntent(text) {
+    const parsed = parseSlashCommand(text);
+    if (parsed.name === 'model')
+        return parsed.args[0] ? { kind: 'select-model', id: parsed.args[0] } : { kind: 'open-overlay', overlay: { kind: 'model' } };
+    if (parsed.name === 'help')
+        return { kind: 'open-overlay', overlay: { kind: 'help' } };
+    if (parsed.name === 'provider')
+        return { kind: 'open-overlay', overlay: { kind: 'provider' } };
+    if (parsed.name === 'resume' || parsed.name === 'fork')
+        return parsed.args[0] ? { kind: 'session-id', action: parsed.name, id: parsed.args[0] } : { kind: 'open-overlay', overlay: { kind: 'session', action: parsed.name } };
+    if (parsed.name === 'redraw')
+        return { kind: 'key-action', action: 'redraw' };
+    return null;
+}
+export function togglePlanMode(current, base) { return current === 'plan' ? (base === 'plan' ? 'default' : base) : 'plan'; }
+export function permissionDryRunSlash(args, rules, projectRoot) {
+    if (args[0] !== 'dry-run')
+        return null;
+    const command = args.slice(1).join(' ').trim();
+    if (!command)
+        return t('screen.usage.permissionsDryRun');
+    return formatPermissionSimulation(simulatePermission({ rules, action: { tool: 'Bash', command }, projectRoot })).trimEnd();
+}
+const SLASH_CLI_FAMILY = { mcp: 'mcp', hooks: 'hook', plugins: 'plugin', doctor: 'doctor', memory: 'memory', notes: 'notes', tasks: 'tasks', library: 'library', research: 'research', automations: 'automation', forge: 'forge' };
+export function slashCommandToCliArgs(name, args) { const family = SLASH_CLI_FAMILY[name]; if (!family)
+    return null; const out = [family, ...args]; if (args.length === 0 && name !== 'doctor')
+    out.push('list'); return out; }
+export function pickerMove(action) {
+    if (action === 'picker-up')
+        return 'up';
+    if (action === 'picker-down')
+        return 'down';
+    if (action === 'picker-page-up')
+        return 'page-up';
+    if (action === 'picker-page-down')
+        return 'page-down';
+    if (action === 'picker-home')
+        return 'home';
+    if (action === 'picker-end')
+        return 'end';
+    return null;
+}
+export function modelItems(rows, query) { return filterItems(rows.map(row => ({ id: row.id, label: row.name, searchText: `${row.id} ${row.name} ${row.provider}`, group: row.provider, value: row })), query).map(item => item.value); }
+export function providerItems(rows, query) { return filterItems(rows.map(row => ({ id: row.id, label: row.label, searchText: `${row.id} ${row.label} ${row.description}`, group: row.local ? 'local' : 'cloud', value: row })), query).map(item => item.value); }
+export function lastProjectToken(text) { const match = /(?:^|\s)(@[^\s]*)$/u.exec(text); return match?.[1] ?? null; }
+/* R4: the token is replaced in place, so a collapsed paste earlier in the draft stays collapsed and Ctrl+Z undoes it. */
+export function replaceLastProjectToken(state, token, value) { const start = state.text.lastIndexOf(token); return start < 0 ? state : replaceRange(state, start, start + token.length, value); }
+/* R4 Q-R4-13: /status as a small titled block, the permission mode in words (Q-R4-12), an honest line with no session. */
+/* R5b D7 (Q-R5-17): with `facts`, the R4 block is followed by the sandbox, rules, work and usage lines (status-view.ts). */
+export function sessionStatusText({ session, running, model, mode, tools, facts }) {
+    const block = t('screen.status.block', { session: session ?? t('screen.status.noSession'), running: t(running ? 'screen.word.yes' : 'screen.word.no'), model, mode: t('screen.status.mode', { mode: permissionModeLabel(mode) }), tools });
+    return facts ? [block, ...statusFactLines(facts)].join('\n') : block;
+}

package/dist/tui/slash-commands.js

@@ -0,0 +1,82 @@
+import { t } from "../i18n/index.js";
+const SLASH_COMMAND_META = [
+    { name: 'help', usage: '' },
+    { name: 'provider', usage: '' },
+    /* P17 (owner decision 4): the first launch's guided setup, again. */
+    { name: 'setup', usage: '' },
+    { name: 'model', usage: '[provider:model]' },
+    /* R5a (owner 2026-09-24): the reasoning effort of the current model, as a line of nodes. */
+    { name: 'effort', usage: '[level]' },
+    { name: 'queue', usage: '[show|clear|run]' },
+    /* R5a (Q-R5-7, Q-R5-19): what Enter does while TALOS works. */
+    { name: 'busy', usage: '[queue|steer|interrupt]' },
+    { name: 'permissions', usage: t('screen.slash.permissionsUsage') },
+    { name: 'plan', usage: '' },
+    { name: 'diff', usage: '' },
+    { name: 'status', usage: '' },
+    { name: 'context', usage: '' },
+    /* R5a (Q-R5-2, Q-R5-8, Q-R5-19): tokens, window, cost and compactions; a view, it runs at once during a turn. */
+    { name: 'usage', usage: '' },
+    { name: 'compact', usage: '' },
+    { name: 'clear', usage: '' },
+    { name: 'redraw', usage: '' },
+    { name: 'resume', usage: '[session-id]' },
+    { name: 'fork', usage: '[session-id]' },
+    /* R5b D1 (Q-R5-12): this conversation to a file. */
+    { name: 'export', usage: '[md|json|jsonl] [file]' },
+    { name: 'rename', usage: '<name>' },
+    /* R5b D4 (Q-R5-14): the ten product themes and mono, previewed live. */
+    { name: 'theme', usage: '[name]' },
+    /* R5b D3 (Q-R5-13): this conversation's checkpoints, with their files; /rewind and /checkpoint are the same command. */
+    { name: 'undo', usage: '' },
+    /* R5b (Q-R5-19): send the last message again; copy an answer (Hermes /retry, Claude Code and Hermes /copy). */
+    { name: 'retry', usage: '' },
+    { name: 'copy', usage: '[n]' },
+    /* R5b (owner 2026-09-25): the messages you sent in this project, to put one back in the composer. */
+    { name: 'history', usage: '' },
+    { name: 'mcp', usage: '[list|test|trust|untrust] [server-id]' },
+    { name: 'hooks', usage: '[list|dry-run|history|trust|untrust|quarantine|release] [hook-id] [args...]' },
+    { name: 'plugins', usage: '[list|install|remove|trust|untrust|quarantine|release] [plugin-id] [args...]' },
+    { name: 'doctor', usage: '[args...]' },
+    { name: 'memory', usage: '[args...]' },
+    { name: 'notes', usage: '[args...]' },
+    { name: 'tasks', usage: '[args...]' },
+    { name: 'library', usage: '[args...]' },
+    { name: 'research', usage: '[args...]' },
+    { name: 'automations', usage: '[args...]' },
+    { name: 'forge', usage: '[args...]' },
+    { name: 'exit', usage: '' },
+];
+/* R2 (Q-R2-1, gate E1): the descriptions are dictionary words; a later locale overlays the dictionary, not this file. */
+export function slashCommandDescription(name) { return t(`screen.slash.${name}`); }
+export const SLASH_COMMANDS = SLASH_COMMAND_META.map(row => ({
+    name: row.name,
+    usage: row.usage,
+    description: slashCommandDescription(row.name),
+}));
+const SLASH_GROUPS = ['session', 'turn', 'view', 'work', 'extensions'];
+const GROUP_OF = {
+    resume: 'session', fork: 'session', rename: 'session', export: 'session', undo: 'session', history: 'session', clear: 'session', compact: 'session', exit: 'session',
+    provider: 'turn', setup: 'turn', model: 'turn', effort: 'turn', busy: 'turn', queue: 'turn', retry: 'turn', plan: 'turn', permissions: 'turn',
+    help: 'view', status: 'view', context: 'view', usage: 'view', diff: 'view', copy: 'view', theme: 'view', redraw: 'view',
+    memory: 'work', notes: 'work', tasks: 'work', library: 'work', research: 'work', automations: 'work', forge: 'work',
+    mcp: 'extensions', hooks: 'extensions', plugins: 'extensions', doctor: 'extensions',
+};
+export function slashCommandGroup(name) { return GROUP_OF[name]; }
+export function slashCommandHelp() {
+    return SLASH_GROUPS.map(group => t(`screen.help.group.${group}`) + '\n' + SLASH_COMMANDS.filter(command => GROUP_OF[command.name] === group).map(command => {
+        const usage = command.usage ? ' ' + command.usage : '';
+        return '  /' + command.name + usage + ' — ' + slashCommandDescription(command.name);
+    }).join('\n')).join('\n\n');
+}
+function distance(a, b) { const d = Array.from({ length: a.length + 1 }, () => Array(b.length + 1).fill(0)); for (let i = 0; i <= a.length; i++)
+    d[i][0] = i; for (let j = 0; j <= b.length; j++)
+    d[0][j] = j; for (let i = 1; i <= a.length; i++)
+    for (let j = 1; j <= b.length; j++)
+        d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1)); return d[a.length][b.length]; }
+/* R5b D3 (Q-R5-13): other names for a command (Claude Code's /rewind aliases); the parsed name is the command's own. */
+const SLASH_ALIASES = Object.freeze({ rewind: 'undo', checkpoint: 'undo' });
+export function parseSlashCommand(text) { const parts = text.trim().replace(/^\//u, '').split(/\s+/u).filter(Boolean); const typed = parts.shift() ?? ''; const name = SLASH_ALIASES[typed] ?? typed; const known = SLASH_COMMANDS.some(x => x.name === name); const suggestions = known ? [] : SLASH_COMMANDS.map(x => ({ n: x.name, d: distance(name, x.name) })).filter(x => x.d <= Math.max(2, Math.floor(name.length / 3))).sort((a, b) => a.d - b.d || a.n.localeCompare(b.n)).slice(0, 3).map(x => x.n); return { name, args: parts, suggestions }; }
+export function completeSlashCommand(text) { if (!text.startsWith('/'))
+    return []; const raw = text.slice(1); if (/\s/u.test(raw))
+    return []; return SLASH_COMMANDS.map(x => '/' + x.name).filter(x => x.startsWith('/' + raw)).sort((a, b) => a.localeCompare(b)); }

package/dist/tui/state.js

@@ -0,0 +1,151 @@
+import { t, tn } from "../i18n/index.js";
+import { toolDisplay } from "./tool-display.js";
+import { createTranscriptModel, reduceTranscriptEvent } from "./transcript-model.js";
+const MAX_RENDER_MESSAGES = 512;
+const MAX_RENDER_TOOLS = 256;
+const MAX_RENDER_WARNINGS = 128;
+const MAX_MESSAGE_CHARS = 256 * 1024;
+const MAX_TOOL_SUMMARY_CHARS = 8 * 1024;
+const MAX_WARNING_CHARS = 2048;
+function tail(value, limit) { if (value.length <= limit)
+    return value; return `${t('screen.state.truncated')}\n${value.slice(-(limit - 22))}`; }
+export function initialTuiState(x) { return { sessionId: null, running: false, sentAt: null, waitingForPerson: false, lastTurn: null, turnStartedAt: null, retry: null, compactions: 0, messages: [], streamingAssistant: null, reasoning: null, tools: [], approval: null, usage: null, warnings: [], transcript: createTranscriptModel(), status: { model: x.model, permissionMode: x.permissionMode, branch: null, contextLabel: null } }; }
+function finalizeStreaming(state, messageId) {
+    const live = state.streamingAssistant;
+    if (!live || live.id !== messageId)
+        return state;
+    const base = state.messages.length >= MAX_RENDER_MESSAGES ? state.messages.slice(-(MAX_RENDER_MESSAGES - 1)) : state.messages;
+    return { ...state, streamingAssistant: null, messages: [...base, { id: live.id, role: 'assistant', text: tail(live.text, MAX_MESSAGE_CHARS) }] };
+}
+function endTurn(state, outcome) {
+    return { sentAt: null, waitingForPerson: false, retry: null, lastTurn: { outcome, durationMs: state.turnStartedAt === null ? (state.lastTurn?.durationMs ?? null) : Math.max(0, Date.now() - state.turnStartedAt) }, turnStartedAt: null };
+}
+function activeToolStatus(status) { return status === 'queued' || status === 'approval' || status === 'running' || status === 'streaming'; }
+function closeRunningTools(state, status = 'cancelled') { return state.tools.map(row => activeToolStatus(row.status) ? { ...row, status, endedAt: row.endedAt ?? Date.now() } : row); }
+const whole = (value, fallback = null) => typeof value === 'number' && Number.isFinite(value) && value >= 0 ? Math.floor(value) : fallback;
+/* The model answered again: a retry, if any, is over (message, reasoning or a tool call). */
+const PROGRESS = new Set(['message.started', 'message.delta', 'reasoning.started', 'reasoning.delta', 'tool.started']);
+export function reduceTuiEvent(state, event) {
+    state = { ...state, transcript: reduceTranscriptEvent(state.transcript, event) };
+    if (event.type === 'provider.attempt') {
+        const attempt = whole(event.attempt, 1), maxAttempts = Math.max(attempt, whole(event.maxAttempts, attempt));
+        return { ...state, retry: { attempt, maxAttempts, status: whole(event.status), retryAfterMs: whole(event.retryAfterMs), waitMs: whole(event.waitMs), at: Date.now() } };
+    }
+    if (state.retry && PROGRESS.has(event.type))
+        state = { ...state, retry: null };
+    if (event.type === 'context.compacted')
+        return { ...state, compactions: (state.compactions ?? 0) + 1 };
+    if (event.type === 'run.started')
+        return { ...state, sessionId: event.sessionId || state.sessionId, running: true, sentAt: null, lastTurn: null, turnStartedAt: Date.now(), retry: null };
+    if (event.type === 'message.started') {
+        if (event.role !== 'assistant')
+            return state;
+        const live = state.streamingAssistant, next = live && live.id !== event.messageId ? finalizeStreaming(state, live.id) : state;
+        return next.streamingAssistant?.id === event.messageId ? next : { ...next, streamingAssistant: { id: event.messageId, text: '' } };
+    }
+    if (event.type === 'message.delta') {
+        const live = state.streamingAssistant;
+        if (live?.id === event.messageId)
+            return { ...state, streamingAssistant: { ...live, text: tail(live.text + event.delta, MAX_MESSAGE_CHARS) } };
+        const next = live ? finalizeStreaming(state, live.id) : state;
+        return { ...next, streamingAssistant: { id: event.messageId, text: tail(event.delta, MAX_MESSAGE_CHARS) } };
+    }
+    if (event.type === 'message.end')
+        return finalizeStreaming(state, event.messageId);
+    if (event.type === 'reasoning.started')
+        return state.reasoning?.id === event.messageId ? state : { ...state, reasoning: { id: event.messageId, text: '' } };
+    if (event.type === 'reasoning.delta') {
+        const current = state.reasoning;
+        return { ...state, reasoning: current?.id === event.messageId ? { ...current, text: tail(current.text + event.delta, MAX_MESSAGE_CHARS) } : { id: event.messageId, text: tail(event.delta, MAX_MESSAGE_CHARS) } };
+    }
+    if (event.type === 'reasoning.end')
+        return state.reasoning?.id === event.messageId ? { ...state, reasoning: null } : state;
+    if (event.type === 'tool.started') {
+        const row = { id: event.toolCallId, name: event.toolName, status: 'queued', argsText: '', liveOutput: '', finalOutput: '', startedAt: Date.now(), endedAt: null, outcome: null };
+        const existing = state.tools.findIndex(x => x.id === event.toolCallId);
+        if (existing >= 0) {
+            const tools = state.tools.slice();
+            tools[existing] = row;
+            return { ...state, tools };
+        }
+        return { ...state, tools: [...state.tools.slice(-(MAX_RENDER_TOOLS - 1)), row] };
+    }
+    if (event.type === 'tool.args')
+        return { ...state, tools: state.tools.map(row => row.id === event.toolCallId ? { ...row, argsText: tail(row.argsText + event.delta, MAX_TOOL_SUMMARY_CHARS) } : row) };
+    if (event.type === 'tool.output')
+        return { ...state, tools: state.tools.map(row => row.id === event.toolCallId && activeToolStatus(row.status) ? { ...row, status: 'streaming', liveOutput: tail(row.liveOutput + event.delta, MAX_TOOL_SUMMARY_CHARS) } : row) };
+    if (event.type === 'tool.completed')
+        return { ...state, tools: state.tools.map(row => row.id === event.toolCallId ? { ...row, status: event.outcome?.status ?? 'completed', finalOutput: tail(event.content, MAX_TOOL_SUMMARY_CHARS), endedAt: Date.now(), outcome: event.outcome ?? null } : row) };
+    if (event.type === 'approval.required') {
+        /* R2 (gate E3): the tool is named by lane T's display table, never by its kernel name (`scrivi`, `shell`). */
+        const p = event.payload;
+        const tool = p.tool ?? p.tipo;
+        const label = tool ? toolDisplay(String(tool)).label : t('screen.approval.label');
+        const detail = String(p.command ?? p.comando ?? p.resource ?? p.percorso ?? p.path ?? '');
+        const toolCallId = event.toolCallId ?? null;
+        return { ...state, tools: toolCallId ? state.tools.map(row => row.id === toolCallId && activeToolStatus(row.status) ? { ...row, status: 'approval' } : row) : state.tools, approval: { requestId: event.requestId, label, detail, payload: p, toolCallId } };
+    }
+    if (event.type === 'approval.resolved') {
+        const approval = state.approval;
+        if (!approval || approval.requestId !== event.requestId)
+            return state;
+        const tools = approval.toolCallId ? state.tools.map(row => {
+            if (row.id !== approval.toolCallId || !activeToolStatus(row.status))
+                return row;
+            if (event.approved === true)
+                return { ...row, status: 'running' };
+            if (event.approved === false)
+                return { ...row, status: 'failed', endedAt: row.endedAt ?? Date.now() };
+            return row;
+        }) : state.tools;
+        return { ...state, tools, approval: null };
+    }
+    if (event.type === 'usage.updated')
+        return { ...state, usage: event.value, status: { ...state.status, contextLabel: usageLabel(event.value) } };
+    if (event.type === 'warning')
+        return { ...state, warnings: [...state.warnings.slice(-(MAX_RENDER_WARNINGS - 1)), tail(event.message, MAX_WARNING_CHARS)] };
+    if (event.type === 'run.cancelled')
+        return { ...state, ...endTurn(state, 'interrupted'), running: false, approval: null, streamingAssistant: null, reasoning: null, tools: closeRunningTools(state, 'cancelled') };
+    if (event.type === 'run.failed')
+        return { ...state, ...endTurn(state, 'failed'), running: false, approval: null, streamingAssistant: null, reasoning: null, tools: closeRunningTools(state, 'failed'), warnings: [...state.warnings.slice(-(MAX_RENDER_WARNINGS - 1)), tail(event.message, MAX_WARNING_CHARS)] };
+    if (event.type === 'run.completed') {
+        const finalized = state.streamingAssistant ? finalizeStreaming(state, state.streamingAssistant.id) : state;
+        return { ...finalized, ...endTurn(state, 'done'), running: false, approval: null, reasoning: null };
+    }
+    return state;
+}
+function usageLabel(value) { if (!value || typeof value !== 'object')
+    return null; const row = value; const prompt = numberValue(row.prompt_tokens ?? row.promptTokens ?? row.input_tokens ?? row.inputTokens); const completion = numberValue(row.completion_tokens ?? row.completionTokens ?? row.output_tokens ?? row.outputTokens); if (prompt === null && completion === null)
+    return null; return `${prompt ?? 0}+${completion ?? 0}`; }
+function numberValue(value) { return typeof value === 'number' && Number.isFinite(value) ? value : null; }
+function objectValue(value) { return value && typeof value === 'object' && !Array.isArray(value) ? value : null; }
+function firstMeasuredNumber(...values) { for (const value of values) {
+    const measured = numberValue(value);
+    if (measured !== null)
+        return measured;
+} return null; }
+export function reasoningUsageEvidence(value) {
+    const row = objectValue(value);
+    if (!row)
+        return { reasoningTokens: null, reasoningCostUsd: null };
+    const completion = objectValue(row.completion_tokens_details ?? row.completionTokensDetails);
+    const output = objectValue(row.output_tokens_details ?? row.outputTokensDetails);
+    const reasoning = objectValue(row.reasoning);
+    return {
+        reasoningTokens: firstMeasuredNumber(row.reasoning_tokens, row.reasoningTokens, completion?.reasoning_tokens, completion?.reasoningTokens, output?.reasoning_tokens, output?.reasoningTokens, reasoning?.tokens),
+        reasoningCostUsd: firstMeasuredNumber(row.reasoning_cost_usd, row.reasoningCostUsd, reasoning?.cost_usd, reasoning?.costUsd),
+    };
+}
+export function reasoningUsageLabel(value) {
+    const evidence = reasoningUsageEvidence(value);
+    if (evidence.reasoningTokens === null && evidence.reasoningCostUsd === null)
+        return t('screen.reasoning.notReported');
+    const parts = [];
+    parts.push(evidence.reasoningTokens === null ? t('screen.reasoning.tokensNotReported') : tn('screen.reasoning.tokens', evidence.reasoningTokens));
+    if (evidence.reasoningCostUsd !== null)
+        parts.push(t('screen.reasoning.cost', { cost: evidence.reasoningCostUsd }));
+    return parts.join(' · ');
+}
+// Temporary compatibility for the old composition root while Task 14 migrates it.
+export const reduceCliEvent = reduceTuiEvent;
+export function selectVisibleTranscript(s, { rows }) { return s.transcript.items.slice(-Math.max(1, rows * 3)); }