talos-code 0.0.1 → 0.2.0

package/dist/tui/components/terminal-shell.js

@@ -0,0 +1,214 @@
+import { en, t } from "../../i18n/index.js";
+import { displayWidth, truncateDisplay } from "../text-width.js";
+import { sanitizeStatus } from "./footer.js";
+function validTerminalDimension(value, fallback) { const measured = Number(value); return Number.isFinite(measured) && measured > 0 ? Math.max(1, Math.floor(measured)) : Math.max(1, Math.floor(fallback)); }
+export function terminalSizeSnapshot(stream, fallback) {
+    return { rows: validTerminalDimension(stream?.rows, fallback.rows), columns: validTerminalDimension(stream?.columns, fallback.columns) };
+}
+export function createTerminalSizeStore(stream, fallback = { rows: 30, columns: 100 }, onError) {
+    let snapshot = terminalSizeSnapshot(stream, fallback), disposed = false;
+    const listeners = new Set();
+    const onResize = () => { if (disposed)
+        return; try {
+        const next = terminalSizeSnapshot(stream, snapshot);
+        if (next.rows === snapshot.rows && next.columns === snapshot.columns)
+            return;
+        snapshot = next;
+        for (const listener of [...listeners])
+            listener(snapshot);
+    }
+    catch (error) {
+        try {
+            onError?.(error);
+        }
+        catch { /* resize diagnostics cannot break rendering */ }
+    } };
+    try {
+        stream?.on?.('resize', onResize);
+    }
+    catch (error) {
+        try {
+            onError?.(error);
+        }
+        catch { /* best effort */ }
+    }
+    return {
+        getSnapshot: () => snapshot,
+        subscribe(listener) { if (disposed)
+            return () => { }; listeners.add(listener); return () => listeners.delete(listener); },
+        dispose() { if (disposed)
+            return; disposed = true; listeners.clear(); try {
+            if (typeof stream?.off === 'function')
+                stream.off('resize', onResize);
+            else
+                stream?.removeListener?.('resize', onResize);
+        }
+        catch (error) {
+            try {
+                onError?.(error);
+            }
+            catch { /* best effort */ }
+        } },
+    };
+}
+const TERMINAL_UNSAFE = /[\x00-\x1f\x7f-\x9f\u2028\u2029\p{Bidi_Control}\p{Default_Ignorable_Code_Point}]/gu;
+export function shellSafeText(value) {
+    return String(value ?? '')
+        .replace(TERMINAL_UNSAFE, character => {
+        if (character === '\n' || character === '\r' || character === '\t')
+            return ' ';
+        const code = character.codePointAt(0);
+        return code > 0xffff ? `\\u{${code.toString(16)}}` : `\\u${code.toString(16).padStart(4, '0')}`;
+    })
+        .replace(/\s{2,}/gu, ' ')
+        .trim();
+}
+function fitStrip(fields, width) {
+    const limit = Math.max(0, Math.floor(width));
+    if (limit === 0)
+        return '';
+    const kept = fields.map(field => ({ ...field, text: shellSafeText(field.text) })).filter(field => field.text);
+    const render = () => kept.map(field => 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);
+}
+/* R4 Q-R4-12: the permission mode as the person reads it (`manual`, `accept edits`, `plan`, `auto`, `don't ask`,
+   `Full access`); the id stays what the runtime and the config use. A mode this table does not know is shown as it came. */
+export function permissionModeLabel(mode) {
+    const id = `screen.mode.${mode}`;
+    return Object.hasOwn(en, id) ? t(id) : shellSafeText(mode);
+}
+/*
+ * R5a S5 (owner decision Q-R5-7; gate E8, finding 8): while a turn runs and the busy-input mode is known, the strip leads
+ * with what Enter does in that mode ("Enter queues · Alt+S steers · Esc interrupts") — one field, never split — then the
+ * mode in its short form, so both fit at 60 columns. Without a mode (callers before R5a) the strip is as it was.
+ */
+export function terminalShortcutStrip({ mode, running, queueCount, width, busyInput }) {
+    if (running && busyInput)
+        return fitStrip([
+            { text: t(`screen.busyLine.${busyInput}`), priority: 100 },
+            { text: t('screen.shortcut.modeShort', { mode: permissionModeLabel(mode) }), priority: 95 },
+            ...(queueCount > 0 ? [{ text: t('screen.shortcut.queue', { count: queueCount }), priority: 90 }] : []),
+            { text: t('screen.shortcut.transcript'), priority: 70 },
+        ], width);
+    return fitStrip([
+        { text: t('screen.shortcut.mode', { mode: permissionModeLabel(mode) }), priority: 100 },
+        ...(running ? [{ text: t('screen.shortcut.interrupt'), priority: 95 }] : []),
+        ...(queueCount > 0 ? [{ text: t('screen.shortcut.queue', { count: queueCount }), priority: 90 }] : []),
+        { text: t('screen.shortcut.transcript'), priority: 70 },
+        { text: t('screen.shortcut.help'), priority: 60 },
+    ], width);
+}
+function busyLabel(kind) {
+    if (kind === 'idle')
+        return t('screen.status.ready');
+    if (kind === 'error')
+        return t('screen.status.error');
+    return t(`screen.busy.${kind}`);
+}
+/* R2: the outcome words of a roster row; an outcome this table does not know is shown as it came (it is an English id). */
+function outcomeLabel(outcome) {
+    const id = `screen.outcome.${outcome}`;
+    return Object.hasOwn(en, id) ? t(id) : outcome;
+}
+/* R5a S9 (review D-14): the model now leads the status row (Q-R5-2), so the main roster row may leave it out (`model` null). */
+export function mainRosterLine({ kind, model, width, marker = '●' }) {
+    const line = model === null ? t('screen.roster.mainStatus', { marker, status: busyLabel(kind) }) : t('screen.roster.main', { marker, status: busyLabel(kind), model });
+    return truncateDisplay(shellSafeText(line), Math.max(0, Math.floor(width)));
+}
+export function queueRosterLine({ count, preview, width, marker = '○' }) {
+    if (count <= 0)
+        return '';
+    const suffix = preview ? ` · ${shellSafeText(preview)}` : '';
+    return truncateDisplay(shellSafeText(t('screen.roster.queue', { marker, count, preview: suffix })), Math.max(0, Math.floor(width)));
+}
+function parsedMs(value) {
+    if (!value)
+        return null;
+    const measured = Date.parse(value);
+    return Number.isFinite(measured) ? measured : null;
+}
+export function agentDurationLabel(row, nowMs) {
+    const start = parsedMs(row.startedAt);
+    if (start === null)
+        return null;
+    const explicitEnd = parsedMs(row.endedAt);
+    const end = explicitEnd ?? (row.outcome === 'running' && Number.isFinite(nowMs) ? nowMs : null);
+    if (end === null || end < start)
+        return null;
+    const seconds = Math.floor((end - start) / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60), rest = seconds % 60;
+    if (minutes < 60)
+        return `${minutes}m ${rest}s`;
+    const hours = Math.floor(minutes / 60), minuteRest = minutes % 60;
+    return `${hours}h ${minuteRest}m`;
+}
+/* R3 Q-R3-7 (gate E7): `status` = the CLI's own activity word for the main row while a turn is open; the kernel list says
+   `unknown` or `running` then (measured, gate §0.3). Without it the kernel's outcome word stays. */
+export function agentRosterLine({ row, width, nowMs, marker, status: activity, hideModel = false }) {
+    const indent = '  '.repeat(Math.max(0, Math.min(8, row.level)));
+    const pointer = marker ?? (row.focused ? '›' : '·');
+    const identity = row.role === 'main' ? t('screen.roster.mainName') : row.name ? t('screen.roster.agentNamed', { name: shellSafeText(row.name) }) : t('screen.roster.agent');
+    const status = activity ?? outcomeLabel(row.interrupted ? 'interrupted' : row.outcome);
+    const duration = agentDurationLabel(row, nowMs);
+    const task = row.task ? ` · ${truncateDisplay(shellSafeText(row.task), 32)}` : '';
+    const elapsed = duration ? ` · ${duration}` : '';
+    const model = row.model && !hideModel ? ` · ${t('screen.roster.model', { model: shellSafeText(row.model) })}` : '';
+    const collision = row.hasCollision ? ` · ${t('screen.roster.collision', { count: row.collisionCount })}` : '';
+    const body = shellSafeText(`${pointer} ${identity} · ${status}${collision}${elapsed}${model}${task}`);
+    return truncateDisplay(`${indent}${body}`, Math.max(0, Math.floor(width)));
+}
+export function edgeRosterLine({ left, right, width }) {
+    const limit = Math.max(0, Math.floor(width));
+    if (limit === 0)
+        return '';
+    const safeLeft = shellSafeText(left);
+    const safeRight = shellSafeText(right ?? '');
+    if (!safeRight)
+        return truncateDisplay(safeLeft, limit);
+    const leftWidth = displayWidth(safeLeft), rightWidth = displayWidth(safeRight);
+    if (leftWidth + 1 + rightWidth > limit)
+        return truncateDisplay(safeLeft, limit);
+    return `${safeLeft}${' '.repeat(Math.max(1, limit - leftWidth - rightWidth))}${safeRight}`;
+}
+export function residualFooterFields(input) {
+    return [
+        ...(input.unseen ? [{ id: 'unseen', text: t('screen.footer.unseen', { count: input.unseen }), priority: 95 }] : []),
+        ...(input.sessionId ? [{ id: 'session', text: t('screen.footer.session', { id: sanitizeStatus(input.sessionId) }), priority: 70 }] : []),
+        { id: 'workspace', text: sanitizeStatus(input.workspace), priority: 50 },
+    ];
+}
+export const WIN32_FRAME_HEIGHT = 'rows-1';
+export function frameRowsFor(rows, platform = process.platform, policy = WIN32_FRAME_HEIGHT) {
+    const measured = Math.max(1, Math.floor(Number(rows) || 1));
+    return platform === 'win32' && policy === 'rows-1' ? Math.max(1, measured - 1) : measured;
+}
+/*
+ * P11 (owner, 2026-09-25, "changing theme crashes the process"): Ink's Box wraps its children in a background Provider
+ * ONLY when it has a colour (ink/build/components/Box.js:27). `mono` has no background, so crossing it in /theme changed
+ * the tree's shape, React remounted the whole app, and its unmount closed the session controller (app.ts, the
+ * `controller.close()` cleanup): the conversation was lost. When the session paints the background the frame therefore
+ * ALWAYS has a background colour; for a theme without one it is a name chalk does not know, which Ink leaves unpainted
+ * (ink/build/colorize.js returns the text unchanged), so mono stays colourless and the shape never changes.
+ */
+export const UNPAINTED_BACKGROUND = 'transparent';
+export function terminalFrameProps({ session, background, rows, columns, platform = process.platform, }) {
+    if (session.mode === 'plain')
+        return { flexDirection: 'column' };
+    const width = Math.max(1, Math.floor(columns));
+    const height = frameRowsFor(rows, platform);
+    return {
+        flexDirection: 'column',
+        width,
+        height,
+        ...(session.paintBackground ? { backgroundColor: background || UNPAINTED_BACKGROUND } : {}),
+    };
+}

package/dist/tui/components/thinking-row.js

@@ -0,0 +1,19 @@
+import { t } from "../../i18n/index.js";
+import { formatDuration } from "../tools/shared.js";
+export function thinkingRowText(text, visible) { return visible && text ? text : null; }
+/*
+ * R5a S8 (owner decision Q-R5-9; gate §4, finding 9): reasoning is collapsed by default, and a collapsed block leaves ONE
+ * dim line, "Thought for 2.8 s · Ctrl+T shows" (Claude Code `thought for Ns`, bytes 2.1.281, 2026-09-23; Pi keeps the
+ * choice, `docs/settings.md:17`, 2026-09-22). While the block streams nothing is added: the status row already says
+ * "thinking". A block with no live timing (a replayed session) says "Thought" without a number (E1).
+ */
+export function thoughtLine(item) {
+    const { startedAt, endedAt } = item;
+    if (typeof startedAt !== 'number' || typeof endedAt !== 'number' || endedAt < startedAt)
+        return t('screen.thought.noDuration');
+    return t('screen.thought.duration', { duration: formatDuration(endedAt - startedAt) });
+}
+/** What the transcript draws: no `run` rows (Q-R3-9); with reasoning collapsed, a block only once it has ended. */
+export function visibleTranscriptItems(items, reasoningVisible) {
+    return items.filter(item => item.kind !== 'run' && (reasoningVisible || item.kind !== 'reasoning' || !item.streaming));
+}

package/dist/tui/components/tool-row.js

@@ -0,0 +1,97 @@
+import { t, tn } from "../../i18n/index.js";
+import { looksItalian } from "../../i18n/kernel-map.js";
+import { rendererKindFor } from "../tool-display.js";
+import { renderTool } from "../tools/registry.js";
+import { lineCount, sanitizeDisplayText } from "../tools/shared.js";
+import { displayWidth, truncateMiddle } from "../text-width.js";
+const SEPARATOR = ' · ';
+/* A target cut narrower than this names nothing (row-format.ts keeps 12 for the same reason). */
+const TARGET_MIN = 12;
+const number = (value) => new Intl.NumberFormat('en-US').format(Math.round(value));
+const clean = (value) => sanitizeDisplayText(String(value ?? '')).replace(/\s*\n\s*/gu, ' ').trim();
+/*
+ * R5a S10 (owner decision Q-R5-17; gate finding 15): why a tool did NOT run, from lane R's `facts.denial`. A rule or the
+ * policy deciding alone names itself (`denied by rule …`, `denied by policy: …`); "you did not approve it" is written only
+ * when the person was asked and said no — `denial.by === 'person'`, or, before lane R's facts arrive, a row whose
+ * approval dialog this transcript opened. A reason that is not English is not shown (E14); the kernel's Italian `via` and
+ * reason are taken off the evidence of a denied row, so its expanded view has no Italian either.
+ */
+export function denialSentence(denial) {
+    if (!denial)
+        return null;
+    const reason = denial.reason && !looksItalian(denial.reason) ? clean(denial.reason).replace(/\.$/u, '') : '';
+    if (denial.by === 'person')
+        return t('tool.denied.person');
+    if (denial.by === 'rule') {
+        const rule = clean(denial.rule);
+        if (!rule)
+            return reason ? t('tool.denied.policy', { reason }) : t('tool.denied.policyNoReason');
+        const scope = clean(denial.scope);
+        return scope ? t('tool.denied.ruleScoped', { rule, scope }) : t('tool.denied.rule', { rule });
+    }
+    if (denial.by === 'mode')
+        return reason ? t('tool.denied.mode', { reason }) : t('tool.denied.modeNoReason');
+    return reason ? t('tool.denied.policy', { reason }) : t('tool.denied.policyNoReason');
+}
+function deniedRow(row) {
+    if (row.status !== 'denied')
+        return row;
+    const denial = row.facts?.denial ?? null;
+    let sentence = denialSentence(denial);
+    /* No decider named yet: the kernel's "you did not approve it" stands only if the person was asked; otherwise the row says
+       only what is known, that the action was refused (a policy deny reaches the kernel as the same "no", gate finding 15). */
+    if (!sentence && !row.askedPerson && String(row.finalOutput ?? '').split(/\r?\n/u)[0]?.trim() === t('error.refused.notApproved'))
+        sentence = t('error.refused.generic');
+    const outcome = row.outcome && (row.outcome.permissionVia !== null || row.outcome.permissionReason !== null) ? { ...row.outcome, permissionVia: null, permissionReason: null } : row.outcome;
+    return { ...row, ...(sentence ? { finalOutput: sentence } : {}), ...(outcome !== row.outcome ? { outcome } : {}) };
+}
+/*
+ * R5a S7 (owner decision Q-R5-11; gate finding 4): a read the kernel cut says so on its row, `450 of 500 lines · cut at
+ * 8,000 characters`, in place of the line count of what came back (which counted a partial last line). The row is fitted
+ * again: the target is cut in the middle to make room; when that would leave the target narrower than 12 columns (60
+ * columns and a long path), `cut at …` moves to the first detail line instead. The height estimate measures this same row.
+ */
+function withReadCut(row, result, width) {
+    const cut = row.readCut;
+    if (!cut || row.status !== 'completed' || rendererKindFor(row.name) !== 'read')
+        return result;
+    const lines = cut.totalLines === null ? tn('tool.result.lines', cut.shownLines, { count: number(cut.shownLines) }) : t('tool.read.cutLines', { shown: number(cut.shownLines), total: number(cut.totalLines) });
+    const cutAt = t('tool.read.cutAt', { limit: number(cut.limitChars) });
+    const counted = tn('tool.result.lines', lineCount(row.finalOutput));
+    const index = result.facts.indexOf(counted);
+    const compose = (added) => {
+        const facts = index >= 0 ? [...result.facts.slice(0, index), ...added, ...result.facts.slice(index + 1)] : [...result.facts, ...added];
+        const statusLabel = facts.join(SEPARATOR);
+        const lineOf = (shown) => result.label + (shown ? ' ' + shown : '') + SEPARATOR + statusLabel;
+        const room = Number.isFinite(width) ? width - displayWidth(lineOf('')) - 1 : Number.POSITIVE_INFINITY;
+        return { facts, statusLabel, room, target: !result.target || displayWidth(lineOf(result.target)) <= width ? result.target : room >= 1 ? truncateMiddle(result.target, room) : '…' };
+    };
+    /* Both facts on the row while the target keeps a readable width; otherwise the cut goes to the first detail line. */
+    let fitted = compose([lines, cutAt]), detailLines = result.detailLines;
+    if (result.target && fitted.target !== result.target && fitted.room < TARGET_MIN) {
+        fitted = compose([lines]);
+        detailLines = [cutAt, ...detailLines];
+    }
+    const title = result.label + (fitted.target ? ' ' + fitted.target : '');
+    return { ...result, title, statusLabel: fitted.statusLabel, line: title + SEPARATOR + fitted.statusLabel, target: fitted.target, facts: fitted.facts, detailLines };
+}
+/*
+ * R5a S6 (owner decision Q-R5-10; gate E6): a command output the executor kept in a private file says how much the row
+ * holds and where the whole output is — the first detail line, in both views, so the way back is always under the row.
+ */
+function withSavedOutput(row, result) {
+    const saved = row.savedOutput;
+    if (!saved)
+        return result;
+    const line = clean(t('tool.output.saved', { kept: number(saved.keptChars), total: number(saved.totalChars), path: saved.path }));
+    return { ...result, detailLines: [line, ...result.detailLines] };
+}
+/* R3 gate E1: the ONE tool row (tools/row-format.ts). app.ts draws `title + ' · ' + statusLabel` (= `line`) and the dim
+   `detailLines`; the height estimate, the search/copy text and the exit transcript read the same result. `now` (optional,
+   default the clock) is the time a running row's elapsed is measured at, so a caller that re-renders once a second can
+   pass its own tick and a test can pin it. R5a: the denial, the read cut and the kept output are added here, once, for
+   every one of those readers. */
+export function toolRowView(row, width, expanded, now) {
+    const shown = deniedRow(row);
+    return withSavedOutput(shown, withReadCut(shown, renderTool(shown, width, expanded, now), width));
+}

package/dist/tui/components/transcript-virtualizer.js

@@ -0,0 +1,165 @@
+import { t, tn } from "../../i18n/index.js";
+import { truncateDisplay, wrapDisplay } from "../text-width.js";
+import { toolRowView } from "./tool-row.js";
+import { thoughtLine } from "./thinking-row.js";
+import { transcriptItemRaw } from "../transcript-model.js";
+const MAX_TRANSCRIPT_MEASUREMENTS = 4096;
+export function transcriptMeasurementKey(itemId, width, variant) {
+    const normalizedWidth = Math.max(1, Math.floor(Number.isFinite(width) ? width : 1));
+    return JSON.stringify([String(itemId), normalizedWidth, String(variant)]);
+}
+export function createTranscriptMeasurementStore() {
+    let snapshot = { version: 0 };
+    const heights = new Map();
+    const listeners = new Set();
+    const publish = () => { snapshot = { version: snapshot.version + 1 }; for (const listener of [...listeners])
+        listener(); };
+    return {
+        getSnapshot: () => snapshot,
+        subscribe(listener) { listeners.add(listener); return () => listeners.delete(listener); },
+        height(key) { return heights.get(String(key)) ?? null; },
+        measure(key, height) {
+            const id = String(key);
+            if (!id || !Number.isFinite(height) || height <= 0)
+                return false;
+            const normalized = Math.max(1, Math.ceil(height));
+            if (heights.get(id) === normalized)
+                return false;
+            if (!heights.has(id) && heights.size >= MAX_TRANSCRIPT_MEASUREMENTS) {
+                const oldest = heights.keys().next().value;
+                if (typeof oldest === 'string')
+                    heights.delete(oldest);
+            }
+            heights.set(id, normalized);
+            publish();
+            return true;
+        },
+    };
+}
+export function planTranscriptVirtualWindow(input) {
+    if (input.scrollRows !== undefined) {
+        const rows = planTranscriptRows({ items: input.items, rowBudget: input.rowBudget, scrollRows: input.scrollRows, heightOf: input.heightOf, ...(input.revealIndex !== undefined ? { revealIndex: input.revealIndex } : {}) });
+        return { ...rows, estimatedRows: rows.totalRows };
+    }
+    const { items, heightOf } = input;
+    const offset = Number.isFinite(input.offset) ? Math.max(0, Math.floor(input.offset)) : 0;
+    const end = Math.max(0, Math.min(items.length, items.length - offset));
+    if (end === 0)
+        return { start: 0, end: 0, rows: [], estimatedRows: 0 };
+    const budget = Number.isFinite(input.rowBudget) ? Math.max(1, Math.floor(input.rowBudget)) : 1;
+    let start = end;
+    let used = 0;
+    while (start > 0) {
+        const index = start - 1;
+        const raw = Number(heightOf(items[index], index));
+        const height = Number.isFinite(raw) && raw > 0 ? Math.max(1, Math.ceil(raw)) : 1;
+        if (start < end && used + height > budget)
+            break;
+        start = index;
+        used += height;
+        if (used >= budget)
+            break;
+    }
+    const revealIndex = Number.isFinite(input.revealIndex) ? Math.floor(input.revealIndex) : -1;
+    const legacyPageSize = Number.isFinite(input.legacyPageSize) ? Math.max(1, Math.floor(input.legacyPageSize)) : 0;
+    if (revealIndex >= 0 && revealIndex < start && revealIndex < end && legacyPageSize > 0) {
+        const legacyStart = Math.max(0, end - legacyPageSize);
+        if (revealIndex >= legacyStart) {
+            let legacyRows = 0;
+            for (let index = legacyStart; index < end; index++) {
+                const raw = Number(heightOf(items[index], index));
+                legacyRows += Number.isFinite(raw) && raw > 0 ? Math.max(1, Math.ceil(raw)) : 1;
+            }
+            return { start: legacyStart, end, rows: items.slice(legacyStart, end), estimatedRows: legacyRows };
+        }
+    }
+    return { start, end, rows: items.slice(start, end), estimatedRows: used };
+}
+/* R1 gate E4: the rows a text takes at `width`, counted with the width function Ink lays out with (text-width.ts). It
+   replaces the old `ceil(width / (0.75 × columns))` estimate, which under-counted prose and let the planner walk back
+   into rows that did not exist (review D-04). Only items never mounted use it: a mounted item reports its measured
+   height (`useBoxMetrics`), and a measurement always wins. */
+export function textRows(text, width) { return Math.max(1, wrapDisplay(String(text), Math.max(1, Math.floor(width))).length); }
+/*
+ * R1 (Q-R1-2, E9, E15): a ROW-based window. `scrollRows` counts rows scrolled up from the newest row; the region that
+ * renders the window is bottom-anchored with its overflow hidden, so the mounted items may be taller than the view and
+ * the view still shows exactly `rowBudget` rows: those between `scrollRows` and `scrollRows + rowBudget` from the
+ * bottom. Unlike the item-offset planner above, the top of an item taller than the screen is reachable with PageUp.
+ */
+export function planTranscriptRows(input) {
+    const { items } = input;
+    const budget = Number.isFinite(input.rowBudget) ? Math.max(0, Math.floor(input.rowBudget)) : 0;
+    const heights = items.map((item, index) => { const raw = Number(input.heightOf(item, index)); return Number.isFinite(raw) && raw > 0 ? Math.max(1, Math.ceil(raw)) : 1; });
+    const below = new Array(items.length);
+    let acc = 0;
+    for (let index = items.length - 1; index >= 0; index--) {
+        below[index] = acc;
+        acc += heights[index];
+    }
+    const totalRows = acc, maxScroll = Math.max(0, totalRows - budget);
+    let scroll = Number.isFinite(input.scrollRows) ? Math.max(0, Math.min(maxScroll, Math.floor(input.scrollRows))) : 0;
+    const reveal = Number.isFinite(input.revealIndex) ? Math.floor(input.revealIndex) : -1;
+    if (reveal >= 0 && reveal < items.length && budget > 0) {
+        /* A search or jump target is brought into view: its first row at the top of the view when it is taller than it. */
+        const top = below[reveal] + heights[reveal], bottom = below[reveal];
+        if (top > scroll + budget || bottom < scroll)
+            scroll = Math.max(0, Math.min(maxScroll, top - budget));
+    }
+    const firstRowFromBottom = (index) => below[index] + heights[index] - 1;
+    const rowsBelow = (index) => below[index];
+    if (items.length === 0 || budget === 0)
+        return { start: items.length, end: items.length, rows: [], clipBelow: 0, hiddenAbove: items.length, totalRows, maxScroll, scrollRows: scroll, firstRowFromBottom, rowsBelow };
+    let end = items.length;
+    while (end > 0 && below[end - 1] + heights[end - 1] <= scroll)
+        end--;
+    let start = end;
+    while (start > 0 && below[start - 1] < scroll + budget)
+        start--;
+    const clipBelow = end > 0 ? Math.max(0, scroll - below[end - 1]) : 0;
+    return { start, end, rows: items.slice(start, end), clipBelow, hiddenAbove: start, totalRows, maxScroll, scrollRows: scroll, firstRowFromBottom, rowsBelow };
+}
+/*
+ * R1 E9 / Q-R1-9: the one dim row that keeps the person's message in sight. When the latest user message starts above
+ * the view it is named ("You: …"); when whole messages are above the view they are counted. Returns null when neither
+ * is true, so the row costs nothing on a short conversation.
+ */
+export function transcriptAnnouncement(input) {
+    const parts = [];
+    if (input.hiddenAbove > 0) {
+        const messages = input.hiddenMessagesAbove;
+        parts.push(messages > 0 ? tn('screen.transcript.earlierMessages', messages) : tn('screen.transcript.earlierItems', input.hiddenAbove));
+    }
+    if (input.promptAboveView && input.latestPrompt) {
+        const prompt = input.latestPrompt.replace(/\s+/gu, ' ').trim();
+        if (prompt)
+            parts.push(t('screen.transcript.youSaid', { prompt }));
+    }
+    if (!parts.length)
+        return null;
+    const text = parts.length === 1 && !parts[0].startsWith('↑') ? `↑ ${parts[0]}` : parts.join(' · ');
+    return truncateDisplay(text, Math.max(1, input.width));
+}
+/* Rows an item takes before it has been measured. Exact for plain text, raw mode, warnings, run rows and tools (the
+   same line lists the renderer draws, wrapped at the same width); a Markdown message is counted from its source text
+   and corrected by the first measurement (E4). */
+export function estimateTranscriptItemRows(item, width, options = {}) {
+    const normalizedWidth = Math.max(1, Math.floor(Number.isFinite(width) ? width : 80));
+    if (options.raw)
+        return textRows(transcriptItemRaw(item), normalizedWidth);
+    if (item.kind === 'message')
+        return 1 + textRows(item.text, normalizedWidth);
+    /* R5a S8 (Q-R5-9): a collapsed reasoning block is its one dim line (components/thinking-row.ts). */
+    if (item.kind === 'reasoning')
+        return options.reasoningVisible === false ? textRows(thoughtLine(item), normalizedWidth) : 3 + textRows(item.text || ' ', Math.max(1, normalizedWidth - 2));
+    /* R3 gate E1: the tool row's height comes from the ONE row formatter — the same header line app.ts draws (`line` is
+       `title · statusLabel`) and the same detail lines — so the estimate and the render cannot disagree. */
+    if (item.kind === 'tool') {
+        const view = toolRowView(item, normalizedWidth, Boolean(options.expandedTools), options.now);
+        return textRows(view.line, normalizedWidth) + view.detailLines.reduce((rows, line) => rows + textRows(line, normalizedWidth), 0);
+    }
+    /* A warning, and since R3 (Q-R3-9) the one outcome line of a turn that did not end normally (a warning with `outcome`). */
+    if (item.kind === 'warning')
+        return textRows(item.text, normalizedWidth);
+    /* Legacy `run` items are no longer produced (Q-R3-9); counted the way app.ts still draws one. */
+    return textRows(t('screen.transcript.run', { status: item.status }) + (item.message ? ' · ' + item.message : ''), normalizedWidth);
+}

package/dist/tui/components/transcript.js

@@ -0,0 +1,43 @@
+import { t } from "../../i18n/index.js";
+import { sanitizeTranscriptText } from "../transcript-model.js";
+export function reduceViewport(view, event, total) {
+    if (event === 'jump-tail')
+        return { ...view, offset: 0, unseen: 0, followingTail: true };
+    if (event === 'new-content')
+        return view.followingTail ? { ...view, offset: 0 } : { ...view, unseen: view.unseen + 1 };
+    if (event === 'page-up') {
+        const max = Math.max(0, total - view.pageSize);
+        const offset = Math.min(max, view.offset + view.pageSize);
+        return { ...view, offset, followingTail: false };
+    }
+    const offset = Math.max(0, view.offset - view.pageSize);
+    return { ...view, offset, followingTail: offset === 0, unseen: offset === 0 ? 0 : view.unseen };
+}
+export function transcriptWindow(rows, view) {
+    const end = Math.max(0, rows.length - Math.max(0, view.offset));
+    const start = Math.max(0, end - Math.max(1, view.pageSize));
+    return rows.slice(start, end);
+}
+/* R5a S3: a compaction notice is a new row too. */
+export function transcriptEventAddsItem(event) { return event.type === 'run.started' || event.type === 'message.started' || event.type === 'reasoning.started' || event.type === 'tool.started' || event.type === 'warning' || event.type === 'context.compacted' || event.type === 'context.compaction.paused'; }
+export const TRANSCRIPT_COPY_MAX_BYTES = 1024 * 1024;
+export class TranscriptCopyError extends Error {
+    code;
+    constructor(code, message = code) { super(message); this.name = 'TranscriptCopyError'; this.code = code; }
+}
+export function transcriptViewportForIndex(view, total, index) {
+    const count = Math.max(0, Math.trunc(total)), pageSize = Math.max(1, Math.trunc(view.pageSize));
+    if (count === 0)
+        return { ...view, offset: 0, unseen: 0, followingTail: true };
+    const target = Math.max(0, Math.min(count - 1, Math.trunc(index)));
+    const maxOffset = Math.max(0, count - pageSize);
+    const offset = Math.min(maxOffset, Math.max(0, count - 1 - target));
+    return { ...view, offset, followingTail: offset === 0, unseen: offset === 0 ? 0 : view.unseen };
+}
+export function osc52CopySequence(text) {
+    const safe = sanitizeTranscriptText(String(text));
+    const bytes = Buffer.byteLength(safe, 'utf8');
+    if (bytes > TRANSCRIPT_COPY_MAX_BYTES)
+        throw new TranscriptCopyError('TRANSCRIPT_COPY_LIMIT', t('screen.copy.tooLarge'));
+    return '\u001b]52;c;' + Buffer.from(safe, 'utf8').toString('base64') + '\u0007';
+}

package/dist/tui/descendant-approvals.js

@@ -0,0 +1,104 @@
+import { createTuiEventAdapter } from "./event-adapter.js";
+/** The sessions below `rootId`, at every level, from a session list. */
+export function descendantsOf(rows, rootId) {
+    const idOf = (row) => typeof row.sessionId === 'string' && row.sessionId ? row.sessionId : typeof row.id === 'string' && row.id ? row.id : null;
+    const below = new Set([rootId]), found = [];
+    for (let grew = true; grew;) {
+        grew = false;
+        for (const row of rows) {
+            const id = idOf(row);
+            if (!id || below.has(id) || typeof row.parentId !== 'string' || !below.has(row.parentId))
+                continue;
+            below.add(id);
+            grew = true;
+            found.push({ sessionId: id, task: typeof row.delegatedTask === 'string' && row.delegatedTask.trim() ? row.delegatedTask : null, depth: typeof row.depth === 'number' ? row.depth : 1 });
+        }
+    }
+    return found;
+}
+export function createDescendantApprovals({ runtime, secretValues = [], intervalMs = 500, onRequired, onResolved, onError = () => { } }) {
+    let rootId = null, timer = null, syncing = false, generation = 0;
+    const watched = new Map();
+    function watch(origin) {
+        const adapter = createTuiEventAdapter(secretValues);
+        adapter.bindSession(origin.sessionId);
+        /* The replay is synchronous inside `subscribe`: what it asks and answers is settled first, and only the requests still
+           waiting at its end are handed over. */
+        let replaying = true;
+        const waiting = new Map();
+        const handle = (event) => {
+            if (event.type === 'approval.required') {
+                if (replaying)
+                    waiting.set(event.requestId, event);
+                else
+                    onRequired(origin, event);
+            }
+            else if (event.type === 'approval.resolved') {
+                if (replaying)
+                    waiting.delete(event.requestId);
+                else
+                    onResolved(origin, event.requestId);
+            }
+            else if (replaying && (event.type === 'run.completed' || event.type === 'run.failed' || event.type === 'run.cancelled'))
+                waiting.clear();
+        };
+        let off = () => { };
+        try {
+            off = runtime.subscribe(origin.sessionId, raw => { for (const event of adapter.translateAll(raw))
+                handle(event); });
+        }
+        finally {
+            replaying = false;
+        }
+        watched.set(origin.sessionId, off);
+        for (const event of waiting.values())
+            onRequired(origin, event);
+    }
+    async function sync() {
+        if (!rootId || syncing)
+            return;
+        syncing = true;
+        const mine = generation;
+        try {
+            const rows = await runtime.listSessions();
+            if (mine !== generation || !rootId)
+                return;
+            for (const origin of descendantsOf(rows, rootId))
+                if (!watched.has(origin.sessionId))
+                    watch(origin);
+        }
+        catch (error) {
+            onError(error);
+        }
+        finally {
+            syncing = false;
+        }
+    }
+    function stop() {
+        generation++;
+        rootId = null;
+        if (timer) {
+            clearInterval(timer);
+            timer = null;
+        }
+        for (const off of watched.values()) {
+            try {
+                off();
+            }
+            catch { /* an unsubscribe that fails leaves nothing to undo */ }
+        }
+        watched.clear();
+    }
+    /** Watches the descendants of `sessionId` until `stop`; a second call for the same session changes nothing. */
+    function start(sessionId) {
+        if (rootId === sessionId && timer)
+            return;
+        stop();
+        rootId = sessionId;
+        timer = setInterval(() => void sync(), Math.max(50, intervalMs));
+        timer.unref?.();
+        void sync();
+    }
+    /** `sync` asks the session list now (tests, and a delegation that has just started). */
+    return { start, stop, sync, watching: () => [...watched.keys()] };
+}