talos-code 0.0.1 → 0.2.0

package/dist/tui/live-activity.js

@@ -0,0 +1,56 @@
+import { t } from "../i18n/index.js";
+import { toolDisplay } from "./tool-display.js";
+/*
+ * P14 (owner, 2026-09-25, "lo spinner thinking rimane in conteggio quando gli agenti vengono dispacciati"): a tool row is
+ * born `queued` (state.ts `tool.started`) and becomes `running` only after an approval, `streaming` only when it prints.
+ * A tool that runs silently without asking — the delegation, which waits for its sub-agents, a long read, a web fetch —
+ * stayed `queued`, was not counted as active, and the line said "thinking" with its clock running. `queued` is active
+ * now; and while delegations are running the line says how many agents are working.
+ */
+const ACTIVE_TOOL = new Set(['queued', 'running', 'streaming']);
+const DELEGATION_TOOLS = new Set(['delega_sottotask']);
+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 delegations = state.tools.filter(row => ACTIVE_TOOL.has(row.status) && row.name !== undefined && DELEGATION_TOOLS.has(row.name)).length;
+    if (delegations > 0)
+        return { kind: 'agents', startedAt: busySince, agents: delegations };
+    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 === 'agents' || 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,43 @@
+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'))];
+    /* P13: Enter watches the selected agent live; on the session in use it goes back to it (Claude Code's "Enter to view",
+       not offered on the agent already watched). */
+    const detail = selected.id === input.viewingId
+        ? t('screen.agents.watchingHint')
+        : selected.id === input.currentSessionId
+            ? (input.viewingId ? t('screen.agents.backHint') : input.running ? t('screen.agents.steerHint') : t('screen.agents.inspectOnly'))
+            : t('screen.agents.watchHint');
+    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' });
+}