talos-code 0.0.1 → 0.1.0

package/dist/tui/keymap-resolver.js

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

package/dist/tui/launch-state.js

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

package/dist/tui/line-diff.js

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

package/dist/tui/live-activity.js

@@ -0,0 +1,45 @@
+import { t } from "../i18n/index.js";
+import { toolDisplay } from "./tool-display.js";
+const ACTIVE_TOOL = new Set(['running', 'streaming']);
+export function deriveLiveActivity(state, busySince) {
+    if (!state.running) {
+        if (typeof state.sentAt === 'number')
+            return { kind: 'starting', startedAt: state.sentAt };
+        if (state.lastTurn)
+            return { kind: state.lastTurn.outcome, startedAt: null, frozenMs: state.lastTurn.durationMs };
+        return { kind: 'idle', startedAt: null };
+    }
+    if (state.waitingForPerson === true)
+        return { kind: 'waiting', startedAt: busySince };
+    /* R5a S4 (E5): a retry is its own state, never "thinking": attempt 2 and later of a request the provider refused. */
+    if (isRetry(state.retry))
+        return { kind: 'retrying', startedAt: state.retry.at };
+    const tool = [...state.tools].reverse().find(row => ACTIVE_TOOL.has(row.status));
+    if (tool)
+        return tool.name ? { kind: 'tool', startedAt: busySince, tool: toolDisplay(tool.name).label } : { kind: 'tool', startedAt: busySince };
+    if (state.streamingAssistant && state.streamingAssistant.text.length > 0)
+        return { kind: 'writing', startedAt: busySince };
+    return { kind: 'thinking', startedAt: busySince };
+}
+/*
+ * R5a S4 (owner decision Q-R5-6; gate E5): the retry line, `Retrying · attempt 2 of 4 · HTTP 429 · in 7 s` (Pi
+ * `status-indicator.ts:51-81`, 2026-09-07; OpenCode PR #47145, 2026-09-04). The countdown is shown only while the wait is
+ * known and not over; with no known wait the provider's own `Retry-After` is stated as asked, never counted down; with
+ * neither, no time at all. Esc interrupts it like any turn (the kernel's wait is abortable).
+ */
+export function isRetry(retry) { return Boolean(retry && retry.attempt >= 2); }
+export function retryCountdownEnd(retry) { return isRetry(retry) && retry.waitMs !== null ? retry.at + retry.waitMs : null; }
+export function retryLine(retry, nowMs) {
+    const parts = [t('screen.retry.title'), t('screen.retry.attempt', { attempt: retry.attempt, max: retry.maxAttempts }), retry.status === null ? t('screen.retry.noResponse') : t('screen.retry.http', { status: retry.status })];
+    const left = retry.waitMs === null ? null : retry.at + retry.waitMs - nowMs;
+    if (left !== null && left > 0)
+        parts.push(t('screen.retry.in', { seconds: Math.ceil(left / 1000) }));
+    else if (retry.waitMs === null && retry.retryAfterMs !== null)
+        parts.push(t('screen.retry.asked', { seconds: Math.ceil(retry.retryAfterMs / 1000) }));
+    return parts.join(' · ');
+}
+/** Kinds that change while you look at them: the only ones that start the motion clock (idle writes nothing, R1 E5).
+ *  `retrying` is not one of them: its countdown ticks once a second, and only while the wait lasts (app.ts). */
+export function isAnimatedActivity(kind) {
+    return kind === 'starting' || kind === 'thinking' || kind === 'writing' || kind === 'tool' || kind === 'waiting' || kind === 'compacting' || kind === 'connecting' || kind === 'updating';
+}

package/dist/tui/metrics.js

@@ -0,0 +1,123 @@
+export const NOOP_TUI_METRICS_SINK = Object.freeze({ record(_metric) { } });
+export function createTuiMetricsCollector() {
+    const metrics = [];
+    return {
+        sink: { record(metric) { metrics.push(structuredClone(metric)); } },
+        snapshot: () => structuredClone(metrics),
+        reset: () => { metrics.length = 0; }
+    };
+}
+export function createTuiMetricsProfiler(options = {}) {
+    const sink = options.sink ?? NOOP_TUI_METRICS_SINK;
+    const clock = options.clock ?? (() => performance.now());
+    const receivedAt = new Map();
+    return {
+        eventReceived(eventId) { receivedAt.set(eventId, clock()); },
+        renderCoalesced(waitMs) { sink.record({ name: 'tui.render.coalesce_ms', value: Math.max(0, waitMs), unit: 'milliseconds' }); },
+        renderCommitted({ eventIds = [], reason }) {
+            sink.record({ name: 'tui.render.committed', value: 1, unit: 'count', tags: { reason } });
+            const visibleAt = clock();
+            for (const eventId of eventIds) {
+                const received = receivedAt.get(eventId);
+                if (received === undefined)
+                    continue;
+                sink.record({ name: 'tui.event_to_visible_ms', value: Math.max(0, visibleAt - received), unit: 'milliseconds' });
+                receivedAt.delete(eventId);
+            }
+            if (reason === 'idle')
+                sink.record({ name: 'tui.render.idle', value: 1, unit: 'count' });
+        }
+    };
+}
+function percentile(values, fraction) {
+    if (values.length === 0)
+        return 0;
+    const sorted = [...values].sort((a, b) => a - b);
+    const rank = Math.max(1, Math.ceil(sorted.length * fraction));
+    return sorted[Math.min(sorted.length - 1, rank - 1)];
+}
+export function summarizeTuiMetrics(metrics) {
+    const visible = metrics.filter(row => row.name === 'tui.event_to_visible_ms').map(row => row.value);
+    const coalesced = metrics.filter(row => row.name === 'tui.render.coalesce_ms').map(row => row.value);
+    const renders = metrics.filter(row => row.name === 'tui.ink.render_ms').map(row => row.value);
+    const total = (name, kind) => metrics.reduce((sum, row) => row.name === name && (kind === undefined || row.tags?.kind === kind) ? sum + row.value : sum, 0);
+    return {
+        committed: metrics.filter(row => row.name === 'tui.render.committed').length,
+        idle: metrics.filter(row => row.name === 'tui.render.idle').length,
+        coalesceMaxMs: coalesced.length ? Math.max(...coalesced) : 0,
+        eventToVisible: {
+            count: visible.length,
+            p50: percentile(visible, 0.50),
+            p95: percentile(visible, 0.95),
+            max: visible.length ? Math.max(...visible) : 0,
+        },
+        /* Gate E6: what TALOS itself wrote (before ConPTY), and how often Ink rendered. Zero while idle is the target (E5). */
+        inkRenders: { count: renders.length, maxMs: renders.length ? Math.max(...renders) : 0 },
+        frames: total('tui.output.frame'),
+        bytes: total('tui.output.bytes'),
+        clears: { display: total('tui.output.clear', 'display'), scrollback: total('tui.output.clear', 'scrollback') },
+    };
+}
+/**
+ * Gate E6, in-process: counts what TALOS writes to the terminal — bytes, DEC 2026 frames (one BSU per Ink frame) and
+ * the full clears `ESC[2J` / `ESC[3J` that Ink 7.1.1 writes on win32 for every commit of a frame at least as tall as the
+ * terminal (`ink/build/ink.js:83-112, 748-772`). A sequence split across two writes counts once: a match counts only
+ * when it ends in the newest chunk.
+ */
+const OUTPUT_SEQUENCES = [
+    ['\u001B[?2026h', 'tui.output.frame', undefined],
+    ['\u001B[2J', 'tui.output.clear', { kind: 'display' }],
+    ['\u001B[3J', 'tui.output.clear', { kind: 'scrollback' }],
+];
+export function createTerminalOutputMeter(sink) {
+    let carry = '';
+    return { observe(chunk) {
+            const text = typeof chunk === 'string' ? chunk : chunk instanceof Uint8Array ? Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength).toString('latin1') : '';
+            const bytes = typeof chunk === 'string' ? Buffer.byteLength(chunk) : chunk instanceof Uint8Array ? chunk.byteLength : 0;
+            if (bytes === 0)
+                return;
+            sink.record({ name: 'tui.output.bytes', value: bytes, unit: 'count' });
+            const scan = carry + text;
+            for (const [sequence, name, tags] of OUTPUT_SEQUENCES) {
+                let found = 0;
+                for (let at = scan.indexOf(sequence); at >= 0; at = scan.indexOf(sequence, at + 1))
+                    if (at + sequence.length > carry.length)
+                        found++;
+                if (found)
+                    sink.record({ name, value: found, unit: 'count', ...(tags ? { tags } : {}) });
+            }
+            carry = scan.slice(-7);
+        } };
+}
+/**
+ * Wires the E6 counters for `TALOS_TUI_RENDER_METRICS=1`: wraps `stdout.write` (every chunk still reaches the terminal)
+ * and gives the `onRender` option of Ink's `render()` (Ink 7.1.1 calls it once per rendered frame, after throttling;
+ * `ink/build/ink.js:349`), so Ink renders are counted in-process. `dispose()` restores the original `write`.
+ */
+export function createTuiRenderMetricsTap({ stdout, sink }) {
+    const meter = createTerminalOutputMeter(sink);
+    const original = stdout.write;
+    const tapped = function (...args) { meter.observe(args[0]); return original.apply(this ?? stdout, args); };
+    stdout.write = tapped;
+    return {
+        inkOptions: { onRender({ renderTime }) { sink.record({ name: 'tui.ink.render_ms', value: Math.max(0, renderTime), unit: 'milliseconds' }); } },
+        dispose() { if (stdout.write === tapped)
+            stdout.write = original; },
+    };
+}
+export function currentProcessPerformanceSnapshot() {
+    const memory = process.memoryUsage();
+    const usage = process.resourceUsage();
+    let eventLoopUtilization = null;
+    try {
+        const p = performance;
+        const row = typeof p.eventLoopUtilization === 'function' ? p.eventLoopUtilization() : null;
+        eventLoopUtilization = typeof row?.utilization === 'number' && Number.isFinite(row.utilization) ? row.utilization : null;
+    }
+    catch { }
+    return {
+        rssBytes: memory.rss, heapUsedBytes: memory.heapUsed, externalBytes: memory.external,
+        userCPUTimeMicros: usage.userCPUTime, systemCPUTimeMicros: usage.systemCPUTime,
+        maxRSSKiB: usage.maxRSS, eventLoopUtilization,
+    };
+}

package/dist/tui/onboarding.js

@@ -0,0 +1,36 @@
+import { t } from "../i18n/index.js";
+import { missingKeyText } from "../provider/missing-key.js";
+import { inertProjectTrustText } from "./project-trust-prompt.js";
+/* The words live in the dictionary (R4: moved from here to i18n/en/firstrun.ts, same words). */
+export const ONBOARDING_COPY = Object.freeze({
+    en: Object.freeze({
+        trust: Object.freeze({ text: t('firstrun.setup.trust'), command: 'talos project trust --include-nested' }),
+        provider: Object.freeze({ text: t('firstrun.setup.provider'), command: '/provider' }),
+        model: Object.freeze({ text: t('firstrun.setup.model'), command: '/model' }),
+    }),
+});
+/*
+ * R4 CONTRACT (owner: lane F; lane N calls it from app.ts), owner decision Q-R4-13:
+ * - `keyMissing`: the chosen provider has no key usable now. `true` says so in general; a provider id says it with the one
+ *   missing-key sentence (R2 E8, the same as -p, `provider test` and doctor), which names the provider's own variable. Either
+ *   way the command is /provider. It follows the provider step (with no provider chosen, choosing one asks for the key).
+ * - `loadedFiles`: the instruction files TALOS loaded for this folder (main.ts, after trust), named relative to the project
+ *   root; one `info` line first — `Loaded AGENTS.md` — even when nothing else is missing.
+ */
+export function onboardingSteps(input, locale = 'en') {
+    const copy = ONBOARDING_COPY[locale] ?? ONBOARDING_COPY.en;
+    const out = [];
+    const files = (input.loadedFiles ?? []).filter(file => typeof file === 'string' && file.length > 0);
+    if (files.length)
+        out.push({ id: 'loaded', kind: 'info', text: t('firstrun.setup.loaded', { files: files.map(inertProjectTrustText).join(', ') }), command: '' });
+    const step = (id) => out.push({ id, kind: 'step', text: copy[id].text, command: copy[id].command });
+    if (!input.projectTrusted)
+        step('trust');
+    if (!input.providerConfigured)
+        step('provider');
+    else if (input.keyMissing)
+        out.push({ id: 'key', kind: 'step', text: typeof input.keyMissing === 'string' ? missingKeyText(input.keyMissing) : t('firstrun.setup.key'), command: '/provider' });
+    if (!input.modelConfigured)
+        step('model');
+    return out;
+}

package/dist/tui/overlays/agent-tree.js

@@ -0,0 +1,39 @@
+import { t } from "../../i18n/index.js";
+import { agentRosterLine, shellSafeText } from "../components/terminal-shell.js";
+import { truncateDisplay } from "../text-width.js";
+import { listOverlay } from "./scroll-window.js";
+export function createAgentTreeOverlayModel(rows, selectedId) {
+    const copied = rows.map(row => ({ ...row, usage: row.usage ? { ...row.usage } : null, delegationEvidence: row.delegationEvidence ? { ...row.delegationEvidence } : null }));
+    const index = selectedId ? copied.findIndex(row => row.id === selectedId) : -1;
+    return { rows: copied, selected: index >= 0 ? index : 0 };
+}
+export function moveAgentTreeSelection(model, delta) {
+    if (model.rows.length === 0)
+        return { ...model, selected: 0 };
+    const next = Math.max(0, Math.min(model.rows.length - 1, model.selected + Math.trunc(delta)));
+    return next === model.selected ? model : { ...model, selected: next };
+}
+export function selectedAgentRow(model) {
+    return model.rows[model.selected] ?? null;
+}
+export function agentTreeOverlayLines(model, input) {
+    const width = Math.max(1, Math.floor(input.width));
+    const fit = (value) => truncateDisplay(shellSafeText(value), width);
+    const lines = [fit(t('screen.agents.title'))];
+    model.rows.forEach((row, index) => {
+        const display = { ...row, focused: index === model.selected };
+        lines.push(agentRosterLine({ row: display, width, nowMs: input.nowMs, marker: index === model.selected ? '›' : ' ' }));
+    });
+    const selected = selectedAgentRow(model);
+    if (!selected)
+        return [...lines, fit(t('screen.agents.empty'))];
+    const detail = selected.id === input.currentSessionId && input.running
+        ? t('screen.agents.steerHint')
+        : t('screen.agents.inspectOnly');
+    lines.push(fit(detail));
+    return lines;
+}
+// R1 Q-R1-3: the same lines as a capped, scrolling overlay (overlays/scroll-window.ts).
+export function agentTreeOverlay(model, input) {
+    return listOverlay(agentTreeOverlayLines(model, input), { head: 1, list: model.rows.length, selected: model.selected, foot: 1, tones: (line, index) => index === 0 ? 'accent' : /COLLISION/u.test(line) ? 'strong' : 'dim' });
+}