talos-code 0.0.1 → 0.2.0

package/dist/tui/highlight.js

@@ -0,0 +1,30 @@
+const JS_LANGS = new Set(['js', 'jsx', 'javascript', 'ts', 'tsx', 'typescript']);
+const SH_LANGS = new Set(['sh', 'bash', 'shell', 'powershell', 'ps1']);
+const JS_KEYWORDS = new Set(['const', 'let', 'var', 'function', 'return', 'if', 'else', 'for', 'while', 'class', 'new', 'import', 'from', 'export', 'async', 'await', 'try', 'catch', 'throw', 'interface', 'type', 'extends', 'implements', 'public', 'private', 'protected', 'readonly']);
+function tokenize(line, re, classify) { const out = []; let pos = 0; for (const m of line.matchAll(re)) {
+    const i = m.index ?? 0;
+    if (i > pos)
+        out.push({ text: line.slice(pos, i), kind: 'plain' });
+    out.push({ text: m[0], kind: classify(m[0], i) });
+    pos = i + m[0].length;
+} if (pos < line.length)
+    out.push({ text: line.slice(pos), kind: 'plain' }); return out.length ? out : [{ text: line, kind: 'plain' }]; }
+function json(line) { return tokenize(line, /"(?:\\.|[^"\\])*"(?=\s*:)|"(?:\\.|[^"\\])*"|-?\b\d+(?:\.\d+)?(?:[eE][+-]?\d+)?\b|\b(?:true|false|null)\b/gu, (t) => { if (/^"/u.test(t))
+    return /"\s*$/u.test(t) && new RegExp(`${t.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*:`).test(line) ? 'key' : 'string'; if (/^(?:true|false|null)$/u.test(t))
+    return 'literal'; return 'number'; }); }
+function js(line) { const comment = line.search(/\/\/|\/\*/u); const head = comment >= 0 ? line.slice(0, comment) : line; const body = tokenize(head, /'(?:\\.|[^'\\])*'|"(?:\\.|[^"\\])*"|`(?:\\.|[^`\\])*`|\b[A-Za-z_$][A-Za-z0-9_$]*\b|\b\d+(?:\.\d+)?\b|=>|===|!==|==|!=|<=|>=|&&|\|\||[+\-*/%=<>!?]/gu, (t) => { if (/^['"`]/u.test(t))
+    return 'string'; if (/^\d/u.test(t))
+    return 'number'; if (JS_KEYWORDS.has(t))
+    return 'keyword'; if (/^(?:true|false|null|undefined)$/u.test(t))
+    return 'literal'; if (/^[+\-*/%=<>!?&|]/u.test(t))
+    return 'operator'; return 'plain'; }); if (comment >= 0)
+    body.push({ text: line.slice(comment), kind: 'comment' }); return body; }
+function sh(line) { const comment = line.indexOf('#'); const head = comment >= 0 ? line.slice(0, comment) : line; const body = tokenize(head, /'(?:[^']*)'|"(?:\\.|[^"\\])*"|\$[A-Za-z_][A-Za-z0-9_]*|\b(?:if|then|else|fi|for|in|do|done|case|esac|function|param|foreach|throw|exit)\b|\b\d+\b/gu, (t) => { if (/^['"]/u.test(t))
+    return 'string'; if (/^\$/u.test(t))
+    return 'literal'; if (/^\d/u.test(t))
+    return 'number'; return 'keyword'; }); if (comment >= 0)
+    body.push({ text: line.slice(comment), kind: 'comment' }); return body; }
+export function highlightCodeLine(line, language = '') { const lang = language.toLowerCase().trim(); if (lang === 'json' || lang === 'jsonc')
+    return json(line); if (JS_LANGS.has(lang))
+    return js(line); if (SH_LANGS.has(lang))
+    return sh(line); return [{ text: line, kind: 'plain' }]; }

package/dist/tui/input-router.js

@@ -0,0 +1,18 @@
+import { resolveKeybinding } from "./keybindings.js";
+const TEXT_INPUT_FOCUS = new Set(['composer', 'command-menu', 'model-picker', 'provider-picker', 'session-picker']);
+export function acceptsTextInput(focus) { return TEXT_INPUT_FOCUS.has(focus); }
+export function routeInput(input) {
+    const { ch, key, composerText } = input;
+    const focus = input.commandMenuOpen && input.focus === 'composer' ? 'command-menu' : input.focus;
+    if (focus === 'composer' && ch === '?' && composerText.length > 0)
+        return { kind: 'text', text: '?' };
+    if (focus === 'composer' && ch === '/' && composerText.trimStart().length === 0)
+        return { kind: 'action', action: 'command-menu' };
+    const contexts = (focus === 'composer' ? [focus, 'history', 'transcript', 'global'] : [focus, 'global']);
+    const action = resolveKeybinding(ch, key, contexts, input.keymap);
+    if (action)
+        return { kind: 'action', action };
+    if (acceptsTextInput(focus) && ch && !key.ctrl && !key.meta)
+        return { kind: 'text', text: ch };
+    return { kind: 'ignore' };
+}

package/dist/tui/interrupt.js

@@ -0,0 +1,99 @@
+import { t } from "../i18n/index.js";
+/*
+ * Ctrl+C policy (review D-12, gate E10). The keymap documents exit as `Ctrl+D / Ctrl+C Ctrl+C`, so at idle the first
+ * press only arms the exit and the caller shows EXIT_HINT (Claude Code prints "Press Ctrl-C again to exit",
+ * CHANGELOG 2.1.248, npm 2026-08-27); a second press inside the window exits. During a run the first press cancels
+ * and a quick second one forces the exit, as before. The idle window is 2 s, not Pi's 500 ms (interactive-mode.ts:
+ * 4117-4125 @a328aa8 2026-09-23): the hint is on screen, and the s10 acceptance cadence presses again after 1.5 s.
+ *
+ * R4 (owner decision Q-R4-7, gate E7): ONE exit rule for Ctrl+C, Ctrl+D and Esc, decided here; app.ts only calls it and
+ * carries out the answer. The composer and dialog state is read through the `context` callback the app injects, at the
+ * moment of the key:
+ * - an open picker or dialog is closed first, before any exit is armed (Claude Code 2.1.280/2.1.281, gate D.2/D.5);
+ * - with a draft, Ctrl+C and Esc Esc (within ESC_CLEAR_WINDOW_MS) clear it — the app puts it in history first, so ↑ brings
+ *   it back (Claude Code "Interactive mode" :21/:37, 2.1.275 → 2026-09-17, gate B.2; Hermes, Pi, Goose clear too);
+ * - the two-press exit (2 s window and the status-row hint, R1) happens only on an empty composer;
+ * - Ctrl+D with a draft deletes at the cursor; on an empty composer it is Ctrl+C (Claude Code :23, Codex `mod.rs:217-224`);
+ *   one armed state, so either key confirms it, and the hint names the key that armed it.
+ * During a run Ctrl+C still cancels first (R1) and Esc stops the run (the queue-preserving interrupt).
+ */
+export const EXIT_CONFIRM_WINDOW_MS = 2000;
+export const ESC_CLEAR_WINDOW_MS = 500;
+export function exitHintText(key = 'ctrl-c') { return t('screen.exit.hint', { key: key === 'ctrl-d' ? 'Ctrl+D' : 'Ctrl+C' }); }
+export const EXIT_HINT = exitHintText('ctrl-c');
+const NO_CONTEXT = { draft: false, dialog: false, completion: false };
+export function createInterruptController({ now = Date.now, windowMs = 1000, exitWindowMs = EXIT_CONFIRM_WINDOW_MS, escWindowMs = ESC_CLEAR_WINDOW_MS, context = () => NO_CONTEXT } = {}) {
+    let lastCancelAt = null, armedAt = null, armedKey = null, lastEscAt = null;
+    const armed = (at) => armedAt !== null && at - armedAt <= exitWindowMs;
+    const disarm = () => { armedAt = null; armedKey = null; };
+    const read = () => { try {
+        return { ...NO_CONTEXT, ...context() };
+    }
+    catch {
+        return NO_CONTEXT;
+    } };
+    /* The R1 two-press rule: idle arms then exits; during a run cancels then forces the exit. */
+    const exitPress = (running, key) => {
+        const at = now();
+        if (!running) {
+            lastCancelAt = null;
+            if (armed(at)) {
+                disarm();
+                return 'exit';
+            }
+            armedAt = at;
+            armedKey = key;
+            return 'arm-exit';
+        }
+        disarm();
+        if (lastCancelAt !== null && at - lastCancelAt <= windowMs) {
+            lastCancelAt = null;
+            return 'force-exit';
+        }
+        lastCancelAt = at;
+        return 'cancel';
+    };
+    const exitKey = (running, key) => {
+        lastEscAt = null;
+        const ctx = read();
+        if (ctx.dialog) {
+            disarm();
+            lastCancelAt = null;
+            return 'close-dialog';
+        }
+        if (key === 'ctrl-d' && ctx.draft)
+            return 'delete-forward';
+        if (!running && ctx.draft) {
+            disarm();
+            lastCancelAt = null;
+            return 'clear-draft';
+        }
+        return exitPress(running, key);
+    };
+    return {
+        /** Ctrl+C: close a dialog · cancel a run · clear a draft · arm or confirm the exit. */
+        ctrlC(running) { return exitKey(running, 'ctrl-c'); },
+        /** Ctrl+D: close a dialog · delete at the cursor when there is a draft · otherwise exactly Ctrl+C. */
+        ctrlD(running) { return exitKey(running, 'ctrl-d'); },
+        /** Esc: close a dialog or the `@` list · stop a run · the second of two quick presses clears a draft. */
+        esc(running) {
+            const ctx = read(), at = now();
+            if (ctx.dialog || ctx.completion || running) {
+                lastEscAt = null;
+                return ctx.dialog ? 'close-dialog' : ctx.completion ? 'close-completion' : 'stop-run';
+            }
+            if (ctx.draft && lastEscAt !== null && at - lastEscAt <= escWindowMs) {
+                lastEscAt = null;
+                disarm();
+                return 'clear-draft';
+            }
+            lastEscAt = at;
+            return 'esc';
+        },
+        /** True while a second idle Ctrl+C/Ctrl+D would exit: the caller keeps the hint visible for exactly this long. */
+        exitArmed() { return armed(now()); },
+        /** The key that armed the exit (the hint names it), or null. */
+        armedBy() { return armed(now()) ? armedKey : null; },
+        reset() { lastCancelAt = null; },
+    };
+}

package/dist/tui/keybindings.js

@@ -0,0 +1,194 @@
+import { t } from "../i18n/index.js";
+const PICKER_CONTEXTS = ['model-picker', 'provider-picker', 'session-picker'];
+const PICKER_KEYS = [
+    ['picker-up', ['Up']], ['picker-down', ['Down']], ['picker-page-up', ['PageUp']], ['picker-page-down', ['PageDown']], ['picker-home', ['Home']], ['picker-end', ['End']], ['picker-confirm', ['Enter']], ['picker-cancel', ['Esc']], ['picker-backspace', ['Backspace']]
+];
+/* R2 (gate E1, Q-R2-10): /help shows every description, so each one is a dictionary word. The picker wording is kept
+   byte-identical: docs/talos-cli/command-reference.md is generated from it and pinned by a test. */
+/* R5a (owner 2026-09-24, /effort's line of nodes): ← → move like ↑ ↓ in the pickers; not in the command menu, where they
+   move the caret of the typed text. */
+const PICKER_SIDE_KEYS = { 'picker-up': ['Left'], 'picker-down': ['Right'] };
+const pickerBindings = PICKER_CONTEXTS.flatMap(context => PICKER_KEYS.map(([id, keys]) => ({ id, keys: [...keys, ...(PICKER_SIDE_KEYS[id] ?? [])], context, description: t(`screen.key.${id}`) })));
+const commandBindings = PICKER_KEYS.map(([id, keys]) => ({ id, keys: [...keys], context: 'command-menu', description: t(`screen.key.${id}`) }));
+commandBindings.push({ id: 'command-complete', keys: ['Tab'], context: 'command-menu', description: t('screen.key.command-complete') });
+export const KEYBINDINGS = Object.freeze([
+    { id: 'submit', keys: ['Enter'], context: 'composer', description: t('screen.key.submit') },
+    { id: 'newline', keys: ['Shift+Enter', 'Ctrl+J'], context: 'composer', description: t('screen.key.newline') },
+    { id: 'interrupt', keys: ['Ctrl+C', 'Esc'], context: 'global', description: t('screen.key.interrupt') },
+    { id: 'exit', keys: ['Ctrl+D', 'Ctrl+C Ctrl+C'], context: 'global', description: t('screen.key.exit') },
+    /* R4 Q-R4-7 (gate E16): the draft keys are listed where /help and the command reference read them. `Esc Esc` is two
+       presses (interrupt.ts decides it); a person may bind `clear-draft` to one key of their own. */
+    { id: 'clear-draft', keys: ['Esc Esc'], context: 'composer', description: t('screen.key.clear-draft') },
+    { id: 'undo', keys: ['Ctrl+Z', 'Alt+Z'], context: 'composer', description: t('screen.key.undo') },
+    { id: 'redo', keys: ['Ctrl+Shift+Z', 'Alt+Shift+Z', 'Alt+/'], context: 'composer', description: t('screen.key.redo') },
+    { id: 'vim-toggle', keys: ['Alt+V'], context: 'composer', description: t('screen.key.vim-toggle') },
+    { id: 'steer', keys: ['Alt+S'], context: 'composer', description: t('screen.key.steer') },
+    { id: 'agent-tree', keys: ['Alt+A'], context: 'composer', description: t('screen.key.agent-tree') },
+    { id: 'left', keys: ['Left', 'Ctrl+B'], context: 'composer', description: t('screen.key.left') },
+    { id: 'right', keys: ['Right', 'Ctrl+F'], context: 'composer', description: t('screen.key.right') },
+    { id: 'home', keys: ['Home', 'Ctrl+A'], context: 'composer', description: t('screen.key.home') },
+    { id: 'end', keys: ['End', 'Ctrl+E'], context: 'composer', description: t('screen.key.end') },
+    { id: 'word-left', keys: ['Alt+B'], context: 'composer', description: t('screen.key.word-left') },
+    { id: 'word-right', keys: ['Alt+F'], context: 'composer', description: t('screen.key.word-right') },
+    { id: 'select-left', keys: ['Shift+Left'], context: 'composer', description: t('screen.key.select-left') },
+    { id: 'select-right', keys: ['Shift+Right'], context: 'composer', description: t('screen.key.select-right') },
+    { id: 'select-home', keys: ['Shift+Home'], context: 'composer', description: t('screen.key.select-home') },
+    { id: 'select-end', keys: ['Shift+End'], context: 'composer', description: t('screen.key.select-end') },
+    { id: 'select-up', keys: ['Shift+Up'], context: 'composer', description: t('screen.key.select-up') },
+    { id: 'select-down', keys: ['Shift+Down'], context: 'composer', description: t('screen.key.select-down') },
+    { id: 'select-word-left', keys: ['Alt+Shift+B'], context: 'composer', description: t('screen.key.select-word-left') },
+    { id: 'select-word-right', keys: ['Alt+Shift+F'], context: 'composer', description: t('screen.key.select-word-right') },
+    { id: 'copy-selection', keys: ['Alt+W'], context: 'composer', description: t('screen.key.copy-selection') },
+    { id: 'backspace', keys: ['Backspace'], context: 'composer', description: t('screen.key.backspace') },
+    { id: 'delete-forward', keys: ['Delete', 'Ctrl+D'], context: 'composer', description: t('screen.key.delete-forward') },
+    { id: 'kill-start', keys: ['Ctrl+U'], context: 'composer', description: t('screen.key.kill-start') },
+    { id: 'kill-end', keys: ['Ctrl+K'], context: 'composer', description: t('screen.key.kill-end') },
+    { id: 'kill-word', keys: ['Ctrl+W'], context: 'composer', description: t('screen.key.kill-word') },
+    { id: 'yank', keys: ['Ctrl+Y'], context: 'composer', description: t('screen.key.yank') },
+    { id: 'history-prev', keys: ['Up', 'Ctrl+P'], context: 'history', description: t('screen.key.history-prev') },
+    { id: 'history-next', keys: ['Down', 'Ctrl+N'], context: 'history', description: t('screen.key.history-next') },
+    { id: 'history-search', keys: ['Ctrl+R'], context: 'history', description: t('screen.key.history-search') },
+    { id: 'palette', keys: ['Tab'], context: 'composer', description: t('screen.key.palette') },
+    { id: 'transcript-search', keys: ['Alt+T'], context: 'transcript', description: t('screen.key.transcript-search') },
+    { id: 'transcript-raw', keys: ['Alt+R'], context: 'transcript', description: t('screen.key.transcript-raw') },
+    { id: 'transcript-copy', keys: ['Alt+C'], context: 'transcript', description: t('screen.key.transcript-copy') },
+    { id: 'page-up', keys: ['PageUp'], context: 'transcript', description: t('screen.key.page-up') },
+    { id: 'page-down', keys: ['PageDown'], context: 'transcript', description: t('screen.key.page-down') },
+    { id: 'transcript-top', keys: ['Ctrl+Home'], context: 'transcript', description: t('screen.key.transcript-top') },
+    { id: 'transcript-bottom', keys: ['Ctrl+End'], context: 'transcript', description: t('screen.key.transcript-bottom') },
+    /* R4 Q-R4-6: Ctrl+L redraws, keeping the conversation and the draft (Claude Code 2.1.280, 2026-09-22, gate D.4; Codex,
+       Gemini, Hermes); the model picker moves to Alt+P (Claude Code `Meta+P`, keybindings.md :105) and the provider picker
+       keeps /provider only. */
+    { id: 'redraw', keys: ['Ctrl+L'], context: 'global', description: t('screen.key.redraw') },
+    { id: 'permission-cycle', keys: ['Shift+Tab', 'Alt+M'], context: 'global', description: t('screen.key.permission-cycle') },
+    { id: 'model-picker', keys: ['Alt+P'], context: 'composer', description: t('screen.key.model-picker') },
+    { id: 'provider-picker', keys: [], context: 'composer', description: t('screen.key.provider-picker') },
+    { id: 'reasoning-toggle', keys: ['Ctrl+T'], context: 'global', description: t('screen.key.reasoning-toggle') },
+    { id: 'external-editor', keys: ['Ctrl+G'], context: 'composer', description: t('screen.key.external-editor') },
+    { id: 'tool-details', keys: ['Ctrl+O'], context: 'global', description: t('screen.key.tool-details') },
+    { id: 'approval-once', keys: ['1'], context: 'approval', description: t('screen.key.approval-once') },
+    { id: 'approval-session', keys: ['2'], context: 'approval', description: t('screen.key.approval-session') },
+    { id: 'approval-always', keys: ['3'], context: 'approval', description: t('screen.key.approval-always') },
+    { id: 'approval-deny-once', keys: ['4'], context: 'approval', description: t('screen.key.approval-deny-once') },
+    { id: 'approval-deny-always', keys: ['5'], context: 'approval', description: t('screen.key.approval-deny-always') },
+    { id: 'approval-cancel', keys: ['Esc', 'Ctrl+C'], context: 'approval', description: t('screen.key.approval-cancel') },
+    { id: 'approval-view', keys: ['v'], context: 'approval', description: t('screen.key.approval-view') },
+    /* R3 gate E11, Q-R3-6: the four choices are a list with Deny highlighted; ↑/↓ move the highlight, Enter confirms it. */
+    { id: 'approval-up', keys: ['Up'], context: 'approval', description: t('screen.key.approval-up') },
+    { id: 'approval-down', keys: ['Down'], context: 'approval', description: t('screen.key.approval-down') },
+    { id: 'approval-confirm', keys: ['Enter'], context: 'approval', description: t('screen.key.approval-confirm') },
+    { id: 'overlay-close', keys: ['Esc', 'Enter', '?'], context: 'help', description: t('screen.key.overlay-close') },
+    { id: 'help', keys: ['?'], context: 'composer', description: t('screen.key.help') },
+    ...pickerBindings,
+    ...commandBindings,
+]);
+export function keybindingHelp(bindings = KEYBINDINGS) { return bindings.filter(x => x.keys.length > 0).map(x => x.keys.join(' / ') + ' — ' + x.description).join('\n'); }
+export function cyclePermissionMode(mode) { return mode === 'default' ? 'acceptEdits' : mode === 'acceptEdits' ? 'plan' : 'default'; }
+export function inkKeyChord(ch, key) {
+    if (key.shift && key.tab)
+        return 'Shift+Tab';
+    if (key.shift && key.return)
+        return 'Shift+Enter';
+    if (key.shift && (key.pageUp || key.pageup))
+        return 'Shift+PageUp';
+    if (key.shift && (key.pageDown || key.pagedown))
+        return 'Shift+PageDown';
+    if (key.shift && key.home)
+        return 'Shift+Home';
+    if (key.shift && key.end)
+        return 'Shift+End';
+    if (key.shift && key.leftArrow)
+        return 'Shift+Left';
+    if (key.shift && key.rightArrow)
+        return 'Shift+Right';
+    if (key.shift && key.upArrow)
+        return 'Shift+Up';
+    if (key.shift && key.downArrow)
+        return 'Shift+Down';
+    if (key.ctrl && key.home)
+        return 'Ctrl+Home';
+    if (key.ctrl && key.end)
+        return 'Ctrl+End'; /* R1 E15: listed in /help; app.ts scrolls on them */
+    if (key.ctrl && key.shift && ch)
+        return 'Ctrl+Shift+' + ch.toUpperCase();
+    if (key.meta && key.shift && ch)
+        return 'Alt+Shift+' + ch.toUpperCase();
+    if (key.ctrl && ch)
+        return 'Ctrl+' + ch.toUpperCase();
+    if (key.meta && ch)
+        return 'Alt+' + ch.toUpperCase();
+    if (key.pageUp || key.pageup)
+        return 'PageUp';
+    if (key.pageDown || key.pagedown)
+        return 'PageDown';
+    if (key.home)
+        return 'Home';
+    if (key.end)
+        return 'End';
+    if (key.leftArrow)
+        return 'Left';
+    if (key.rightArrow)
+        return 'Right';
+    if (key.upArrow)
+        return 'Up';
+    if (key.downArrow)
+        return 'Down';
+    if (key.return)
+        return 'Enter';
+    if (key.tab)
+        return 'Tab';
+    if (key.escape)
+        return 'Esc';
+    if (key.backspace)
+        return 'Backspace';
+    if (key.delete)
+        return 'Delete';
+    return ch.length === 1 ? ch : null;
+}
+/*
+ * R3-KEYS (coordinator, measured in the R3 acceptance run): Ctrl+O typed in the same stdin chunk as text
+ * ("\u000fKEYS glued…") reached Ink as ONE input string, so U+000F was inserted into the composer and sent to the model.
+ * No C0 or DEL character may reach the editor or the model except a line break: in a mixed chunk the LEADING control
+ * character acts as its key (Ctrl+<letter>, Enter, Backspace; LF is Ctrl+J, the newline key), and the rest is text in
+ * which CR and CRLF become LF and every other C0/DEL character is dropped. The same text rule applies to a bracketed paste
+ * (app.ts). A chunk with no control character, and a key Ink already parsed, pass unchanged.
+ * Owner decision (R3 follow-up): TAB is kept. A tab reaches the model unchanged (Gemini CLI's stripUnsafeCharacters keeps
+ * 0x09 so a pasted Makefile stays valid); a chunk that STARTS with a tab is text, only a lone tab is the Tab key (Ink parses
+ * that one). The composer draws a tab as spaces for display only (components/composer.ts).
+ */
+const CONTROL = /[\x00-\x08\x0b-\x1f\x7f]/u;
+export function sanitizeInputText(text) {
+    return text.replace(/\r\n?/gu, '\n').replace(/[\x00-\x08\x0b-\x1f\x7f]/gu, '');
+}
+function leadingKey(code) {
+    if (code === 0x0d)
+        return { ch: '\r', key: { return: true } };
+    if (code === 0x09)
+        return null; /* a tab is text (owner decision, R3 follow-up), never Ctrl+I */
+    if (code === 0x7f || code === 0x08)
+        return { ch: '', key: { backspace: true } };
+    if (code === 0x0a)
+        return { ch: 'j', key: { ctrl: true } };
+    if (code >= 0x01 && code <= 0x1a)
+        return { ch: String.fromCharCode(code + 0x60), key: { ctrl: true } };
+    return null;
+}
+export function splitInputChunk(ch, key) {
+    if (typeof ch !== 'string' || ch.length <= 1 || key.ctrl || key.meta || !CONTROL.test(ch.replace(/\n/gu, '')))
+        return [{ ch, key }];
+    const parts = [];
+    const lead = leadingKey(ch.charCodeAt(0));
+    const rest = lead ? ch.slice(1) : ch;
+    if (lead)
+        parts.push(lead);
+    const text = sanitizeInputText(rest);
+    if (text)
+        parts.push({ ch: text, key: {} });
+    return parts;
+}
+export function resolveKeybinding(ch, key, contexts, bindings = KEYBINDINGS) { const chord = inkKeyChord(ch, key); if (!chord)
+    return null; for (const context of contexts) {
+    const binding = bindings.find(row => row.context === context && row.keys.includes(chord));
+    if (binding)
+        return binding.id;
+} return null; }

package/dist/tui/keymap-resolver.js

@@ -0,0 +1,91 @@
+import { KEYBINDINGS } from "./keybindings.js";
+const SPECIAL = new Map([
+    ['pageup', 'PageUp'], ['pagedown', 'PageDown'], ['home', 'Home'], ['end', 'End'],
+    ['left', 'Left'], ['right', 'Right'], ['up', 'Up'], ['down', 'Down'],
+    ['enter', 'Enter'], ['tab', 'Tab'], ['esc', 'Esc'], ['escape', 'Esc'],
+    ['backspace', 'Backspace'], ['delete', 'Delete'],
+]);
+const SAFETY = [
+    { bindingId: 'interrupt', chord: 'Ctrl+C' },
+    { bindingId: 'exit', chord: 'Ctrl+D' },
+    { bindingId: 'approval-cancel', chord: 'Esc' },
+];
+export function canonicalKeyChord(value) {
+    if (typeof value !== 'string')
+        return null;
+    const raw = value.trim();
+    if (!raw || /[\x00-\x1f\x7f]/u.test(raw))
+        return null;
+    if ([...raw].length === 1 && raw !== '+')
+        return raw;
+    const special = SPECIAL.get(raw.toLowerCase());
+    if (special)
+        return special;
+    const shifted = /^shift\+(tab|enter)$/iu.exec(raw);
+    if (shifted)
+        return shifted[1].toLowerCase() === 'tab' ? 'Shift+Tab' : 'Shift+Enter';
+    const modified = /^(ctrl|alt)\+([^+\s])$/iu.exec(raw);
+    if (modified) {
+        const modifier = modified[1].toLowerCase() === 'ctrl' ? 'Ctrl' : 'Alt';
+        return modifier + '+' + modified[2].toUpperCase();
+    }
+    return null;
+}
+function cloneDefaults() { return KEYBINDINGS.map(row => ({ ...row, keys: [...row.keys] })); }
+export function resolveKeymap(overrides) {
+    const bindings = cloneDefaults();
+    const diagnostics = [];
+    if (overrides) {
+        for (const [bindingId, rawKeys] of Object.entries(overrides)) {
+            const targets = bindings.filter(row => row.id === bindingId);
+            if (targets.length === 0) {
+                diagnostics.push({ code: 'KEYMAP_UNKNOWN_BINDING', bindingId, message: 'Unknown key binding: ' + bindingId });
+                continue;
+            }
+            const keys = [];
+            const seen = new Set();
+            for (const raw of rawKeys) {
+                const chord = canonicalKeyChord(raw);
+                if (!chord) {
+                    diagnostics.push({ code: 'KEYMAP_CHORD_INVALID', bindingId, chord: String(raw), message: 'Invalid key chord for ' + bindingId + ': ' + String(raw) });
+                    continue;
+                }
+                if (seen.has(chord)) {
+                    diagnostics.push({ code: 'KEYMAP_DUPLICATE_CHORD', bindingId, chord, message: 'Duplicate key chord for ' + bindingId + ': ' + chord });
+                    continue;
+                }
+                seen.add(chord);
+                keys.push(chord);
+            }
+            for (const binding of targets)
+                binding.keys = [...keys];
+        }
+    }
+    const byContext = new Map();
+    for (const binding of bindings) {
+        for (const chord of binding.keys) {
+            const key = binding.context + '\u0000' + chord;
+            const previous = byContext.get(key);
+            if (previous && previous.bindingId !== binding.id) {
+                diagnostics.push({ code: 'KEYMAP_CONFLICT', bindingId: binding.id, chord, conflictWith: previous.bindingId, message: 'Key chord ' + chord + ' conflicts in ' + binding.context + ': ' + previous.bindingId + ' vs ' + binding.id });
+            }
+            else
+                byContext.set(key, { bindingId: binding.id, chord });
+        }
+    }
+    for (const reserved of SAFETY) {
+        const binding = bindings.find(row => row.id === reserved.bindingId);
+        if (!binding?.keys.includes(reserved.chord)) {
+            diagnostics.push({ code: 'KEYMAP_RESERVED_CHORD', bindingId: reserved.bindingId, chord: reserved.chord, message: 'Safety key ' + reserved.chord + ' must remain bound to ' + reserved.bindingId });
+        }
+    }
+    return { bindings, diagnostics };
+}
+export function assertValidKeymap(overrides) {
+    const resolved = resolveKeymap(overrides);
+    if (resolved.diagnostics.length) {
+        const first = resolved.diagnostics[0];
+        throw Object.assign(new Error(first.message), { code: 'KEYMAP_INVALID', details: { diagnostics: resolved.diagnostics } }); /* R2 (gate E6): code on error.code only */
+    }
+    return resolved.bindings;
+}

package/dist/tui/launch-state.js

@@ -0,0 +1,148 @@
+/*
+ * R4 CONTRACT (owner: lane F; stub written by the coordinator so both lanes compile). Owner decision Q-R4-4: the full boot
+ * plays only on the first launch and after an update (a new version or build commit); every other launch gets the short
+ * boot (the final frame, at most 600 ms). The launch state lives under the data root, never the config root (gate E5), so
+ * a test profile starts empty and its first launch is a full boot. Lane N only CALLS bootPlan (app.ts) and passes `mode`
+ * to BootSequence; lane F owns the body (reading and recording the launch) and may not change the signature.
+ *
+ * R4 lane F (the body):
+ * - The record is `<dataRoot>/launch-state.json`, schema `talos.cli.launch-state.v1`: the version and build seen by the last
+ *   launch, when TALOS first ran and when it last ran. Nothing else is kept (no path, no project, no person's data).
+ * - It fails TOWARD the full boot: a record that is missing, unreadable or of another shape is a first launch, and a record
+ *   that cannot be written (read-only profile, a file where the folder should be) never throws — that launch just plays the
+ *   full boot again, which is the harmless side.
+ * - A build that cannot be read (`build` null or absent) is not an update: development builds report no build, and a
+ *   missing value must not replay the full boot at every start. A different non-empty build is an update.
+ * - Written through a temporary file and a rename, so a crash or a second TALOS starting at the same moment leaves either
+ *   the old record or the new one, never half of one (the pattern of `security/project-trust.ts` atomicWriteText).
+ * - Synchronous on purpose: lane N calls it once while the first frame is prepared, and the file is a few hundred bytes.
+ */
+import { mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const SCHEMA = 'talos.cli.launch-state.v1';
+export function launchStatePath(dataRoot) { return join(dataRoot, 'launch-state.json'); }
+function readRecord(file) {
+    try {
+        const value = JSON.parse(readFileSync(file, 'utf8'));
+        if (!value || value.schema !== SCHEMA || typeof value.version !== 'string' || (value.build !== null && typeof value.build !== 'string')
+            || typeof value.firstLaunchAt !== 'string' || typeof value.lastLaunchAt !== 'string')
+            return null;
+        return value;
+    }
+    catch {
+        return null;
+    }
+}
+function writeRecord(dataRoot, record) {
+    const file = launchStatePath(dataRoot);
+    const temporary = `${file}.tmp-${process.pid}-${Date.now()}`;
+    try {
+        mkdirSync(dataRoot, { recursive: true });
+        writeFileSync(temporary, `${JSON.stringify(record, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+        renameSync(temporary, file);
+    }
+    catch {
+        try {
+            rmSync(temporary, { force: true });
+        }
+        catch { /* the temporary file was never created */ }
+    }
+}
+/** P17: whether this profile has never launched the interface, read without recording a launch (the trust question asks). */
+export function isFirstLaunch(dataRoot) {
+    try {
+        return readRecord(launchStatePath(dataRoot)) === null;
+    }
+    catch {
+        return false;
+    }
+}
+export function bootPlan(input) {
+    const previous = readRecord(launchStatePath(input.dataRoot));
+    const build = typeof input.build === 'string' && input.build !== '' ? input.build : null;
+    const firstLaunch = previous === null;
+    const updated = !firstLaunch && (previous.version !== input.version || (build !== null && previous.build !== null && previous.build !== build));
+    const at = new Date(input.now ?? Date.now()).toISOString();
+    writeRecord(input.dataRoot, { schema: SCHEMA, version: input.version, build: build ?? previous?.build ?? null, firstLaunchAt: previous?.firstLaunchAt ?? at, lastLaunchAt: at });
+    return { mode: firstLaunch || updated ? 'full' : 'short', firstLaunch };
+}
+/*
+ * R4 Q-R4-4 (i)(a): the build commit, so that "after an update" also means a new commit of a development checkout (whose
+ * version is always 1.0.0). It is the commit git records for the checkout the running CLI comes from, read the way git
+ * stores it — HEAD, a branch ref or packed-refs, and for a linked worktree its `.git` file and `commondir` — without spawning
+ * git. An installed copy has no checkout: null, and the version alone decides (a release has its own version). Read once
+ * per process; a checkout that cannot be read is null, never an error (the boot falls back to the version).
+ */
+const SHA = /^[0-9a-f]{40}$/u;
+function readText(file) { try {
+    return readFileSync(file, 'utf8');
+}
+catch {
+    return null;
+} }
+function gitDirFrom(start) {
+    let cursor = resolve(start);
+    for (let depth = 0; depth < 12; depth++) {
+        const dotGit = join(cursor, '.git');
+        try {
+            const info = statSync(dotGit);
+            if (info.isDirectory())
+                return dotGit;
+            if (info.isFile()) {
+                const match = /^gitdir:\s*(.+?)\s*$/mu.exec(readText(dotGit) ?? '');
+                if (!match)
+                    return null;
+                return isAbsolute(match[1]) ? match[1] : resolve(cursor, match[1]);
+            }
+        }
+        catch { /* no .git here: go up */ }
+        const parent = dirname(cursor);
+        if (parent === cursor)
+            return null;
+        cursor = parent;
+    }
+    return null;
+}
+function refCommit(gitDir, commonDir, ref) {
+    if (!/^refs\/[\w./-]+$/u.test(ref) || ref.includes('..'))
+        return null;
+    for (const dir of [gitDir, commonDir]) {
+        const loose = readText(join(dir, ...ref.split('/')))?.trim();
+        if (loose && SHA.test(loose))
+            return loose;
+    }
+    for (const line of (readText(join(commonDir, 'packed-refs')) ?? '').split(/\r?\n/u)) {
+        const [sha, name] = line.trim().split(' ');
+        if (name === ref && sha && SHA.test(sha))
+            return sha;
+    }
+    return null;
+}
+export function buildIdFrom(start) {
+    const gitDir = gitDirFrom(start);
+    if (!gitDir)
+        return null;
+    const common = readText(join(gitDir, 'commondir'))?.trim();
+    const commonDir = common ? resolve(gitDir, common) : gitDir;
+    const head = readText(join(gitDir, 'HEAD'))?.trim() ?? '';
+    if (SHA.test(head))
+        return head;
+    const match = /^ref:\s*(\S+)$/u.exec(head);
+    return match ? refCommit(gitDir, commonDir, match[1]) : null;
+}
+let cachedBuildId;
+/** The running CLI's build commit (or that of the checkout holding `start`); null for an installed copy. */
+export function currentBuildId(start) {
+    if (start !== undefined)
+        return buildIdFrom(start);
+    if (cachedBuildId === undefined) {
+        try {
+            cachedBuildId = buildIdFrom(dirname(fileURLToPath(import.meta.url)));
+        }
+        catch {
+            cachedBuildId = null;
+        }
+    }
+    return cachedBuildId;
+}

package/dist/tui/line-diff.js

@@ -0,0 +1,57 @@
+/*
+ * R3 CONTRACT (owner: lane R+D; stub written by the coordinator so both lanes compile). The ONE line diff (Q-R3-11: jsdiff
+ * 9.0.0, pinned) feeding the write/edit row summary, its Ctrl+O diff and the approval preview (gate E10). It returns the
+ * existing DiffModel so components/diff.ts renders it. Lane S+P only CALLS lineDiff; lane R+D owns the body and may not
+ * change the signature.
+ *
+ * R3 lane RD body. jsdiff's `structuredPatch` (Myers, the library Gemini 8.0.3, Pi 8.0.4, Qwen ^7 and OpenCode diff with,
+ * gate §3.2) with 3 context lines, the same as `/diff` (`git diff --unified=3`). The counts are the `+`/`-` lines of the
+ * hunks, so a moved line and an edit of one of two identical lines are seen — the multiset count it replaces saw neither.
+ * Lines are compared exactly as written (a CRLF → LF change is a change); a trailing `\r` never reaches the screen.
+ * A change too large to compare in time (jsdiff `timeout`, and a line cap that keeps a huge file off the event loop)
+ * returns the whole replacement flagged `approximate` with one plain row saying so: never a fake minimal diff.
+ */
+import { structuredPatch } from 'diff';
+import { t } from "../i18n/index.js";
+/* Beyond these the diff is not attempted (Myers is O((N+M)·D)); the row then states the sizes, not a count it cannot know. */
+const MAX_LINES = 50_000;
+const TIMEOUT_MS = 250;
+const CONTEXT = 3;
+function linesOf(text) { if (text === '')
+    return 0; const n = text.split('\n').length; return text.endsWith('\n') ? n - 1 : n; }
+function row(kind, text, oldLine = null, newLine = null) { return { kind, text: text.endsWith('\r') ? text.slice(0, -1) : text, oldLine, newLine }; }
+export function lineDiff(before, after, { path = 'file' } = {}) {
+    const old = before ?? '', next = String(after ?? '');
+    if (old === next)
+        return { added: 0, removed: 0, model: { files: [], plain: [], empty: true } };
+    const oldCount = linesOf(old), newCount = linesOf(next);
+    const patch = oldCount + newCount > MAX_LINES ? undefined : structuredPatch(path, path, old, next, undefined, undefined, { context: CONTEXT, timeout: TIMEOUT_MS });
+    if (!patch) {
+        const note = row('plain', t('tool.diff.tooLarge', { before: oldCount, after: newCount }));
+        return { added: newCount, removed: oldCount, approximate: true, model: { files: [], plain: [note], empty: false } };
+    }
+    const rows = [];
+    let added = 0, removed = 0;
+    for (const hunk of patch.hunks) {
+        /* The header the way `git diff` and jsdiff's own formatPatch print it: an empty side starts one line earlier. */
+        const oldStart = hunk.oldLines === 0 ? hunk.oldStart - 1 : hunk.oldStart, newStart = hunk.newLines === 0 ? hunk.newStart - 1 : hunk.newStart;
+        rows.push(row('hunk', `@@ -${oldStart},${hunk.oldLines} +${newStart},${hunk.newLines} @@`));
+        let oldLine = hunk.oldStart, newLine = hunk.newStart;
+        for (const text of hunk.lines) {
+            const mark = text[0], body = text.slice(1);
+            if (mark === '+') {
+                rows.push(row('add', body, null, newLine++));
+                added++;
+            }
+            else if (mark === '-') {
+                rows.push(row('remove', body, oldLine++, null));
+                removed++;
+            }
+            else if (mark === '\\')
+                rows.push(row('no-newline', text));
+            else
+                rows.push(row('context', body, oldLine++, newLine++));
+        }
+    }
+    return { added, removed, model: { files: [{ oldPath: path, newPath: path, rows }], plain: [], empty: rows.length === 0 } };
+}