talos-code 0.0.1 → 0.1.0

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) }; }

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; }