talos-code 0.0.1 → 0.1.0

package/dist/tui/components/composer.js

@@ -0,0 +1,219 @@
+import { displayWidth, splitGraphemes } from "../text-width.js";
+import { composerSegments, copySelection, deleteBackward, deleteForward, draftText, editorFromDraft, insertPaste, killToEnd, killToStart, killWordBackward, moveCursor, moveVertical, moveWord, redoEditor, undoEditor, yank } from "../editor.js";
+export function createComposerStore(initial) {
+    let snapshot = initial;
+    const listeners = new Set();
+    const publish = (next) => {
+        if (next === snapshot)
+            return snapshot;
+        snapshot = next;
+        for (const listener of [...listeners])
+            listener();
+        return snapshot;
+    };
+    return {
+        getSnapshot: () => snapshot,
+        subscribe(listener) { listeners.add(listener); return () => listeners.delete(listener); },
+        update(fn) { return publish(fn(snapshot)); },
+        replace(next) { return publish(next); },
+    };
+}
+export function composerFastTextInput(input) {
+    if (input.bootPhase !== 'ready' || input.focus !== 'composer' || input.modalOwner || input.auxCount !== 0)
+        return null;
+    if (input.vimMode !== 'disabled' && input.vimMode !== 'insert')
+        return null;
+    if (input.key.ctrl || input.key.meta)
+        return null;
+    if (input.routed?.kind !== 'text' || typeof input.routed.text !== 'string' || input.routed.text.length !== 1)
+        return null;
+    const code = input.routed.text.charCodeAt(0);
+    return code < 32 || code === 127 ? null : input.routed.text;
+}
+export function composerOwnsPaste(input) {
+    if (input.bootPhase !== 'ready' || input.focus !== 'composer' || input.modalOwner || input.auxCount !== 0)
+        return false;
+    return input.vimMode === 'disabled' || input.vimMode === 'insert';
+}
+export function composerFastPasteInput(input) {
+    if (!composerOwnsPaste(input))
+        return null;
+    if (input.key.ctrl || input.key.meta)
+        return null;
+    if (input.routed?.kind !== 'text' || typeof input.routed.text !== 'string' || input.routed.text.length <= 1)
+        return null;
+    return input.routed.text;
+}
+export function applyComposerFastPasteInput(editor, text) {
+    return insertPaste(editor, text);
+}
+export function composerFastEditorAction(input) {
+    if (input.bootPhase !== 'ready' || input.focus !== 'composer' || input.modalOwner || input.auxCount !== 0)
+        return null;
+    if (input.vimMode !== 'disabled' && input.vimMode !== 'insert')
+        return null;
+    if (input.routed?.kind !== 'action' || typeof input.routed.action !== 'string')
+        return null;
+    const action = input.routed.action;
+    const allowed = ['backspace', 'delete-forward', 'left', 'right', 'home', 'end', 'word-left', 'word-right', 'select-left', 'select-right', 'select-home', 'select-end', 'select-up', 'select-down', 'select-word-left', 'select-word-right', 'kill-start', 'kill-end', 'kill-word', 'yank', 'undo', 'redo', 'copy-selection'];
+    if (!allowed.includes(action))
+        return null;
+    if (action === 'delete-forward' && input.editor.text.length === 0)
+        return null;
+    return action;
+}
+export function applyComposerFastEditorAction(editor, action) {
+    if (action === 'backspace')
+        return deleteBackward(editor);
+    if (action === 'delete-forward')
+        return deleteForward(editor);
+    if (action === 'left' || action === 'right' || action === 'home' || action === 'end')
+        return moveCursor(editor, action);
+    if (action === 'word-left')
+        return moveWord(editor, -1);
+    if (action === 'word-right')
+        return moveWord(editor, 1);
+    if (action === 'select-left')
+        return moveCursor(editor, 'left', true);
+    if (action === 'select-right')
+        return moveCursor(editor, 'right', true);
+    if (action === 'select-home')
+        return moveCursor(editor, 'home', true);
+    if (action === 'select-end')
+        return moveCursor(editor, 'end', true);
+    if (action === 'select-up')
+        return moveVertical(editor, -1, true);
+    if (action === 'select-down')
+        return moveVertical(editor, 1, true);
+    if (action === 'select-word-left')
+        return moveWord(editor, -1, true);
+    if (action === 'select-word-right')
+        return moveWord(editor, 1, true);
+    if (action === 'kill-start')
+        return killToStart(editor);
+    if (action === 'kill-end')
+        return killToEnd(editor);
+    if (action === 'kill-word')
+        return killWordBackward(editor);
+    if (action === 'yank')
+        return yank(editor);
+    if (action === 'undo')
+        return undoEditor(editor);
+    if (action === 'redo')
+        return redoEditor(editor);
+    if (action === 'copy-selection')
+        return copySelection(editor);
+    return editor;
+}
+export function planComposerHistoryAction(input) {
+    if (input.bootPhase !== 'ready' || input.focus !== 'composer' || input.modalOwner || input.auxCount !== 0)
+        return null;
+    if (input.vimMode !== 'disabled' && input.vimMode !== 'insert')
+        return null;
+    if (input.routed?.kind !== 'action' || typeof input.routed.action !== 'string')
+        return null;
+    const action = input.routed.action;
+    if (action !== 'history-prev' && action !== 'history-next' && action !== 'history-search')
+        return null;
+    if (action === 'history-search') {
+        const found = reverseHistoryMatch(input.history, input.editor.text, input.reverseIndex);
+        if (!found)
+            return { editor: input.editor, historyIndex: input.historyIndex, reverseIndex: 0 };
+        return { editor: editorFromDraft(input.history[found.index] ?? found.value), historyIndex: found.index, reverseIndex: found.index + 1 };
+    }
+    if (!input.key.ctrl) {
+        const moved = moveVertical(input.editor, action === 'history-prev' ? -1 : 1);
+        const hadSelection = input.editor.selectionAnchor !== undefined;
+        if (moved.cursor !== input.editor.cursor || hadSelection) {
+            return { editor: moved, historyIndex: input.historyIndex, reverseIndex: input.reverseIndex };
+        }
+    }
+    if (input.history.length === 0)
+        return { editor: input.editor, historyIndex: input.historyIndex, reverseIndex: input.reverseIndex };
+    const delta = action === 'history-prev' ? 1 : -1;
+    const next = Math.max(-1, Math.min(input.history.length - 1, input.historyIndex + delta));
+    return {
+        editor: editorFromDraft(next >= 0 ? (input.history[next] ?? '') : ''),
+        historyIndex: next,
+        reverseIndex: 0,
+    };
+}
+export function reverseHistoryMatch(history, query, from = 0) { for (let i = Math.max(0, from); i < history.length; i++) {
+    const value = draftText(history[i]);
+    if (value.toLowerCase().includes(query.toLowerCase()))
+        return { index: i, value };
+} return null; }
+export function composerDisplay(state) { return composerSegments(state); }
+export const COMPOSER_PREFIX_COLUMNS = 2;
+/*
+ * R3 owner decision (keep TAB): a tab in the text is drawn as spaces up to the next COMPOSER_TAB_STOP, clipped at the end
+ * of the row, so the width the budget measures is the width Ink draws (string-width gives a raw tab 0 cells, the terminal
+ * up to 8). Display only: the editor keeps the tab, and the cursor on a tab is one cell at its start.
+ */
+export const COMPOSER_TAB_STOP = 4;
+export function composerRows(segments, contentWidth) {
+    const width = Math.max(1, Math.floor(contentWidth));
+    const rows = [[]];
+    let used = 0, cursorRow = 0;
+    const push = (text, kind, selected) => {
+        const row = rows[rows.length - 1];
+        const last = row[row.length - 1];
+        if (last && last.kind === kind && last.selected === selected && kind !== 'cursor')
+            last.text += text;
+        else
+            row.push({ text, kind, selected });
+    };
+    const breakRow = () => { rows.push([]); used = 0; };
+    const tabCells = () => { if (used >= width)
+        breakRow(); return Math.min(COMPOSER_TAB_STOP - (used % COMPOSER_TAB_STOP), width - used); };
+    for (const segment of segments) {
+        const selected = Boolean(segment.selected);
+        if (segment.kind === 'cursor' && segment.text === '\t') {
+            const w = tabCells();
+            cursorRow = rows.length - 1;
+            push(' ', 'cursor', selected);
+            if (w > 1)
+                push(' '.repeat(w - 1), 'text', selected);
+            used += w;
+            continue;
+        }
+        if (segment.kind === 'cursor') {
+            /* The cursor on a line break is drawn as a cell at the end of the row, then the row breaks. */
+            const cell = segment.text === '\n' || segment.text === '' ? ' ' : segment.text;
+            const w = Math.max(1, displayWidth(cell));
+            if (used + w > width && used > 0)
+                breakRow();
+            cursorRow = rows.length - 1;
+            push(cell, 'cursor', selected);
+            used += w;
+            if (segment.text === '\n')
+                breakRow();
+            continue;
+        }
+        for (const g of splitGraphemes(segment.text)) {
+            if (g === '\n' || g === '\r\n') {
+                breakRow();
+                continue;
+            }
+            if (g === '\t') {
+                const w = tabCells();
+                push(' '.repeat(w), segment.kind, selected);
+                used += w;
+                continue;
+            }
+            const w = displayWidth(g);
+            if (used + w > width && used > 0)
+                breakRow();
+            push(g, segment.kind, selected);
+            used += w;
+        }
+    }
+    return { rows, cursorRow };
+}
+export function composerLayout(segments, { contentWidth, maxRows }) {
+    const { rows, cursorRow } = composerRows(segments, contentWidth);
+    const visible = Math.max(1, Math.floor(maxRows));
+    const start = Math.max(0, Math.min(rows.length - visible, cursorRow - visible + 1));
+    const shown = rows.slice(start, start + visible);
+    return { rows: shown, total: rows.length, start, cursorRow, hiddenAbove: start, hiddenBelow: Math.max(0, rows.length - start - shown.length) };
+}

package/dist/tui/components/diff.js

@@ -0,0 +1,35 @@
+import { t } from "../../i18n/index.js";
+import { displayWidth, truncateDisplay } from "../text-width.js";
+/* R3: the sanitiser is imported from its leaf module (tools/shared.ts), not through transcript-model.ts, because the tool
+   rows now render diffs with this file and the transcript model imports the tool rows (no import cycle). */
+import { sanitizeDisplayText as sanitizeTranscriptText } from "../tools/shared.js";
+function safe(value) { return sanitizeTranscriptText(value); }
+function prefix(row) { return row.kind === 'add' ? '+' : row.kind === 'remove' ? '-' : row.kind === 'context' ? ' ' : ' '; }
+function fit(value, width) { const limit = Math.max(1, Math.floor(width)); return displayWidth(value) <= limit ? value : truncateDisplay(value, limit); }
+function wideRow(row, width) {
+    if (row.kind === 'add' || row.kind === 'remove' || row.kind === 'context') {
+        const old = row.oldLine === null ? '' : String(row.oldLine), next = row.newLine === null ? '' : String(row.newLine);
+        const text = old.padStart(5) + ' ' + next.padStart(5) + ' │ ' + prefix(row) + safe(row.text);
+        return { kind: row.kind, text: fit(text, width) };
+    }
+    return { kind: row.kind, text: fit(safe(row.text), width) };
+}
+function narrowRow(row, width) {
+    const text = (row.kind === 'add' || row.kind === 'remove' || row.kind === 'context' ? prefix(row) : '') + safe(row.text);
+    return { kind: row.kind, text: fit(text, width) };
+}
+export function renderDiffModel(model, width) {
+    const limit = Math.max(1, Math.floor(width)), mode = limit >= 72 ? 'unified' : 'narrow';
+    if (model.empty)
+        return { mode, empty: true, lines: [{ kind: 'meta', text: t('screen.diff.noChanges') }] };
+    const lines = [];
+    for (const plain of model.plain)
+        lines.push(mode === 'unified' ? wideRow(plain, limit) : narrowRow(plain, limit));
+    for (const file of model.files) {
+        const label = (file.oldPath || '—') + (file.oldPath !== file.newPath ? ' → ' + (file.newPath || '—') : '');
+        lines.push({ kind: 'file', text: fit(safe(label), limit) });
+        for (const row of file.rows)
+            lines.push(mode === 'unified' ? wideRow(row, limit) : narrowRow(row, limit));
+    }
+    return { mode, empty: false, lines };
+}

package/dist/tui/components/footer.js

@@ -0,0 +1,48 @@
+import { t } from "../../i18n/index.js";
+import { displayWidth, truncateDisplay } from "../text-width.js";
+export function sanitizeStatus(text) {
+    return String(text).replace(/[\r\n\t]+/gu, ' ').replace(/\s{2,}/gu, ' ').trim();
+}
+export function layoutFooter(fields, width) {
+    const limit = Math.max(0, Math.floor(width));
+    if (limit === 0)
+        return '';
+    const kept = [...fields]
+        .filter(field => sanitizeStatus(field.text).length > 0)
+        .sort((a, b) => b.priority - a.priority);
+    const render = () => kept.map(field => sanitizeStatus(field.text)).join(' · ');
+    while (kept.length && displayWidth(render()) > limit) {
+        let lowest = 0;
+        for (let index = 1; index < kept.length; index++)
+            if (kept[index].priority < kept[lowest].priority)
+                lowest = index;
+        kept.splice(lowest, 1);
+    }
+    return truncateDisplay(render(), limit);
+}
+export function contextUsageLabel(usage, _contextWindow) {
+    if (!usage || typeof usage !== 'object')
+        return null;
+    const row = usage;
+    if (row.schema === 'talos.cli.context-status.v1') {
+        const measured = row.measurement && typeof row.measurement === 'object' ? row.measurement : null;
+        const input = finiteNumber(measured?.inputTokens), window = finiteNumber(measured?.windowTokens), percent = finiteNumber(measured?.percentOfWindow);
+        if (input === null || window === null || window <= 0 || percent === null)
+            return null;
+        return t(measured?.stale === true ? 'screen.footer.contextStale' : 'screen.footer.context', { input: compactCount(input), window: compactCount(window), percent });
+    }
+    const prompt = finiteNumber(row.prompt_tokens ?? row.promptTokens ?? row.input_tokens ?? row.inputTokens);
+    const completion = finiteNumber(row.completion_tokens ?? row.completionTokens ?? row.output_tokens ?? row.outputTokens);
+    if (prompt === null && completion === null)
+        return null;
+    return t('screen.footer.usage', { total: compactCount((prompt ?? 0) + (completion ?? 0)) });
+}
+function finiteNumber(value) { return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : null; }
+function compactCount(value) {
+    if (value < 1000)
+        return String(Math.round(value));
+    if (value < 1_000_000)
+        return `${trimDecimal(value / 1000)}k`;
+    return `${trimDecimal(value / 1_000_000)}m`;
+}
+function trimDecimal(value) { return value.toFixed(1).replace(/\.0$/u, ''); }

package/dist/tui/components/header.js

@@ -0,0 +1,6 @@
+import { sanitizeStatus } from "./footer.js";
+export function headerLine({ workspace, status }) {
+    const place = sanitizeStatus(workspace);
+    const state = sanitizeStatus(status);
+    return ['TALOS', place, state].filter(Boolean).join(' · ');
+}

package/dist/tui/components/markdown.js

@@ -0,0 +1,305 @@
+import { t } from "../../i18n/index.js";
+import { highlightCodeLine } from "../highlight.js";
+import { displayWidth } from "../text-width.js";
+import { sanitizeTranscriptText } from "../transcript-model.js";
+export function markdownRenderPropsEqual(previous, next) { return previous.text === next.text && previous.width === next.width; }
+export function createMarkdownParseMemo({ parser = parseMarkdownBlocks } = {}) {
+    let cachedText = null, cachedBlocks = null;
+    return {
+        get(text) { const value = String(text); if (cachedBlocks !== null && cachedText === value)
+            return cachedBlocks; const blocks = parser(value); cachedText = value; cachedBlocks = blocks; return blocks; },
+        invalidate() { cachedText = null; cachedBlocks = null; },
+    };
+}
+export function markdownSafeText(text) { return sanitizeTranscriptText(String(text)); }
+function safeLinkDestination(value) {
+    const destination = markdownSafeText(value).trim();
+    if (!destination || /[\s\x00-\x1f\x7f]/u.test(destination))
+        return null;
+    if (destination.startsWith('#') || destination.startsWith('./') || destination.startsWith('../') || destination.startsWith('/'))
+        return destination;
+    const scheme = /^([A-Za-z][A-Za-z0-9+.-]*):/u.exec(destination)?.[1]?.toLowerCase() ?? null;
+    if (!scheme)
+        return destination;
+    return scheme === 'http' || scheme === 'https' || scheme === 'mailto' ? destination : null;
+}
+function mergeInlineText(tokens) { const out = []; for (const token of tokens) {
+    const previous = out.at(-1);
+    if (token.kind === 'text' && previous?.kind === 'text')
+        previous.text += token.text;
+    else
+        out.push(token);
+} return out; }
+export function parseMarkdownInline(text) {
+    const safe = markdownSafeText(text), tokens = [];
+    let plain = '';
+    const flush = () => { if (plain) {
+        tokens.push({ kind: 'text', text: plain });
+        plain = '';
+    } };
+    for (let index = 0; index < safe.length;) {
+        const rest = safe.slice(index);
+        if (rest.startsWith('**')) {
+            const end = safe.indexOf('**', index + 2);
+            if (end < 0) {
+                plain += rest;
+                break;
+            }
+            flush();
+            tokens.push({ kind: 'strong', text: safe.slice(index + 2, end) });
+            index = end + 2;
+            continue;
+        }
+        if (rest.startsWith('~~')) {
+            const end = safe.indexOf('~~', index + 2);
+            if (end < 0) {
+                plain += rest;
+                break;
+            }
+            flush();
+            tokens.push({ kind: 'strike', text: safe.slice(index + 2, end) });
+            index = end + 2;
+            continue;
+        }
+        if (rest.startsWith('`')) {
+            const end = safe.indexOf('`', index + 1);
+            if (end < 0) {
+                plain += rest;
+                break;
+            }
+            flush();
+            tokens.push({ kind: 'code', text: safe.slice(index + 1, end) });
+            index = end + 1;
+            continue;
+        }
+        if (rest.startsWith('*')) {
+            const end = safe.indexOf('*', index + 1);
+            if (end < 0) {
+                plain += rest;
+                break;
+            }
+            flush();
+            tokens.push({ kind: 'emphasis', text: safe.slice(index + 1, end) });
+            index = end + 1;
+            continue;
+        }
+        if (rest.startsWith('[')) {
+            const close = safe.indexOf('](', index + 1);
+            if (close >= 0) {
+                const end = safe.indexOf(')', close + 2);
+                if (end >= 0) {
+                    const label = safe.slice(index + 1, close), target = safeLinkDestination(safe.slice(close + 2, end));
+                    if (target) {
+                        flush();
+                        tokens.push({ kind: 'link', text: label, href: target });
+                        index = end + 1;
+                        continue;
+                    }
+                }
+            }
+        }
+        plain += safe[index] ?? '';
+        index++;
+    }
+    flush();
+    return mergeInlineText(tokens);
+}
+export function markdownInlineText(text) { return parseMarkdownInline(text).map(token => token.kind === 'link' ? `${token.text} (${token.href})` : token.text).join(''); }
+function splitTableRow(line) {
+    let value = line.trim();
+    if (value.startsWith('|'))
+        value = value.slice(1);
+    if (value.endsWith('|') && !value.endsWith('\\|'))
+        value = value.slice(0, -1);
+    const cells = [], current = [];
+    let escaped = false;
+    for (const character of value) {
+        if (escaped) {
+            current.push(character);
+            escaped = false;
+            continue;
+        }
+        if (character === '\\') {
+            escaped = true;
+            current.push(character);
+            continue;
+        }
+        if (character === '|') {
+            cells.push(current.join('').trim().replace(/\\\|/gu, '|'));
+            current.length = 0;
+            continue;
+        }
+        current.push(character);
+    }
+    if (escaped)
+        current.push('\\');
+    cells.push(current.join('').trim().replace(/\\\|/gu, '|'));
+    return cells;
+}
+function delimiterRow(line) {
+    const cells = splitTableRow(line);
+    if (!cells.length)
+        return null;
+    const align = [];
+    for (const cell of cells) {
+        if (!/^:?-{3,}:?$/u.test(cell))
+            return null;
+        align.push(cell.startsWith(':') && cell.endsWith(':') ? 'center' : cell.endsWith(':') ? 'right' : 'left');
+    }
+    return align;
+}
+function listRow(line) {
+    const unordered = /^(\s*)[-+*]\s+(.+)$/u.exec(line);
+    if (unordered)
+        return { ordered: false, start: 1, text: unordered[2] ?? '', depth: Math.floor((unordered[1]?.replace(/\t/gu, '  ').length ?? 0) / 2) };
+    const ordered = /^(\s*)(\d{1,9})[.)]\s+(.+)$/u.exec(line);
+    if (ordered)
+        return { ordered: true, start: Number(ordered[2]), text: ordered[3] ?? '', depth: Math.floor((ordered[1]?.replace(/\t/gu, '  ').length ?? 0) / 2) };
+    return null;
+}
+export function parseMarkdownBlocks(text) {
+    const lines = String(text).split(/\r?\n/u), out = [];
+    let paragraph = [];
+    let code = null;
+    let language = '';
+    const flushParagraph = () => { if (paragraph.length) {
+        out.push({ kind: 'paragraph', text: paragraph.join('\n') });
+        paragraph = [];
+    } };
+    const flushCode = () => { if (code) {
+        out.push({ kind: 'code', language, text: code.join('\n'), tokens: code.map(line => highlightCodeLine(line, language)) });
+        code = null;
+        language = '';
+    } };
+    for (let index = 0; index < lines.length;) {
+        const line = lines[index] ?? '';
+        const fence = /^```\s*([^\s`]*)/u.exec(line);
+        if (fence) {
+            if (code) {
+                flushCode();
+                index++;
+                continue;
+            }
+            flushParagraph();
+            code = [];
+            language = fence[1] ?? '';
+            index++;
+            continue;
+        }
+        if (code) {
+            code.push(line);
+            index++;
+            continue;
+        }
+        const heading = /^(#{1,6})\s+(.*)$/u.exec(line);
+        if (heading) {
+            flushParagraph();
+            out.push({ kind: 'heading', level: heading[1].length, text: heading[2] ?? '' });
+            index++;
+            continue;
+        }
+        if (line === '') {
+            flushParagraph();
+            index++;
+            continue;
+        }
+        if (/^\s*>/u.test(line)) {
+            flushParagraph();
+            const quoted = [];
+            while (index < lines.length) {
+                const match = /^\s*>\s?(.*)$/u.exec(lines[index] ?? '');
+                if (!match)
+                    break;
+                quoted.push(match[1] ?? '');
+                index++;
+            }
+            out.push({ kind: 'blockquote', text: quoted.join('\n') });
+            continue;
+        }
+        const list = listRow(line);
+        if (list) {
+            flushParagraph();
+            const items = [list.text], depths = [list.depth], start = list.start;
+            index++;
+            while (index < lines.length) {
+                const next = listRow(lines[index] ?? '');
+                if (!next || next.ordered !== list.ordered)
+                    break;
+                items.push(next.text);
+                depths.push(next.depth);
+                index++;
+            }
+            out.push({ kind: 'list', ordered: list.ordered, start, items, depths });
+            continue;
+        }
+        const next = lines[index + 1];
+        const align = next === undefined ? null : delimiterRow(next);
+        if (line.includes('|') && align) {
+            const headers = splitTableRow(line);
+            if (headers.length === align.length) {
+                flushParagraph();
+                const rows = [];
+                index += 2;
+                while (index < lines.length && (lines[index] ?? '').trim() !== '' && (lines[index] ?? '').includes('|')) {
+                    const cells = splitTableRow(lines[index] ?? '');
+                    if (cells.length !== headers.length)
+                        break;
+                    rows.push(cells);
+                    index++;
+                }
+                out.push({ kind: 'table', headers, align, rows });
+                continue;
+            }
+        }
+        paragraph.push(line);
+        index++;
+    }
+    if (code)
+        flushCode();
+    flushParagraph();
+    return out;
+}
+function padCell(value, width, align) {
+    const gap = Math.max(0, width - displayWidth(value));
+    if (align === 'right')
+        return ' '.repeat(gap) + value;
+    if (align === 'center') {
+        const left = Math.floor(gap / 2);
+        return ' '.repeat(left) + value + ' '.repeat(gap - left);
+    }
+    return value + ' '.repeat(gap);
+}
+export function markdownBlockLines(block, width) {
+    const limit = Math.max(1, Math.floor(width));
+    if (block.kind === 'heading')
+        return { mode: 'plain', lines: [markdownInlineText(block.text)] };
+    if (block.kind === 'paragraph')
+        return { mode: 'plain', lines: markdownInlineText(block.text).split('\n') };
+    if (block.kind === 'blockquote')
+        return { mode: 'plain', lines: markdownInlineText(block.text).split('\n').map(line => '│ ' + line) };
+    if (block.kind === 'code')
+        return { mode: 'plain', lines: block.text.split('\n').map(markdownSafeText) };
+    if (block.kind === 'list')
+        return { mode: 'plain', lines: block.items.map((item, index) => '  '.repeat(block.depths[index] ?? 0) + (block.ordered ? String(block.start + index) + '. ' : '• ') + markdownInlineText(item)) };
+    const header = block.headers.map(markdownInlineText), rows = block.rows.map(row => row.map(markdownInlineText));
+    const widths = header.map((value, column) => Math.max(3, displayWidth(value), ...rows.map(row => displayWidth(row[column] ?? ''))));
+    const natural = widths.reduce((sum, value) => sum + value, 0) + Math.max(0, widths.length - 1) * 3;
+    if (limit >= Math.max(32, natural)) {
+        const render = (row) => row.map((value, column) => padCell(value ?? '', widths[column] ?? 3, block.align[column] ?? 'left')).join(' | ');
+        /* R3 gate E13 (D-13): the separator is dashes only. The alignment colon is Markdown source syntax; alignment is shown
+           by the cell padding above (`padCell`), the way Codex, Crush, Goose and Qwen draw an aligned table (gate §7). */
+        const separator = widths.map(size => '-'.repeat(size)).join('-+-');
+        return { mode: 'wide', lines: [render(header), separator, ...rows.map(render)] };
+    }
+    const lines = [];
+    rows.forEach((row, rowIndex) => {
+        if (rowIndex > 0)
+            lines.push('');
+        for (let column = 0; column < header.length; column++)
+            lines.push((header[column] || t('screen.markdown.column', { number: column + 1 })) + ': ' + (row[column] ?? ''));
+    });
+    if (rows.length === 0)
+        for (let column = 0; column < header.length; column++)
+            lines.push(header[column] ?? '');
+    return { mode: 'narrow', lines };
+}

package/dist/tui/components/status-indicator.js

@@ -0,0 +1,32 @@
+import { t } from "../../i18n/index.js";
+import { frameIndex, stableElapsedLabel } from "../render-scheduler.js";
+import { retryLine } from "../live-activity.js";
+/* A static glyph for the states that do not spin: nothing moves while TALOS waits for the person or after the turn. */
+const STATIC_GLYPH = {
+    idle: { unicode: ' ', ascii: ' ' }, error: { unicode: '!', ascii: '!' }, waiting: { unicode: '?', ascii: '?' }, retrying: { unicode: '↻', ascii: '~' },
+    done: { unicode: '✓', ascii: '+' }, interrupted: { unicode: '■', ascii: '-' }, failed: { unicode: '✗', ascii: 'x' },
+};
+/** The one word for an activity, shared by the status row and the main roster row (gate E7). */
+export function activityWord(kind, tool) { return kind === 'tool' && tool ? t('screen.busy.toolNamed', { tool }) : t(`screen.busy.${kind}`); }
+const NO_ELAPSED = new Set(['idle', 'error']);
+export function busyIndicatorText({ kind, elapsedMs, frame, unicode, frames, tool, retry, nowMs }) {
+    const spinnerFrames = frames?.length ? frames : (unicode ? ['⠋', '⠙', '⠹', '⠸'] : ['-', '\\', '|', '/']);
+    const fixed = STATIC_GLYPH[kind];
+    const glyph = fixed ? (unicode ? fixed.unicode : fixed.ascii) : spinnerFrames[Math.abs(frame) % spinnerFrames.length];
+    /* R5a S4: the retry line replaces word and clock (the attempt, the status and the countdown say more than elapsed). */
+    if (kind === 'retrying' && retry)
+        return `${glyph} ${retryLine(retry, nowMs ?? Date.now())}`;
+    const verb = activityWord(kind, tool).padEnd(10, ' ');
+    const elapsed = NO_ELAPSED.has(kind) ? '     ' : stableElapsedLabel(elapsedMs);
+    return `${glyph} ${verb} ${elapsed}`;
+}
+export function createStatusIndicatorComponent(React, Ink) {
+    return function StatusIndicator({ kind, startedAt, motion, unicode, frames, color }) {
+        const [now, setNow] = React.useState(() => Date.now());
+        React.useEffect(() => { if (!motion || STATIC_GLYPH[kind])
+            return; const timer = setInterval(() => setNow(Date.now()), 120); return () => clearInterval(timer); }, [kind, motion]);
+        const elapsed = Math.max(0, now - startedAt);
+        const frame = frameIndex(elapsed, 120, 4);
+        return React.createElement(Ink.Text, { color }, busyIndicatorText({ kind, elapsedMs: elapsed, frame, unicode, ...(frames?.length ? { frames } : {}) }));
+    };
+}