talos-code 0.0.1 → 0.1.0

package/dist/tui/prompt-history-store.js

@@ -0,0 +1,116 @@
+/*
+ * R5b D5 (owner decision Q-R5-15): the prompts a person sends, kept across sessions. One file per project under the data
+ * root (`<dataRoot>/history/<projectId>.jsonl`, never in the project), the last 1,000 (Hermes, the Node REPL); each line
+ * `{v:1,text,collapsedPastes,at}`, the newest last. Before a prompt reaches the disk its secret-shaped values and the
+ * environment's secret values are masked (diagnostics/redact.ts, the same masks as the logs), piece by piece so a collapsed
+ * paste still covers its own text afterwards. `ui.history.persist: false` turns it off: nothing is read and nothing is
+ * written. Before R5b the history lived in memory only (R4 E17).
+ *
+ * Writes: one `appendFile` per prompt of one short line (a prompt over 64 KiB stays in memory only: long interleaved appends
+ * are how a jsonl file breaks, 2026-09-04), and a rewrite to the last 1,000 through a temporary file and a rename once the
+ * file passes 1,200 lines. A line that does not parse is skipped, never fatal.
+ */
+import { randomUUID } from 'node:crypto';
+import { appendFile, chmod, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { loadEffectiveConfig } from "../config/load.js";
+import { createRedactor } from "../diagnostics/redact.js";
+import { projectId } from "../paths.js";
+export const PROMPT_HISTORY_LIMIT = 1000;
+const PRUNE_AT = 1200;
+const MAX_RECORD_CHARS = 64 * 1024;
+export function promptHistoryFile(paths, projectRoot) { return join(paths.dataRoot, 'history', `${projectId(projectRoot)}.jsonl`); }
+/** The draft with its secrets masked; each paste block is masked on its own and its offsets follow the new text. */
+export function maskDraft(draft, redactor) {
+    const pastes = [...draft.collapsedPastes].sort((a, b) => a.start - b.start);
+    let text = '', cursor = 0;
+    const kept = [];
+    for (const paste of pastes) {
+        if (paste.start < cursor || paste.end > draft.text.length || paste.end <= paste.start)
+            continue;
+        text += redactor.text(draft.text.slice(cursor, paste.start));
+        const inner = redactor.text(draft.text.slice(paste.start, paste.end)), start = text.length;
+        text += inner;
+        kept.push({ start, end: text.length, chars: inner.length, lines: paste.lines });
+        cursor = paste.end;
+    }
+    text += redactor.text(draft.text.slice(cursor));
+    return { text, collapsedPastes: kept };
+}
+function parseLine(line) {
+    try {
+        const row = JSON.parse(line);
+        if (row?.v !== 1 || typeof row.text !== 'string')
+            return null;
+        const pastes = Array.isArray(row.collapsedPastes) ? row.collapsedPastes.filter((p) => [p?.start, p?.end, p?.chars, p?.lines].every(Number.isSafeInteger) && p.start >= 0 && p.end <= row.text.length && p.start < p.end) : [];
+        return { text: row.text, collapsedPastes: pastes.map((p) => ({ start: p.start, end: p.end, chars: p.chars, lines: p.lines })) };
+    }
+    catch {
+        return null;
+    }
+}
+export function createPromptHistoryStore({ paths, projectRoot, secrets }) {
+    const file = promptHistoryFile(paths, projectRoot);
+    const redactor = createRedactor(secrets);
+    let lines = null;
+    const readRows = async () => { try {
+        return (await readFile(file, 'utf8')).split('\n').filter(Boolean);
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT')
+            return [];
+        throw error;
+    } };
+    const newestFirst = (raw) => {
+        const seen = new Set(), rows = [];
+        for (let index = raw.length - 1; index >= 0 && rows.length < PROMPT_HISTORY_LIMIT; index -= 1) {
+            const row = parseLine(raw[index]);
+            if (!row || seen.has(row.text))
+                continue;
+            seen.add(row.text);
+            rows.push(row);
+        }
+        return rows;
+    };
+    return {
+        file,
+        async load() { const raw = await readRows(); lines = raw.length; return newestFirst(raw); },
+        async append(draft) {
+            if (!draft.text.trim() || draft.text.length > MAX_RECORD_CHARS)
+                return;
+            const masked = maskDraft(draft, redactor);
+            await mkdir(dirname(file), { recursive: true, mode: 0o700 });
+            await appendFile(file, `${JSON.stringify({ v: 1, text: masked.text, collapsedPastes: masked.collapsedPastes, at: new Date().toISOString() })}\n`, { encoding: 'utf8', mode: 0o600 });
+            if (lines === null)
+                lines = (await readRows()).length;
+            else
+                lines += 1;
+            if (lines > PRUNE_AT) {
+                const kept = newestFirst(await readRows()).reverse().map(row => JSON.stringify({ v: 1, text: row.text, collapsedPastes: row.collapsedPastes, at: new Date().toISOString() }));
+                const temp = `${file}.${process.pid}.${randomUUID()}.tmp`;
+                try {
+                    await writeFile(temp, kept.map(line => line + '\n').join(''), { encoding: 'utf8', mode: 0o600 });
+                    await rename(temp, file);
+                }
+                catch (error) {
+                    await rm(temp, { force: true }).catch(() => { });
+                    throw error;
+                }
+                try {
+                    await chmod(file, 0o600);
+                }
+                catch { /* Windows */ }
+                lines = kept.length;
+            }
+        },
+    };
+}
+/** On unless `ui.history.persist` is false; a configuration that cannot be read keeps it off (nothing written by doubt). */
+export async function promptHistoryEnabled({ paths, projectRoot }) {
+    try {
+        return (await loadEffectiveConfig({ paths, projectRoot })).value.ui?.history?.persist !== false;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/tui/queue-store.js

@@ -0,0 +1,110 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, open, readFile, rename, rm, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { validateCliAttachments } from "../runtime/attachments.js";
+export const QUEUE_SCHEMA = 'talos.cli.queue.v1';
+export const QUEUE_MAX_ENTRIES = 64;
+export const QUEUE_TEXT_MAX_BYTES = 1024 * 1024;
+export const QUEUE_STORE_MAX_BYTES = 64 * 1024 * 1024;
+export class QueueStoreError extends Error {
+    code;
+    constructor(code, message = code) { super(message); this.name = 'QueueStoreError'; this.code = code; }
+}
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
+function session(value) { if (typeof value !== 'string' || !value.trim() || value.length > 512 || /[\0\r\n]/u.test(value))
+    throw new QueueStoreError('QUEUE_STORE_INVALID', 'Session id is invalid.'); return value; }
+function cloneEntry(entry) { return { ...entry, ...(entry.attachments ? { attachments: entry.attachments.map(row => ({ ...row })) } : {}) }; }
+function validateEntry(value) {
+    if (!value || typeof value !== 'object')
+        throw new QueueStoreError('QUEUE_STORE_INVALID', 'Queue entry is invalid.');
+    const row = value;
+    if (typeof row.id !== 'string' || !UUID.test(row.id) || !(row.kind === 'prompt' || row.kind === 'command') || !(row.status === 'pending' || row.status === 'dispatching') || typeof row.text !== 'string')
+        throw new QueueStoreError('QUEUE_STORE_INVALID', 'Queue entry shape is invalid.');
+    if (!row.text.trim() || Buffer.byteLength(row.text, 'utf8') > QUEUE_TEXT_MAX_BYTES)
+        throw new QueueStoreError('QUEUE_STORE_INVALID', 'Queue entry text is invalid.');
+    if (row.kind === 'command' && row.attachments !== undefined)
+        throw new QueueStoreError('QUEUE_STORE_INVALID', 'Commands cannot carry attachments.');
+    let attachments;
+    if (row.attachments !== undefined) {
+        try {
+            attachments = validateCliAttachments(row.attachments);
+        }
+        catch {
+            throw new QueueStoreError('QUEUE_STORE_INVALID', 'Queue attachment snapshot is invalid.');
+        }
+    }
+    return { id: row.id, kind: row.kind, text: row.text, status: row.status, ...(attachments?.length ? { attachments } : {}) };
+}
+function validated(entries) {
+    if (!Array.isArray(entries) || entries.length > QUEUE_MAX_ENTRIES)
+        throw new QueueStoreError('QUEUE_STORE_LIMIT', `A session queue can retain at most ${QUEUE_MAX_ENTRIES} entries.`);
+    return entries.map(validateEntry);
+}
+export function createQueueStore({ rootDir }) {
+    if (typeof rootDir !== 'string' || !rootDir.trim())
+        throw new QueueStoreError('QUEUE_STORE_INVALID', 'Queue root is required.');
+    const fileForSession = (sessionId) => path.join(rootDir, createHash('sha256').update(session(sessionId)).digest('hex') + '.json');
+    async function syncDirectory() { try {
+        const handle = await open(rootDir, 'r');
+        try {
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch { /* Not available on every platform. */ } }
+    async function save(sessionId, entries) {
+        const id = session(sessionId), rows = validated(entries).map(cloneEntry);
+        const body = JSON.stringify({ schema: QUEUE_SCHEMA, sessionId: id, entries: rows }) + '\n';
+        if (Buffer.byteLength(body, 'utf8') > QUEUE_STORE_MAX_BYTES)
+            throw new QueueStoreError('QUEUE_STORE_LIMIT', 'Queue store exceeds its byte budget.');
+        await mkdir(rootDir, { recursive: true, mode: 0o700 });
+        const file = fileForSession(id), temp = path.join(rootDir, '.' + path.basename(file) + '.' + process.pid + '.' + randomUUID() + '.tmp');
+        let handle = null;
+        try {
+            handle = await open(temp, 'wx', 0o600);
+            await handle.writeFile(body, 'utf8');
+            await handle.sync();
+            await handle.close();
+            handle = null;
+            await rename(temp, file);
+            await syncDirectory();
+        }
+        catch (error) {
+            try {
+                await handle?.close();
+            }
+            catch { }
+            await rm(temp, { force: true }).catch(() => { });
+            if (error instanceof QueueStoreError)
+                throw error;
+            throw Object.assign(new QueueStoreError('QUEUE_STORE_WRITE_FAILED', 'Queue state could not be written atomically.'), { cause: error });
+        }
+    }
+    async function load(sessionId) {
+        const id = session(sessionId), file = fileForSession(id);
+        let info;
+        try {
+            info = await stat(file);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return [];
+            throw Object.assign(new QueueStoreError('QUEUE_STORE_READ_FAILED'), { cause: error });
+        }
+        if (!info.isFile() || info.size > QUEUE_STORE_MAX_BYTES)
+            throw new QueueStoreError('QUEUE_STORE_INVALID', 'Queue store file is invalid.');
+        let parsed;
+        try {
+            parsed = JSON.parse(await readFile(file, 'utf8'));
+        }
+        catch {
+            throw new QueueStoreError('QUEUE_STORE_INVALID', 'Queue store is not valid JSON.');
+        }
+        if (parsed?.schema !== QUEUE_SCHEMA || parsed?.sessionId !== id || !Array.isArray(parsed?.entries))
+            throw new QueueStoreError('QUEUE_STORE_INVALID', 'Queue store schema/session mismatch.');
+        return validated(parsed.entries).map(cloneEntry);
+    }
+    return { fileForSession, save, load };
+}

package/dist/tui/regions/budget.js

@@ -0,0 +1,59 @@
+/*
+ * R1 lane L — ONE height budget per frame (gate E1, E3, E13; owner decisions Q-R1-3, Q-R1-8).
+ *
+ * Pure: it receives the frame height and the exact row counts of the content (composer lines, chrome lines, the rows a
+ * panel asks for) and returns the height of every region. The regions are then rendered as boxes of EXACTLY these
+ * heights with their overflow hidden, so the sum of the rendered rows equals `frameRows` by construction and a region
+ * whose content is taller is clipped instead of overwriting its neighbours (review D-02). No row count here is an
+ * estimate: every input is counted by the same width function Ink lays text out with (text-width.ts, E4).
+ */
+import { t } from "../../i18n/index.js";
+export const MIN_COLUMNS = 40;
+export const MIN_ROWS = 12;
+/* R2 (Q-R2-10): the notice is on acceptance frames (s12), so its words are the dictionary's; the bytes did not change. */
+export const TOO_SMALL_TEXT = t('screen.layout.tooSmall', { columns: MIN_COLUMNS, rows: MIN_ROWS });
+/* A panel whose budget is below this many rows takes the whole frame instead of a sliver (Q-R1-3). */
+export const PANEL_FULL_SCREEN_BELOW = 6;
+export const COMPOSER_MAX_ROWS = 10;
+const whole = (value) => { const n = Number(value); return Number.isFinite(n) ? Math.max(0, Math.floor(n)) : 0; };
+const request = (value) => value === null || value === undefined ? 0 : value === Infinity ? Infinity : whole(value);
+export function composerRowsCap(rows) { return Math.max(3, Math.min(COMPOSER_MAX_ROWS, Math.floor(whole(rows) / 3))); }
+export function budget(input) {
+    const rows = whole(input.rows), columns = whole(input.columns), frameRows = Math.max(1, Math.min(rows, whole(input.frameRows)));
+    const zero = { header: 0, transcript: 0, diff: 0, overlay: 0, aux: 0, menu: 0, status: 0, composer: 0, composerContent: 0, composerHints: 0, shortcut: 0, roster: 0, extras: 0, footer: 0, overlayMaxRows: 0 };
+    if (columns < MIN_COLUMNS || rows < MIN_ROWS)
+        return { tooSmall: true, frameRows, fullScreenPanel: false, ...zero };
+    /* Composer: border + text + hints, capped at min(10, ⌊rows/3⌋) (E3). Hints go first when the cap bites; the text
+       keeps at least one row, and a longer text scrolls inside the composer to the cursor. */
+    const cap = composerRowsCap(rows);
+    const composerHints = Math.min(whole(input.composerHints), Math.max(0, cap - 3));
+    const composerContent = Math.max(1, Math.min(Math.max(1, whole(input.composerLines)), cap - 2 - composerHints));
+    const composer = 2 + composerContent + composerHints;
+    const status = input.status === undefined ? 1 : Math.min(1, whole(input.status));
+    const overlayMaxRows = Math.max(0, frameRows - composer - status);
+    const wants = { overlay: request(input.overlay), menu: request(input.menu), diff: request(input.diff), aux: request(input.aux) };
+    const anyPanel = wants.overlay > 0 || wants.menu > 0 || wants.diff > 0 || wants.aux > 0;
+    if (anyPanel && overlayMaxRows < PANEL_FULL_SCREEN_BELOW) {
+        /* Q-R1-3: a panel squeezed below six rows is unusable; it takes the frame. Unreachable at ≥ 40×12 with the
+           composer cap above (frame ≥ 11, composer ≤ 4, status 1 → ≥ 6), kept for a frame policy that changes. */
+        const first = wants.overlay > 0 ? 'overlay' : wants.menu > 0 ? 'menu' : wants.diff > 0 ? 'diff' : 'aux';
+        return { tooSmall: false, frameRows, fullScreenPanel: true, ...zero, [first]: frameRows, overlayMaxRows: frameRows };
+    }
+    let room = overlayMaxRows;
+    const take = (want) => { const got = Math.min(want, room); room -= got; return got; };
+    const overlay = take(wants.overlay), menu = take(wants.menu), diff = take(wants.diff), aux = take(wants.aux);
+    /* Chrome after the panels, kept in this order while it fits, so it is DROPPED in the reverse order the owner set:
+       roster (and its queue/reasoning lines) first, then the shortcut strip, then the header, the footer last (E13).
+       Without a panel the transcript keeps at least one row. */
+    const transcriptMin = overlay + menu + diff + aux > 0 ? 0 : 1;
+    let spare = room - transcriptMin;
+    const keep = (want) => { const n = whole(want); if (n <= spare) {
+        spare -= n;
+        return n;
+    } return 0; };
+    const footer = keep(input.footer), header = keep(input.header), shortcut = keep(input.shortcut), roster = keep(input.roster), extras = roster ? keep(input.extras) : 0;
+    const transcript = spare + transcriptMin;
+    return { tooSmall: false, frameRows, fullScreenPanel: false, header, transcript, diff, overlay, aux, menu, status, composer, composerContent, composerHints, shortcut, roster, extras, footer, overlayMaxRows };
+}
+/* The sum of every region; equals `frameRows` for every budget that is not "too small" (asserted by the grid test). */
+export function budgetRows(b) { return b.header + b.transcript + b.diff + b.overlay + b.aux + b.menu + b.status + b.composer + b.shortcut + b.roster + b.extras + b.footer; }

package/dist/tui/regions/views.js

@@ -0,0 +1,96 @@
+/*
+ * R1 lane L, gate E11 step 3: the screen's regions as small Ink views, split out of `app.ts` behind `budget()`.
+ *
+ * Every region is a box of EXACTLY the height `budget()` gave it, `flexShrink:0`, overflow hidden (E1/E2). The frame
+ * is therefore the sum of its regions whatever their content does: a region whose content is taller is clipped inside
+ * its own rows instead of pushing the composer off the screen or overwriting the footer (review D-02/D-03). Single
+ * lines of chrome are pre-truncated to the width with the width function Ink uses and rendered with
+ * `wrap:'truncate-end'`, so a line can never become two rows (E4).
+ */
+import { t } from "../../i18n/index.js";
+import { composerLayout } from "../components/composer.js";
+import { composerDisplay } from "../components/composer.js";
+import { truncateDisplay } from "../text-width.js";
+import { TOO_SMALL_TEXT } from "./budget.js";
+export function createRegionViews(React, Ink) {
+    const h = React.createElement;
+    /* A region: fixed height, never shrinks, never overflows. `bottom` anchors the content to the last row (transcript). */
+    function Region({ rows, bottom = false, children, ...rest }) {
+        if (rows <= 0)
+            return null;
+        /* The inner box keeps the content at its natural height: a bordered panel squeezed by Yoga would draw its text
+           over its own border (the D-02 trace); taller content is clipped by the region instead. */
+        return h(Ink.Box, { flexDirection: 'column', height: rows, flexShrink: 0, overflowY: 'hidden', ...(bottom ? { justifyContent: 'flex-end' } : {}), ...rest }, h(Ink.Box, { flexDirection: 'column', flexShrink: 0 }, children));
+    }
+    /* One row of chrome, whatever the text. */
+    function Line({ text, columns, ...style }) {
+        return h(Ink.Text, { wrap: 'truncate-end', ...style }, truncateDisplay(String(text ?? ''), Math.max(1, columns)) || ' ');
+    }
+    /* Q-R1-8: below 40×12 the frame is the notice and nothing else: one line whenever it fits. Narrower than the notice
+       itself (31 columns) it wraps at a word instead of being cut, so "need 40×12" — the one thing the line is for — is
+       never lost; a person can still read it at 20 columns. */
+    function TooSmall({ columns }) {
+        return h(Ink.Box, { flexDirection: 'column', width: Math.max(1, columns) }, h(Ink.Text, { wrap: 'wrap' }, TOO_SMALL_TEXT));
+    }
+    /*
+     * The transcript region (E9, Q-R1-2/9): the dim announcement row (latest prompt above the view, messages above it),
+     * then the items, bottom-anchored. `clipBelow` shifts the items down by the rows scrolled up inside the last one;
+     * the rows that fall below the region are clipped by the region itself.
+     */
+    function TranscriptRegion({ rows, announcement, clipBelow, color, children }) {
+        if (rows <= 0)
+            return null;
+        const itemRows = announcement ? rows - 1 : rows;
+        return h(Region, { rows }, announcement ? h(Line, { key: 'announce', text: announcement, columns: Number.MAX_SAFE_INTEGER, dimColor: true, color }) : null, itemRows > 0 ? h(Region, { key: 'items', rows: itemRows, bottom: true }, h(Ink.Box, { flexDirection: 'column', flexShrink: 0, marginBottom: -Math.max(0, clipBelow) }, children)) : null);
+    }
+    /*
+     * The composer (E3): a bordered box whose text rows are laid out by `composerLayout` (exact row count, scrolled to
+     * the cursor) and capped at `contentRows`. It subscribes to the composer store itself, so a keystroke re-renders the
+     * composer and not the whole app (the fast input path of B1); the app re-renders only when the ROW COUNT changes.
+     */
+    const ComposerRegion = React.memo(function ComposerRegion({ store, vimHint, contentRows, hintRows, columns }) {
+        const editor = React.useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
+        const contentWidth = composerContentWidth(columns);
+        const layout = composerLayout(composerDisplay(editor), { contentWidth, maxRows: contentRows });
+        const hints = [vimHint, editor.text.includes('\n') ? t('screen.composer.multilineHint') : ''].filter(Boolean).slice(0, hintRows);
+        return h(Ink.Box, { borderStyle: 'single', flexDirection: 'column', flexShrink: 0, height: 2 + contentRows + hints.length, overflowY: 'hidden' }, ...layout.rows.map((row, index) => {
+            /* The marker `>` leads the first visible row; an arrow beside it says the text continues above or below. */
+            const marker = index === 0 ? (layout.hiddenAbove ? '>↑' : '> ') : index === layout.rows.length - 1 && layout.hiddenBelow ? ' ↓' : '  ';
+            return h(Ink.Text, { key: `composer-row-${layout.start + index}`, wrap: 'truncate-end' }, marker, ...row.map((piece, pieceIndex) => h(Ink.Text, { key: pieceIndex, inverse: piece.kind === 'cursor' || piece.selected, dimColor: piece.kind === 'paste' }, piece.text)));
+        }), ...hints.map((hint, index) => h(Ink.Text, { key: `composer-hint-${index}`, dimColor: true, wrap: 'truncate-end' }, truncateDisplay(hint, Math.max(1, columns - 2)))));
+    }, (previous, next) => previous.store === next.store && previous.vimHint === next.vimHint && previous.contentRows === next.contentRows && previous.hintRows === next.hintRows && previous.columns === next.columns);
+    /* The header row (dropped third when rows run out, E13). */
+    function Header({ rows, text, color }) {
+        return h(Region, { rows }, h(Ink.Text, { bold: true, color, wrap: 'truncate-end' }, text));
+    }
+    /* The overlay host wiring (Q-R1-3): diff, overlay, completions and command menu, each in the rows the budget gave it,
+       in the order they stack above the status row. An overlay taller than its rows is clipped by its region, never drawn
+       over the composer; lane O fits every overlay to `maxRows` so that clip does not happen in practice. */
+    function Panels({ budget, diff, overlay, aux, menu }) {
+        return h(React.Fragment, null, h(Region, { key: 'diff', rows: budget.diff }, diff), h(Region, { key: 'overlay', rows: budget.overlay }, overlay), h(Region, { key: 'aux', rows: budget.aux }, ...aux), h(Region, { key: 'menu', rows: budget.menu }, menu));
+    }
+    /* The rows under the composer, each one row and only if the budget kept it: dropped roster first, then the shortcut
+       strip; the footer stays longest (E13). */
+    function StatusBar({ budget, shortcutLine, rosterLines, queueLine, reasoningLine, footerLine, color, statusSegments, toneColors }) {
+        const line = (key, text) => h(Ink.Text, { key, dimColor: true, color, wrap: 'truncate-end' }, text || ' ');
+        return h(React.Fragment, null, budget.shortcut ? line('shortcut', shortcutLine) : null, ...(budget.roster ? rosterLines.slice(0, budget.roster) : []), budget.extras && queueLine ? line('queue', queueLine) : null, budget.extras && reasoningLine ? line('reasoning', reasoningLine) : null, budget.footer ? (statusSegments?.length ? h(StatusRow, { key: 'footer', segments: statusSegments, color, toneColors }) : line('footer', footerLine)) : null);
+    }
+    /* R5a S1 (Q-R5-2): the status row, one Text; the context percentage takes Hermes's colours at 50 / 80 / 95 (bold at 95)
+       and every other segment stays dim like the chrome. The segments already fit the width (status-bar.ts). */
+    function StatusRow({ segments, color, toneColors }) {
+        return h(Ink.Text, { wrap: 'truncate-end' }, ...segments.flatMap((segment, index) => {
+            const toned = segment.tone !== 'normal';
+            const piece = h(Ink.Text, { key: segment.id, dimColor: !toned, color: toned ? (toneColors?.[segment.tone] ?? color) : color, bold: segment.tone === 'critical' }, segment.text);
+            return index ? [h(Ink.Text, { key: `sep-${segment.id}`, dimColor: true, color }, ' · '), piece] : [piece];
+        }));
+    }
+    return { Region, Line, TooSmall, TranscriptRegion, ComposerRegion, Header, Panels, StatusBar };
+}
+/* Text columns inside the composer: the two border cells and the two-cell marker (`> `) are not text. */
+export function composerContentWidth(columns) { return Math.max(1, Math.floor(columns) - 4); }
+/* What the budget needs from the composer: its text rows at this width and its hint rows. The app subscribes to this
+   PRIMITIVE through the store, so it re-renders when the composer grows or shrinks by a row, not on every key. */
+export function composerMeasure(editor, columns, vimHint) {
+    const rows = composerLayout(composerDisplay(editor), { contentWidth: composerContentWidth(columns), maxRows: Number.MAX_SAFE_INTEGER }).total;
+    return { lines: rows, hints: (vimHint ? 1 : 0) + (editor.text.includes('\n') ? 1 : 0) };
+}

package/dist/tui/render-coordinator.js

@@ -0,0 +1,148 @@
+import { createTuiMetricsProfiler } from "./metrics.js";
+import { COALESCE_WINDOW_MS, MOTION_FRAME_MS } from "./render-scheduler.js";
+function defaultTimers() {
+    return {
+        clock: () => performance.now(),
+        setTimer: (fn, delayMs) => setTimeout(fn, delayMs),
+        clearTimer: handle => clearTimeout(handle),
+    };
+}
+export function createRenderCoordinator(options = {}) {
+    const defaults = defaultTimers();
+    const clock = options.clock ?? defaults.clock;
+    const setTimer = options.setTimer ?? defaults.setTimer;
+    const clearTimer = options.clearTimer ?? defaults.clearTimer;
+    const windowMs = Math.max(1, Math.min(COALESCE_WINDOW_MS, options.windowMs ?? COALESCE_WINDOW_MS));
+    const motionPeriodMs = Math.max(1, options.motionPeriodMs ?? MOTION_FRAME_MS);
+    const profiler = options.profiler ?? createTuiMetricsProfiler({ clock });
+    const listeners = new Set();
+    const awaitingVisible = new Map();
+    const pending = [];
+    let pendingSince = null;
+    let flushTimer = null;
+    let epoch = 0;
+    const motionTimers = new Set();
+    let disposed = false;
+    function cancelFlushTimer() {
+        if (flushTimer !== null) {
+            clearTimer(flushTimer);
+            flushTimer = null;
+        }
+    }
+    function scheduleFlush() {
+        if (disposed || flushTimer !== null)
+            return;
+        flushTimer = setTimer(() => { flushTimer = null; flushPending(); }, windowMs);
+    }
+    function flushPending(override) {
+        if (disposed)
+            throw new Error('RENDER_COORDINATOR_DISPOSED');
+        cancelFlushTimer();
+        const started = pendingSince ?? clock();
+        const rows = pending.splice(0, pending.length);
+        pendingSince = null;
+        for (const row of rows)
+            row.apply();
+        epoch += 1;
+        const batch = {
+            epoch,
+            reason: override ?? strongestReasonFrom(rows),
+            eventIds: rows.flatMap(row => row.eventId ? [row.eventId] : []),
+            coalescedMs: Math.max(0, clock() - started),
+        };
+        profiler.renderCoalesced(batch.coalescedMs);
+        awaitingVisible.set(epoch, batch);
+        for (const listener of listeners)
+            listener(batch);
+        return batch;
+    }
+    function strongestReasonFrom(rows) {
+        if (rows.some(row => row.reason === 'event'))
+            return 'event';
+        if (rows.some(row => row.reason === 'resize'))
+            return 'resize';
+        return 'motion';
+    }
+    function queue(row) {
+        if (disposed)
+            throw new Error('RENDER_COORDINATOR_DISPOSED');
+        if (pending.length === 0)
+            pendingSince = clock();
+        pending.push(row);
+        scheduleFlush();
+    }
+    const enqueueMotion = (apply) => queue({ reason: 'motion', apply });
+    return {
+        subscribe(listener) { listeners.add(listener); return () => listeners.delete(listener); },
+        enqueueEvent(eventId, apply) { profiler.eventReceived(eventId); queue({ reason: 'event', apply, eventId }); },
+        enqueueMotion,
+        immediate(reason, apply) {
+            if (disposed)
+                throw new Error('RENDER_COORDINATOR_DISPOSED');
+            if (pending.length === 0)
+                pendingSince = clock();
+            pending.push({ reason: reason === 'resize' ? 'resize' : 'event', apply });
+            return flushPending(reason);
+        },
+        startMotion(apply) {
+            if (disposed)
+                throw new Error('RENDER_COORDINATOR_DISPOSED');
+            let active = true;
+            let handle = null;
+            const owner = {};
+            const tick = () => {
+                if (!active || disposed)
+                    return;
+                motionTimers.delete(handle);
+                handle = null;
+                queue({ reason: 'motion', apply, motion: owner });
+                handle = setTimer(tick, motionPeriodMs);
+                motionTimers.add(handle);
+            };
+            handle = setTimer(tick, motionPeriodMs);
+            motionTimers.add(handle);
+            return () => {
+                active = false;
+                if (handle !== null) {
+                    clearTimer(handle);
+                    motionTimers.delete(handle);
+                    handle = null;
+                }
+                /* E5: a spinner frame queued just before the stop would commit after the session went idle, and on Ink 7.1.1 +
+                   win32 every commit of a full-height frame is a full clear and repaint. Drop it; queued events still flush. */
+                for (let i = pending.length - 1; i >= 0; i--)
+                    if (pending[i].motion === owner)
+                        pending.splice(i, 1);
+                if (pending.length === 0) {
+                    cancelFlushTimer();
+                    pendingSince = null;
+                }
+            };
+        },
+        markVisible(visibleEpoch) {
+            const visible = [...awaitingVisible.entries()]
+                .filter(([candidate]) => candidate <= visibleEpoch)
+                .sort((a, b) => a[0] - b[0]);
+            if (visible.length === 0)
+                return;
+            for (const [candidate] of visible)
+                awaitingVisible.delete(candidate);
+            const batches = visible.map(([, batch]) => batch);
+            const latest = batches.at(-1);
+            profiler.renderCommitted({ eventIds: batches.flatMap(batch => batch.eventIds), reason: latest.reason });
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            cancelFlushTimer();
+            for (const timer of motionTimers)
+                clearTimer(timer);
+            motionTimers.clear();
+            pending.length = 0;
+            pendingSince = null;
+            listeners.clear();
+            awaitingVisible.clear();
+        },
+    };
+}

package/dist/tui/render-scheduler.js

@@ -0,0 +1,4 @@
+export const COALESCE_WINDOW_MS = 16;
+export const MOTION_FRAME_MS = 120;
+export function frameIndex(elapsedMs, periodMs, frameCount) { return frameCount <= 1 ? 0 : Math.floor(Math.max(0, elapsedMs) / Math.max(1, periodMs)) % frameCount; }
+export function stableElapsedLabel(elapsedMs) { return elapsedMs < 1000 ? '     ' : `${(elapsedMs / 1000).toFixed(1).padStart(4, ' ')}s`; }

package/dist/tui/run.js

@@ -0,0 +1,69 @@
+import { createTuiMetricsCollector, createTuiMetricsProfiler, createTuiRenderMetricsTap, summarizeTuiMetrics } from "./metrics.js";
+import { createRenderCoordinator } from "./render-coordinator.js";
+import { detectTerminalCapabilities } from "./terminal-capabilities.js";
+import { createTerminalSessionPlan } from "./terminal-session.js";
+import { DEFAULT_THEME_ACCENT } from "./theme-catalog.js";
+import { createThemeStore } from "./theme-store.js";
+import { createTerminalSizeStore, terminalFrameProps } from "./components/terminal-shell.js";
+import { developmentLogError } from "../diagnostics/development-log.js";
+import { formatExitOutput } from "./exit-output.js";
+async function loadTuiModules() { return { React: await import('react'), Ink: await import('ink'), createTuiAppComponent: (await import("./app.js")).createTuiAppComponent }; }
+export async function runInkTui({ exitOutput = 'transcript', ...props }, io = {}) {
+    let React, Ink, createTuiAppComponent;
+    try {
+        ({ React, Ink, createTuiAppComponent } = await (io.load ?? loadTuiModules)());
+    }
+    catch {
+        throw new Error('TUI_DEPENDENCY_UNAVAILABLE');
+    }
+    const stdout = io.stdout ?? process.stdout, env = io.env ?? process.env;
+    const capabilities = detectTerminalCapabilities({ stdinIsTTY: Boolean((io.stdin ?? process.stdin).isTTY), stdoutIsTTY: Boolean(stdout.isTTY), color: props.invocation.color !== false, env });
+    /* R5b D4 (Q-R5-14): the theme is live — one store, read here for the painted background and by the app for its colours,
+       so /theme can preview and change it without a restart. mono still means no colour and no motion (theme-store.ts).
+       The session is planned on the terminal's own capabilities, so leaving mono for a colour theme paints the background. */
+    const themeStore = createThemeStore(capabilities, props.uiTheme ?? DEFAULT_THEME_ACCENT);
+    const effectiveCapabilities = themeStore.getSnapshot().capabilities;
+    const session = createTerminalSessionPlan({ capabilities, env });
+    const collector = createTuiMetricsCollector();
+    const coordinator = createRenderCoordinator({ profiler: createTuiMetricsProfiler({ sink: collector.sink }) });
+    const TuiApp = createTuiAppComponent(React, Ink, capabilities, undefined, themeStore);
+    const terminalSize = createTerminalSizeStore(stdout, { rows: 30, columns: 100 }, error => developmentLogError('tui.resize.failure', error, {}, 'tui-run'));
+    /* R1 lane contract: the app reports its last transcript once, as it exits (TuiAppProps.onExit, lane L). */
+    let exitSnapshot = null;
+    const onExit = (snapshot) => { exitSnapshot = snapshot; };
+    const Root = () => {
+        const size = React.useSyncExternalStore(terminalSize.subscribe, terminalSize.getSnapshot, terminalSize.getSnapshot);
+        const background = React.useSyncExternalStore(themeStore.subscribe, themeStore.getSnapshot, themeStore.getSnapshot).theme.colors.background;
+        const frameProps = terminalFrameProps({ session, ...(background ? { background } : {}), rows: size.rows, columns: size.columns });
+        return React.createElement(Ink.Box, frameProps, React.createElement(TuiApp, { ...props, renderCoordinator: coordinator, terminalSize: size, onExit }));
+    };
+    /* E6 (lane I): with TALOS_TUI_RENDER_METRICS=1 count bytes, DEC 2026 frames, clears and Ink renders in-process. */
+    const metricsTap = env.TALOS_TUI_RENDER_METRICS === '1' ? createTuiRenderMetricsTap({ stdout, sink: collector.sink }) : null;
+    const rendered = Ink.render(React.createElement(Root), {
+        ...(metricsTap ? metricsTap.inkOptions : {}),
+        stdout,
+        exitOnCtrlC: false,
+        interactive: session.mode === 'plain' ? false : effectiveCapabilities.interactive,
+        alternateScreen: session.alternateScreen,
+    });
+    try {
+        await rendered.waitUntilExit();
+        metricsTap?.dispose(); /* the exit output below is not TUI rendering */
+        /* E10 / Q-R1-4: Ink resolves waitUntilExit only after it has written exitAlternativeScreen (ink.js 7.1.1:548-552,
+           572-583), so this lands on the primary screen and survives in scrollback. Plain mode never had an alternate
+           screen and already left everything append-only (E14). */
+        if (session.alternateScreen) {
+            const text = formatExitOutput(exitSnapshot, { mode: exitOutput, color: themeStore.getSnapshot().capabilities.color });
+            if (text)
+                stdout.write(text);
+        }
+    }
+    finally {
+        terminalSize.dispose();
+        coordinator.dispose();
+        metricsTap?.dispose();
+        if (env.TALOS_TUI_RENDER_METRICS === '1') {
+            process.stderr.write(`${JSON.stringify({ schema: 'talos.cli.tui-render-metrics.v1', ...summarizeTuiMetrics(collector.snapshot()) })}\n`);
+        }
+    }
+}

package/dist/tui/selection-list.js

@@ -0,0 +1,29 @@
+function score(text, query) {
+    const t = text.toLowerCase(), q = query.toLowerCase();
+    if (!q)
+        return 0;
+    if (t.startsWith(q))
+        return 3000 - q.length;
+    if (t.includes(q))
+        return 2000 - t.indexOf(q);
+    let at = 0, gaps = 0;
+    for (const ch of q) {
+        const next = t.indexOf(ch, at);
+        if (next < 0)
+            return -1;
+        gaps += next - at;
+        at = next + 1;
+    }
+    return 1000 - gaps;
+}
+export function filterItems(items, query) {
+    return items.map(item => ({ item, score: score(item.searchText, query) })).filter(x => x.score >= 0)
+        .sort((a, b) => b.score - a.score || (a.item.group ?? '').localeCompare(b.item.group ?? '') || a.item.label.localeCompare(b.item.label) || a.item.id.localeCompare(b.item.id))
+        .map(x => x.item);
+}
+export function moveSelection(state, count, action) {
+    const max = Math.max(0, count - 1);
+    const delta = action === 'up' ? -1 : action === 'down' ? 1 : action === 'page-up' ? -state.pageSize : action === 'page-down' ? state.pageSize : 0;
+    const selected = action === 'home' ? 0 : action === 'end' ? max : Math.max(0, Math.min(max, state.selected + delta));
+    return { ...state, selected };
+}