talos-code 0.1.0 → 0.2.1

package/dist/tui/catalog-service.js

@@ -466,7 +466,7 @@ export function createTuiCatalogService(deps) {
                 const result = await localModels(provider, local, signal);
                 if (result.kind !== 'ok') {
                     const said = t(result.kind === 'down' ? 'firstrun.models.down' : 'firstrun.models.unreadable', { label, address: result.address });
-                    return { provider, label, rows: known, verified: false, notice: known.length ? `${said} ${t('firstrun.models.knownOnly')}` : said };
+                    return { provider, label, rows: known, verified: false, notice: known.length ? `${said} ${t('firstrun.models.knownOnly')}` : said, engine: result.kind };
                 }
                 const rows = mergeModels(result.rows, known);
                 const installed = result.rows.length;
@@ -498,6 +498,7 @@ export function createTuiCatalogService(deps) {
             throw Object.assign(new Error('CONFIG_SCOPE_INVALID'), { code: 'CONFIG_SCOPE_INVALID' }); await deps.persistModel(id); },
         testProviderKey,
         keyTestNotice,
+        ...(deps.openRouterLogin ? { startOpenRouterLogin: (input) => deps.openRouterLogin(input) } : {}),
         async setProviderKey(id, secret, signal) {
             const test = await testProviderKey(id, secret, signal);
             if (!test.passed)

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

@@ -1,4 +1,4 @@
-import { t } from "../../i18n/index.js";
+import { t, tn } 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. */
@@ -7,16 +7,22 @@ const STATIC_GLYPH = {
     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}`); }
+export function activityWord(kind, tool, agents) {
+    if (kind === 'agents' && agents && agents > 0)
+        return tn('screen.busy.agentsCount', agents);
+    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 }) {
+export function busyIndicatorText({ kind, elapsedMs, frame, unicode, frames, tool, agents, 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, ' ');
+    /* P13 (owner decision 4): while agents work, the line says how to watch them. */
+    const word = activityWord(kind, tool, agents);
+    const verb = (kind === 'agents' && agents && agents > 0 ? `${word} · ${t('screen.busy.agentsWatch')}` : word).padEnd(10, ' ');
     const elapsed = NO_ELAPSED.has(kind) ? '     ' : stableElapsedLabel(elapsedMs);
     return `${glyph} ${verb} ${elapsed}`;
 }

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

@@ -191,6 +191,15 @@ export function frameRowsFor(rows, platform = process.platform, policy = WIN32_F
     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' };
@@ -200,6 +209,6 @@ export function terminalFrameProps({ session, background, rows, columns, platfor
         flexDirection: 'column',
         width,
         height,
-        ...(session.paintBackground && background ? { backgroundColor: background } : {}),
+        ...(session.paintBackground ? { backgroundColor: background || UNPAINTED_BACKGROUND } : {}),
     };
 }

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()] };
+}

package/dist/tui/launch-state.js

@@ -49,6 +49,15 @@ function writeRecord(dataRoot, record) {
         catch { /* the temporary file was never created */ }
     }
 }
+/** P17: whether this profile has never launched the interface, read without recording a launch (the trust question asks). */
+export function isFirstLaunch(dataRoot) {
+    try {
+        return readRecord(launchStatePath(dataRoot)) === null;
+    }
+    catch {
+        return false;
+    }
+}
 export function bootPlan(input) {
     const previous = readRecord(launchStatePath(input.dataRoot));
     const build = typeof input.build === 'string' && input.build !== '' ? input.build : null;

package/dist/tui/live-activity.js

@@ -1,6 +1,14 @@
 import { t } from "../i18n/index.js";
 import { toolDisplay } from "./tool-display.js";
-const ACTIVE_TOOL = new Set(['running', 'streaming']);
+/*
+ * 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')
@@ -14,6 +22,9 @@ export function deriveLiveActivity(state, 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 };
@@ -41,5 +52,5 @@ export function retryLine(retry, nowMs) {
 /** 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';
+    return kind === 'starting' || kind === 'thinking' || kind === 'writing' || kind === 'tool' || kind === 'agents' || kind === 'waiting' || kind === 'compacting' || kind === 'connecting' || kind === 'updating';
 }

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

@@ -27,9 +27,13 @@ export function agentTreeOverlayLines(model, input) {
     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');
+    /* 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;
 }

package/dist/tui/overlays/approval-dialog.js

@@ -240,6 +240,8 @@ export function approvalDialogModel(pending, input) {
     const question = t(questionId in QUESTION_IDS ? questionId : 'approval.question');
     /* Q-R3-13 (R0 decision 4): a command approval on a host with no verified sandbox says so in its title. */
     const title = t('tool.approval.title', { label }) + (input.unsandboxed === true && action.tool === 'Bash' ? ` ${t('approval.unsandboxed')}` : '');
+    /* P13 (owner decision 8): an approval a sub-agent asks for says so, as Claude Code's does ("from a subagent"). */
+    const origin = pending.origin?.kind === 'agent' ? ` ${pending.origin.task ? t('approval.origin.agent', { task: pending.origin.task }) : t('approval.origin.agentUnnamed')}` : '';
     const change = approvalChange(pending);
     const ruleLine = pending.rule === PATH_BOUNDARY_RULE ? 'decided by the path boundary' : pending.rule ? `rule ${pending.rule}` : undefined;
     const explanation = pending.explanation;
@@ -253,7 +255,7 @@ export function approvalDialogModel(pending, input) {
             segments = rows;
     }
     return {
-        title, summary, fullPayload, expanded: input.expanded, reason: pending.reason, ...(pending.rule ? { rule: pending.rule } : {}), ...(pending.runtimeHint ? { runtimeHint: pending.runtimeHint } : {}),
+        title: title + origin, summary, fullPayload, expanded: input.expanded, reason: pending.reason, ...(pending.rule ? { rule: pending.rule } : {}), ...(pending.runtimeHint ? { runtimeHint: pending.runtimeHint } : {}),
         ...(ruleLine ? { ruleLine } : {}), segments, ...(segmentsWithheld ? { segmentsWithheld } : {}), ...(pending.explanationError ? { explanationError: pending.explanationError } : {}),
         ...(input.expanded && pending.alwaysSimulation ? { alwaysPreview: alwaysPreview(pending, pending.alwaysSimulation) } : {}),
         question, selected, ...(change ? { change } : {}),

package/dist/tui/overlays/model-picker.js

@@ -12,6 +12,7 @@ export function createModelPickerModel(catalog, input) {
     let verified = false;
     let notice = '';
     let label = input.provider ?? '';
+    let engine = null;
     let abort = null;
     return {
         async open() {
@@ -19,6 +20,7 @@ export function createModelPickerModel(catalog, input) {
             loadError = null;
             models = [];
             verified = false;
+            engine = null;
             if (!input.provider) {
                 notice = t('screen.model.chooseProviderFirst');
                 return;
@@ -33,6 +35,7 @@ export function createModelPickerModel(catalog, input) {
                 verified = list.verified;
                 notice = list.notice;
                 label = list.label;
+                engine = list.engine ?? null;
                 const current = input.current;
                 if (current && current.startsWith(`${input.provider}:`) && !models.some(row => row.id === current)) {
                     models = [...models, ...normalizeModels([{ id: current }], input.provider, 'configured')];
@@ -52,6 +55,8 @@ export function createModelPickerModel(catalog, input) {
         error: () => loadError,
         verified: () => verified,
         notice: () => notice,
+        /* P17: a local engine that did not answer (the setup offers R to retry). */
+        engineDown: () => engine === 'down',
         label: () => label,
     };
 }

package/dist/tui/overlays/provider-picker.js

@@ -133,6 +133,32 @@ export function providerConsentOverlay({ provider, choice }) {
         foot: [{ text: t('screen.provider.consentFoot'), tone: 'dim' }],
     };
 }
+export function providerLoginChoiceOverlay({ label, choice, notice = null }) {
+    const options = [{ choice: 'browser', text: t('screen.provider.loginBrowser', { provider: label }) }, { choice: 'paste-key', text: t('screen.provider.loginPasteKey') }];
+    return {
+        head: [{ text: t('screen.provider.titleNamed', { provider: label }), tone: 'title' }],
+        /* A saved key that does not work now (benched) is said here too, before the person picks a way. */
+        sections: [{ lines: [...(notice ? [{ text: notice, tone: 'plain' }] : []), ...options.map(option => ({ text: `${option.choice === choice ? '›' : ' '} ${option.text}`, tone: option.choice === choice ? 'selected' : 'accent' }))], selected: (notice ? 1 : 0) + Math.max(0, options.findIndex(option => option.choice === choice)) }],
+        foot: [{ text: t('screen.provider.loginChoiceKeys'), tone: 'dim' }],
+    };
+}
+/* The sign-in under way: the address (always shown, the browser may not open), then the code the person may paste. Only the
+   MASK of a pasted code reaches this view. */
+export function providerOAuthOverlay({ label, url, mode, opened, phase, masked, message }) {
+    const lines = [];
+    if (mode === 'paste')
+        lines.push(t('screen.provider.oauthRemote', { provider: label }));
+    else
+        lines.push(t(opened ? 'screen.provider.oauthOpened' : 'screen.provider.oauthNotOpened', { provider: label }));
+    lines.push(url);
+    const typing = phase === 'paste' || (mode === 'paste' && phase !== 'failed');
+    if (typing)
+        lines.push(t('screen.provider.oauthPaste', { masked: masked || ' ' }));
+    if (message)
+        lines.push(message);
+    const foot = phase === 'exchanging' ? t('screen.provider.oauthExchanging') : phase === 'failed' ? t('screen.provider.oauthFailedKeys') : typing ? t('screen.provider.oauthPasteKeys') : t('screen.provider.oauthWaiting');
+    return { head: [{ text: t('screen.provider.titleNamed', { provider: label }), tone: 'title' }], sections: [{ lines: lines.map(text => ({ text, tone: 'plain' })), selected: typing ? lines.findIndex(line => line.startsWith(t('screen.provider.oauthPaste', { masked: '' }).trim())) : 0 }], foot: [{ text: foot, tone: 'dim' }] };
+}
 // Only the MASK reaches this view, never the typed key. The key line is the "selected" row: it is where the person types.
 export function providerKeyOverlay({ label, remediation, benched, masked, keyTestNotice, testing, result }) {
     const lines = [...(remediation ? [remediation] : []), ...(benched ? [benched] : [])];

package/dist/tui/project-trust-prompt.js

@@ -4,6 +4,7 @@ import { detectTerminalCapabilities } from "./terminal-capabilities.js";
 import { createTerminalSessionPlan } from "./terminal-session.js";
 import { displayWidth, truncateDisplay, truncateMiddle, wrapDisplay } from "./text-width.js";
 import { liveTheme } from "./theme-store.js";
+import { DEFAULT_THEME_ACCENT } from "./theme-catalog.js";
 export const PROJECT_TRUST_GRACE_MS = 300;
 /* E4: paths are shown as the person types them. Control, C1, line/paragraph separators, bidi controls and
    default-ignorable characters are shown as `\uXXXX`; a backslash is doubled only where it would read as such an escape
@@ -38,7 +39,7 @@ function resourceLine(resource) {
     const where = inertProjectTrustText(resource.relativePath);
     return resource.id === resource.relativePath ? `${resource.kind} · ${where}` : `${resource.kind} · ${inertProjectTrustText(resource.id)} · ${where}`;
 }
-export function projectTrustPromptModel({ assessment, nestedRepositories }) {
+export function projectTrustPromptModel({ assessment, nestedRepositories, setupStep }) {
     const counts = new Map();
     for (const resource of assessment.resources)
         counts.set(resource.kind, (counts.get(resource.kind) ?? 0) + 1);
@@ -55,6 +56,7 @@ export function projectTrustPromptModel({ assessment, nestedRepositories }) {
     const firstTime = assessment.trusted || assessment.reason === 'PROJECT_UNTRUSTED';
     return {
         title: t(firstTime ? 'firstrun.trust.title' : 'firstrun.trust.titleChanged'),
+        ...(setupStep ? { setupStep: true } : {}),
         project: inertProjectTrustText(assessment.workspace.canonicalRoot),
         reason: reasonText(assessment),
         resourceSummary: assessment.resources.length ? tn('firstrun.trust.files', assessment.resources.length, { detail }) : '',
@@ -118,7 +120,7 @@ export function layoutProjectTrustPrompt(model, { columns, rows, selected, platf
         }
         return { kind: 'choice', text: truncateDisplay(`${choice.id === selected ? '>' : ' '} ${label}`, width), selected: choice.id === selected };
     });
-    const title = truncateDisplay(t('firstrun.trust.heading', { title: model.title }), width);
+    const title = truncateDisplay(t(model.setupStep ? 'firstrun.setup.trustHeading' : 'firstrun.trust.heading', { title: model.title }), width);
     let path = wrapDisplay(model.project, width);
     let reason = wrapWords(model.reason, width);
     let summary = model.resourceSummary ? wrapWords(model.resourceSummary, width) : [];
@@ -209,7 +211,7 @@ export async function runProjectTrustPrompt(input, io = {}) {
     }
     const capabilities = detectTerminalCapabilities({ stdinIsTTY: true, stdoutIsTTY: true, color: input.color !== false, env });
     const session = createTerminalSessionPlan({ capabilities, env });
-    const theme = liveTheme(capabilities, input.theme ?? 'calm').theme;
+    const theme = liveTheme(capabilities, input.theme ?? DEFAULT_THEME_ACCENT).theme;
     const model = projectTrustPromptModel(input);
     const ids = model.choices.map(choice => choice.id);
     const sizeStore = createTerminalSizeStore(stdout, { rows: 24, columns: 80 });

package/dist/tui/session-controller.js

@@ -3,6 +3,7 @@ import { buildAgentTree } from "../runtime/agent-tree.js";
 import { createPermissionEngine } from "../security/permission-engine.js";
 import { createApprovalCoordinator, decisionFromChoice, decisionFromSource } from "./approval.js";
 import { createTuiEventAdapter, denialFromEngine, isolationOf } from "./event-adapter.js";
+import { createDescendantApprovals } from "./descendant-approvals.js";
 import { simulatePermission } from "../security/permission-explanation.js";
 import { KERNEL_RUN_TEXT } from "../i18n/kernel-map.js";
 import { permissionActionFromApproval } from "../security/from-approval.js";
@@ -33,6 +34,11 @@ export function createTuiSessionController({ runtime, projectRoot, model, mode,
         beforeDeny: (rid, decision) => { const target = denialTargets.get(rid); if (target)
             adapter.noteDenial(target.toolCallId, denialFromEngine(decision, { rule: () => simulatePermission({ rules, action: target.action, projectRoot }).explanation.rule ?? null })); } });
     const adapter = createTuiEventAdapter(secretValuesFromEnvironment(process.env));
+    /* P13: the approvals the current run's sub-agents ask for (descendant-approvals.ts), watched while that run is open. */
+    const descendants = createDescendantApprovals({ runtime, secretValues: secretValuesFromEnvironment(process.env),
+        onRequired: (origin, event) => requestApproval(origin.sessionId, event, origin),
+        onResolved: (_origin, requestId) => approvalResolved(requestId),
+        onError: error => developmentLogError('descendants.failure', error, { sessionId: current }, 'tui-controller') });
     let unsubscribe = () => { };
     let closed = false;
     let current = null;
@@ -143,10 +149,13 @@ export function createTuiSessionController({ runtime, projectRoot, model, mode,
             openRun = event.runId ? { runId: event.runId } : {};
             if (replayingHistory)
                 event = { ...event, history: true };
+            else
+                descendants.start(id);
         }
         else if (event.type === 'run.completed' || event.type === 'run.failed' || event.type === 'run.cancelled') {
             openRun = null;
             runEpoch++;
+            descendants.stop();
         }
         onEvent(event);
         bypassWhy(event);
@@ -161,14 +170,8 @@ export function createTuiSessionController({ runtime, projectRoot, model, mode,
             else
                 requestApproval(id, event);
         }
-        else if (event.type === 'approval.resolved') {
-            replayedApprovals.delete(event.requestId);
-            approvalTools.delete(event.requestId);
-            answeredApprovals.add(event.requestId);
-            if (answeredApprovals.size > 256)
-                answeredApprovals.delete(answeredApprovals.values().next().value);
-            onApproval?.(null);
-        }
+        else if (event.type === 'approval.resolved')
+            approvalResolved(event.requestId);
         else if (allowDrain && (event.type === 'run.completed' || event.type === 'run.failed') && !pendingSteer && !cancelling)
             requestQueuedDrain(id);
     }
@@ -214,7 +217,15 @@ export function createTuiSessionController({ runtime, projectRoot, model, mode,
     const replayedApprovals = new Map();
     const answeredApprovals = new Set();
     const approvalTools = new Map();
-    function requestApproval(id, event) {
+    function approvalResolved(requestId) {
+        replayedApprovals.delete(requestId);
+        approvalTools.delete(requestId);
+        answeredApprovals.add(requestId);
+        if (answeredApprovals.size > 256)
+            answeredApprovals.delete(answeredApprovals.values().next().value);
+        onApproval?.(null);
+    }
+    function requestApproval(id, event, origin) {
         const action = permissionActionFromApproval(event.payload);
         const epoch = runEpoch;
         answeredApprovals.delete(event.requestId);
@@ -222,12 +233,12 @@ export function createTuiSessionController({ runtime, projectRoot, model, mode,
             denialTargets.set(event.requestId, { toolCallId: event.toolCallId, action });
         void coordinator.request(id, event.requestId, action).finally(() => denialTargets.delete(event.requestId)).then(result => {
             if (result.pending) {
-                if (answeredApprovals.has(event.requestId) || epoch !== runEpoch || current !== id)
+                if (answeredApprovals.has(event.requestId) || epoch !== runEpoch || (origin ? !descendants.watching().includes(id) : current !== id))
                     return;
                 if (event.toolCallId)
                     approvalTools.set(event.requestId, event.toolCallId);
                 const runtimeHint = event.payload.trifecta === true ? 'trifecta' : undefined;
-                onApproval?.({ requestId: event.requestId, sessionId: id, action: result.action, rawPayload: event.payload, reason: result.reason, ...(result.rule ? { rule: result.rule } : {}), ...(runtimeHint ? { runtimeHint } : {}), ...explainApproval({ rules, action: result.action, projectRoot, persists: Boolean(paths) }) });
+                onApproval?.({ requestId: event.requestId, sessionId: id, ...(origin ? { origin: { kind: 'agent', task: origin.task } } : {}), action: result.action, rawPayload: event.payload, reason: result.reason, ...(result.rule ? { rule: result.rule } : {}), ...(runtimeHint ? { runtimeHint } : {}), ...explainApproval({ rules, action: result.action, projectRoot, persists: Boolean(paths) }) });
             }
             else {
                 /* R3 gate E4 (Q-R3-3): why the engine let it run, on the tool's row. */
@@ -524,6 +535,7 @@ export function createTuiSessionController({ runtime, projectRoot, model, mode,
     let openRun = null;
     function attach(id, from = 0, history = false) {
         unsubscribe();
+        descendants.stop();
         adapter.bindSession(id);
         current = id;
         openRun = null;
@@ -564,6 +576,7 @@ export function createTuiSessionController({ runtime, projectRoot, model, mode,
         if (current === id && openRun === open && outcome === 'running') {
             for (const event of waiting)
                 requestApproval(id, event);
+            descendants.start(id);
             return;
         }
         if (current !== id || openRun !== open || typeof outcome !== 'string' || outcome === 'running' || outcome === 'unknown')
@@ -774,5 +787,5 @@ export function createTuiSessionController({ runtime, projectRoot, model, mode,
         finally {
             cancelling = false;
         } }, close() { if (closed)
-            return; closed = true; developmentLog('controller.close', { sessionId: current, queueCount: queuedEntries.length }, 'info', 'tui-controller'); unsubscribe(); } };
+            return; closed = true; developmentLog('controller.close', { sessionId: current, queueCount: queuedEntries.length }, 'info', 'tui-controller'); descendants.stop(); unsubscribe(); } };
 }

package/dist/tui/setup-wizard.js

@@ -0,0 +1,46 @@
+/*
+ * P17 (owner, 2026-09-25: "mini procedura guidata semplicissima al fresh install"; decisions of 2026-09-26). The first launch
+ * chains the windows that already exist: trust (the screen before anything loads) → provider → key or local engine → model,
+ * one window at a time with "Step N of 4"; Enter goes on, Esc skips the step, Ctrl+C quits, and what was done stays saved.
+ * Only the missing steps run: a key already usable (from the environment too) or a local engine that answers skips them; a
+ * credential that exists but is benched is explained by the first frame's line, not asked again (Hermes #113720).
+ * Read on 2026-09-26: Claude Code (welcome, theme, login, security notes, terminal setup, trust), Codex (welcome, auth,
+ * trust), Hermes (provider + model through the same picker as `hermes model`, skippable, `hermes setup` to redo), Pi (theme
+ * and analytics, providers later), OpenCode (no wizard), Gemini CLI (theme, then auth). `/setup` redoes it (Hermes'
+ * `hermes setup`). Without an interactive terminal it never runs (clig.dev: "never require a prompt").
+ */
+import { t } from "../i18n/index.js";
+export const SETUP_TOTAL = 4;
+const INDEX = { trust: 1, provider: 2, key: 3, model: 4 };
+const NAME = { trust: 'firstrun.setup.stepName.trust', provider: 'firstrun.setup.stepName.provider', key: 'firstrun.setup.stepName.key', model: 'firstrun.setup.stepName.model' };
+/** The line that tells where the person is in the setup; `escSkips:false` when Esc does something else there. */
+export function setupStepLine(step, { escSkips = true } = {}) {
+    return t(escSkips ? 'firstrun.setup.stepLine' : 'firstrun.setup.stepLineOnly', { index: INDEX[step], total: SETUP_TOTAL, name: t(NAME[step]) });
+}
+/** The same window, with the setup's step on top (the window's own title stays under it). */
+export function setupOverlay(content, step, options = {}) {
+    return { ...content, head: [{ text: setupStepLine(step, options), tone: 'title' }, ...(content.head ?? [])] };
+}
+/**
+ * Whether the first launch runs the setup, and from which step. `providerUsable`: the chosen provider has a key usable now
+ * (from the environment too) or needs none; `keyBenched`: it has a key that does not work now (explained, not asked again).
+ */
+export function setupStart(input) {
+    if (!input.firstLaunch)
+        return { start: false };
+    if (!input.providerChosen)
+        return { start: true, from: 'provider' };
+    if (input.keyBenched)
+        return { start: false };
+    if (!input.providerUsable)
+        return { start: true, from: 'key' };
+    if (!input.modelChosen)
+        return { start: true, from: 'model' };
+    return { start: false };
+}
+/** What the setup says when it ends: ready with the model, or where to pick it up again. */
+export function setupEndLines(outcome) {
+    if (!outcome.ready)
+        return [t('firstrun.setup.skipped')];
+    return [t('firstrun.setup.ready', { model: outcome.model }), t('firstrun.setup.readyHints')];
+}

package/dist/tui/slash-commands.js

@@ -2,6 +2,8 @@ import { t } from "../i18n/index.js";
 const SLASH_COMMAND_META = [
     { name: 'help', usage: '' },
     { name: 'provider', usage: '' },
+    /* P17 (owner decision 4): the first launch's guided setup, again. */
+    { name: 'setup', usage: '' },
     { name: 'model', usage: '[provider:model]' },
     /* R5a (owner 2026-09-24): the reasoning effort of the current model, as a line of nodes. */
     { name: 'effort', usage: '[level]' },
@@ -55,7 +57,7 @@ export const SLASH_COMMANDS = SLASH_COMMAND_META.map(row => ({
 const SLASH_GROUPS = ['session', 'turn', 'view', 'work', 'extensions'];
 const GROUP_OF = {
     resume: 'session', fork: 'session', rename: 'session', export: 'session', undo: 'session', history: 'session', clear: 'session', compact: 'session', exit: 'session',
-    provider: 'turn', model: 'turn', effort: 'turn', busy: 'turn', queue: 'turn', retry: 'turn', plan: 'turn', permissions: 'turn',
+    provider: 'turn', setup: 'turn', model: 'turn', effort: 'turn', busy: 'turn', queue: 'turn', retry: 'turn', plan: 'turn', permissions: 'turn',
     help: 'view', status: 'view', context: 'view', usage: 'view', diff: 'view', copy: 'view', theme: 'view', redraw: 'view',
     memory: 'work', notes: 'work', tasks: 'work', library: 'work', research: 'work', automations: 'work', forge: 'work',
     mcp: 'extensions', hooks: 'extensions', plugins: 'extensions', doctor: 'extensions',

package/dist/tui/theme-catalog.js

@@ -6,7 +6,9 @@ export function mixHex(a, amount, b) {
     return `#${x.map((v, i) => Math.round(v * t + y[i] * (1 - t)).toString(16).padStart(2, '0')).join('')}`;
 }
 const theme = (id, label, accent, background) => ({ id, label, accent, background, muted: mixHex(accent, 62, background) });
-export const DEFAULT_THEME_ACCENT = 'calm';
+/* P15 (owner, 2026-09-25, "vorrei mettere forge come tema principale di default"): Forge is the default from 0.2.0. A theme
+   the person chose stays theirs (it is in their configuration); the legacy migrations keep mapping to what they mapped to. */
+export const DEFAULT_THEME_ACCENT = 'forge';
 export const TALOS_THEME_ACCENTS = Object.freeze([
     theme('calm', 'Calm', '#c08b3c', '#1e1f22'),
     theme('forge', 'Forge', '#c98b32', '#080b11'),

package/dist/version.js

@@ -1,2 +1,2 @@
-export const CLI_VERSION = '0.1.0';
+export const CLI_VERSION = '0.2.1';
 export const TALOS_BASE_COMMIT = '0c432153a288f64237e98403869d02d20d8fabc7';

package/dist/workspace/checkpoint-store.js

@@ -60,6 +60,24 @@ function parseRecord(text, expectedRoot) {
         throw coded('CHECKPOINT_STORE_INVALID');
     return value;
 }
+const STAT_INDEX_SCHEMA = 'talos.cli.checkpoint-stat-index.v1';
+async function loadStatIndex(indexPath) {
+    const rows = new Map();
+    try {
+        const value = JSON.parse(await readFile(indexPath, 'utf8'));
+        if (value?.schema !== STAT_INDEX_SCHEMA || !Array.isArray(value.rows))
+            return rows;
+        for (const row of value.rows) {
+            if (!Array.isArray(row) || row.length !== 6)
+                continue;
+            const [p, size, mtimeMs, ctimeMs, ref, verifiedAtMs] = row;
+            if (typeof p === 'string' && typeof ref === 'string' && /^[0-9a-f]{64}$/u.test(ref) && [size, mtimeMs, ctimeMs, verifiedAtMs].every(n => typeof n === 'number' && Number.isFinite(n)))
+                rows.set(p, { size, mtimeMs, ctimeMs, ref, verifiedAtMs });
+        }
+    }
+    catch { /* missing or torn: an empty index, every file is read again */ }
+    return rows;
+}
 function dedupeEvidence(rows) { const byKey = new Map(); for (const row of rows)
     byKey.set(`${row.path}\0${row.beforeHash ?? ''}\0${row.afterHash ?? ''}`, row); return [...byKey.values()]; }
 export function createCheckpointStore({ rootDir, projectRoot, limits = CHECKPOINT_LIMITS }) {
@@ -85,7 +103,20 @@ export function createCheckpointStore({ rootDir, projectRoot, limits = CHECKPOIN
     } }
     async function replace(record) { const x = await init(); if (record.canonicalRoot !== x.canonicalRoot)
         throw coded('CHECKPOINT_WORKSPACE_MISMATCH'); await atomicWrite(await recordPath(record.id), `${JSON.stringify(record)}\n`); }
-    async function capture() { const x = await init(); return captureWorkspaceSnapshot({ projectRoot: x.canonicalRoot, blobRoot, limits }); }
+    /* P18: the stat index of the last capture (checkpoint.ts StatCache), kept in memory and in the workspace's folder so a new
+       `talos -p` process starts from it too. It is only a cache: unreadable means empty (every file read again), and a
+       failed save costs speed on the next turn, never a checkpoint. */
+    let statRows = null;
+    async function capture() {
+        const x = await init();
+        const indexPath = path.join(x.workspaceDir, 'stat-index.json');
+        statRows ??= await loadStatIndex(indexPath);
+        const next = new Map();
+        const snapshot = await captureWorkspaceSnapshot({ projectRoot: x.canonicalRoot, blobRoot, limits, statCache: { previous: statRows, next } });
+        statRows = next;
+        await atomicWrite(indexPath, `${JSON.stringify({ schema: STAT_INDEX_SCHEMA, rows: [...next].map(([p, r]) => [p, r.size, r.mtimeMs, r.ctimeMs, r.ref, r.verifiedAtMs]) })}\n`).catch(() => { });
+        return snapshot;
+    }
     async function list() { const x = await init(); let names = []; try {
         names = await readdir(x.recordsDir);
     }