cvc-tui 0.4.3 → 0.4.5

package/dist/app/slash/commands/session.js

@@ -0,0 +1,431 @@
+// @ts-nocheck
+// SPDX-License-Identifier: MIT
+// Ported from CVC Agent (https://github.com/NousResearch/cvc)
+// Original Copyright (c) 2025 Nous Research. CVC adaptations (c) 2026 Jai Kumar Meena.
+import { attachedImageNotice, introMsg, toTranscriptMessages } from '../../../domain/messages.js';
+import { TUI_SESSION_MODEL_FLAG } from '../../../domain/slash.js';
+import { formatVoiceRecordKey, parseVoiceRecordKey } from '../../../lib/platform.js';
+import { fmtK } from '../../../lib/text.js';
+import { DEFAULT_INDICATOR_STYLE, INDICATOR_STYLES } from '../../interfaces.js';
+import { patchOverlayState } from '../../overlayStore.js';
+import { patchUiState } from '../../uiStore.js';
+const TUI_SESSION_MODEL_RE = new RegExp(`(?:^|\\s)${TUI_SESSION_MODEL_FLAG}(?:\\s|$)`);
+const TUI_SESSION_STRIP_RE = new RegExp(`\\s*${TUI_SESSION_MODEL_FLAG}\\b\\s*`, 'g');
+const stripTuiSessionFlag = (trimmed) => trimmed.replace(TUI_SESSION_STRIP_RE, ' ').replace(/\s+/g, ' ').trim();
+const modelValueForConfigSet = (arg) => {
+    const trimmed = arg.trim();
+    if (!trimmed) {
+        return trimmed;
+    }
+    if (TUI_SESSION_MODEL_RE.test(trimmed)) {
+        return stripTuiSessionFlag(trimmed);
+    }
+    return trimmed;
+};
+export const sessionCommands = [
+    {
+        aliases: ['bg', 'btw'],
+        help: 'launch a background prompt',
+        name: 'background',
+        run: (arg, ctx) => {
+            if (!arg) {
+                return ctx.transcript.sys('/background <prompt>');
+            }
+            ctx.gateway.rpc('prompt.background', { session_id: ctx.sid, text: arg }).then(ctx.guarded(r => {
+                if (!r.task_id) {
+                    return;
+                }
+                patchUiState(state => ({ ...state, bgTasks: new Set(state.bgTasks).add(r.task_id) }));
+                ctx.transcript.sys(`bg ${r.task_id} started`);
+            }));
+        }
+    },
+    {
+        help: 'change or show model',
+        name: 'model',
+        run: (arg, ctx) => {
+            if (ctx.session.guardBusySessionSwitch('change models')) {
+                return;
+            }
+            if (!arg.trim()) {
+                return patchOverlayState({ modelPicker: true });
+            }
+            ctx.gateway
+                .rpc('config.set', { key: 'model', session_id: ctx.sid, value: modelValueForConfigSet(arg) })
+                .then(ctx.guarded(r => {
+                if (!r.value) {
+                    return ctx.transcript.sys('error: invalid response: model switch');
+                }
+                ctx.transcript.sys(`model → ${r.value}`);
+                ctx.local.maybeWarn(r);
+                patchUiState(state => ({
+                    ...state,
+                    info: state.info ? { ...state.info, model: r.value } : { model: r.value, skills: {}, tools: {} }
+                }));
+            }));
+        }
+    },
+    {
+        help: 'browse and resume previous sessions',
+        name: 'sessions',
+        run: (arg, ctx) => {
+            if (ctx.session.guardBusySessionSwitch('switch sessions')) {
+                return;
+            }
+            if (!arg.trim()) {
+                return patchOverlayState({ picker: true });
+            }
+        }
+    },
+    {
+        help: 'attach an image',
+        name: 'image',
+        run: (arg, ctx) => {
+            ctx.gateway.rpc('image.attach', { path: arg, session_id: ctx.sid }).then(ctx.guarded(r => {
+                ctx.transcript.sys(attachedImageNotice(r));
+                if (r.remainder) {
+                    ctx.composer.setInput(r.remainder);
+                }
+            }));
+        }
+    },
+    {
+        help: 'switch personality for this session',
+        name: 'personality',
+        run: (arg, ctx) => {
+            if (!arg) {
+                return;
+            }
+            ctx.gateway.rpc('config.set', { key: 'personality', session_id: ctx.sid, value: arg }).then(ctx.guarded(r => {
+                if (r.history_reset) {
+                    ctx.session.resetVisibleHistory(r.info ?? null);
+                }
+                ctx.transcript.sys(`personality: ${r.value || 'default'}${r.history_reset ? ' · transcript cleared' : ''}`);
+                ctx.local.maybeWarn(r);
+            }));
+        }
+    },
+    {
+        help: 'compress transcript',
+        name: 'compress',
+        run: (arg, ctx) => {
+            ctx.gateway
+                .rpc('session.compress', {
+                session_id: ctx.sid,
+                ...(arg ? { focus_topic: arg } : {})
+            })
+                .then(ctx.guarded(r => {
+                if (Array.isArray(r.messages)) {
+                    const rows = toTranscriptMessages(r.messages);
+                    ctx.transcript.setHistoryItems(r.info ? [introMsg(r.info), ...rows] : rows);
+                }
+                if (r.info) {
+                    patchUiState({ info: r.info });
+                }
+                if (r.usage) {
+                    patchUiState(state => ({ ...state, usage: { ...state.usage, ...r.usage } }));
+                }
+                if (r.summary?.headline) {
+                    const prefix = r.summary.noop ? '' : '✓ ';
+                    ctx.transcript.sys(`${prefix}${r.summary.headline}`);
+                    if (r.summary.token_line) {
+                        ctx.transcript.sys(`  ${r.summary.token_line}`);
+                    }
+                    if (r.summary.note) {
+                        ctx.transcript.sys(`  ${r.summary.note}`);
+                    }
+                    return;
+                }
+                if ((r.removed ?? 0) <= 0) {
+                    return ctx.transcript.sys('nothing to compress');
+                }
+                ctx.transcript.sys(`compressed ${r.removed} messages${r.usage?.total ? ` · ${fmtK(r.usage.total)} tok` : ''}`);
+            }))
+                .catch(ctx.guardedErr);
+        }
+    },
+    {
+        aliases: ['fork'],
+        help: 'branch the session',
+        name: 'branch',
+        run: (arg, ctx) => {
+            const prevSid = ctx.sid;
+            ctx.gateway.rpc('session.branch', { name: arg, session_id: ctx.sid }).then(ctx.guarded(r => {
+                if (!r.session_id) {
+                    return;
+                }
+                void ctx.session.closeSession(prevSid);
+                patchUiState({ sid: r.session_id });
+                ctx.session.setSessionStartedAt(Date.now());
+                ctx.transcript.setHistoryItems([]);
+                ctx.transcript.sys(`branched → ${r.title ?? ''}`);
+            }));
+        }
+    },
+    {
+        help: 'voice mode: [on|off|tts|status]',
+        name: 'voice',
+        run: (arg, ctx) => {
+            const normalized = (arg ?? '').trim().toLowerCase();
+            const action = normalized === 'on' || normalized === 'off' || normalized === 'tts' || normalized === 'status'
+                ? normalized
+                : 'status';
+            ctx.gateway.rpc('voice.toggle', { action }).then(ctx.guarded(r => {
+                ctx.voice.setVoiceEnabled(!!r.enabled);
+                // Render the configured record key (config.yaml ``voice.record_key``)
+                // instead of hardcoded "Ctrl+B" — the gateway response carries the
+                // current value so /voice status and /voice on stay in sync with
+                // both the CLI and the TUI's actual binding (#18994).
+                //
+                // Copilot review on #19835 caught that rendering from the fresh
+                // backend response WITHOUT updating the frontend ``voice.recordKey``
+                // state would skew display and binding between config-edit and
+                // the next ``mtime`` poll (~5s). Parse once, push into state so
+                // ``useInputHandlers()`` picks up the new binding immediately.
+                //
+                // Round-2 follow-up: only push state when the response actually
+                // carries ``record_key`` — otherwise an older gateway (or a future
+                // branch that forgets to include it) would clobber a custom user
+                // binding back to the default on every /voice invocation. The
+                // label still falls back to the documented default for display.
+                const parsed = r.record_key ? parseVoiceRecordKey(r.record_key) : undefined;
+                if (parsed) {
+                    ctx.voice.setVoiceRecordKey(parsed);
+                }
+                const recordKeyLabel = formatVoiceRecordKey(parsed ?? parseVoiceRecordKey('ctrl+b'));
+                // Match CLI's _show_voice_status / _enable_voice_mode /
+                // _toggle_voice_tts output shape so users don't have to learn
+                // two vocabularies.
+                if (action === 'status') {
+                    const mode = r.enabled ? 'ON' : 'OFF';
+                    const tts = r.tts ? 'ON' : 'OFF';
+                    ctx.transcript.sys('Voice Mode Status');
+                    ctx.transcript.sys(`  Mode:       ${mode}`);
+                    ctx.transcript.sys(`  TTS:        ${tts}`);
+                    ctx.transcript.sys(`  Record key: ${recordKeyLabel}`);
+                    // CLI's "Requirements:" block — surfaces STT/audio setup issues
+                    // so the user sees "STT provider: MISSING ..." instead of
+                    // silently failing on every record-key press.
+                    if (r.details) {
+                        ctx.transcript.sys('');
+                        ctx.transcript.sys('  Requirements:');
+                        for (const line of r.details.split('\n')) {
+                            if (line.trim()) {
+                                ctx.transcript.sys(`    ${line}`);
+                            }
+                        }
+                    }
+                    return;
+                }
+                if (action === 'tts') {
+                    ctx.transcript.sys(`Voice TTS ${r.tts ? 'enabled' : 'disabled'}.`);
+                    return;
+                }
+                // on/off — mirror cli.py:_enable_voice_mode's 3-line output
+                if (r.enabled) {
+                    const tts = r.tts ? ' (TTS enabled)' : '';
+                    ctx.transcript.sys(`Voice mode enabled${tts}`);
+                    ctx.transcript.sys(`  ${recordKeyLabel} to start/stop recording`);
+                    ctx.transcript.sys('  /voice tts  to toggle speech output');
+                    ctx.transcript.sys('  /voice off  to disable voice mode');
+                }
+                else {
+                    ctx.transcript.sys('Voice mode disabled.');
+                }
+            }));
+        }
+    },
+    {
+        help: 'switch theme skin (fires skin.changed)',
+        name: 'skin',
+        run: (arg, ctx) => {
+            if (!arg) {
+                return ctx.gateway
+                    .rpc('config.get', { key: 'skin' })
+                    .then(ctx.guarded(r => ctx.transcript.sys(`skin: ${r.value || 'default'}`)));
+            }
+            ctx.gateway
+                .rpc('config.set', { key: 'skin', value: arg })
+                .then(ctx.guarded(r => r.value && ctx.transcript.sys(`skin → ${r.value}`)));
+        }
+    },
+    {
+        help: 'pick the busy indicator: kaomoji (default), emoji, unicode (braille), or ascii',
+        name: 'indicator',
+        usage: `/indicator [${INDICATOR_STYLES.join('|')}]`,
+        run: (arg, ctx) => {
+            const value = arg.trim().toLowerCase();
+            if (!value) {
+                return ctx.gateway
+                    .rpc('config.get', { key: 'indicator' })
+                    .then(ctx.guarded(r => ctx.transcript.sys(`indicator: ${r.value || DEFAULT_INDICATOR_STYLE}`)));
+            }
+            if (!INDICATOR_STYLES.includes(value)) {
+                return ctx.transcript.sys(`usage: /indicator [${INDICATOR_STYLES.join('|')}]`);
+            }
+            ctx.gateway.rpc('config.set', { key: 'indicator', value }).then(ctx.guarded(r => {
+                if (!r.value) {
+                    return;
+                }
+                // Hot-swap the running TUI immediately so the next render
+                // uses the new style without waiting for the 5s mtime poll
+                // to re-apply config.full.
+                patchUiState({ indicatorStyle: value });
+                ctx.transcript.sys(`indicator → ${r.value}`);
+            }));
+        }
+    },
+    {
+        help: 'toggle yolo mode (per-session approvals)',
+        name: 'yolo',
+        run: (_arg, ctx) => {
+            ctx.gateway
+                .rpc('config.set', { key: 'yolo', session_id: ctx.sid })
+                .then(ctx.guarded(r => ctx.transcript.sys(`yolo ${r.value === '1' ? 'on' : 'off'}`)));
+        }
+    },
+    {
+        help: 'inspect or set reasoning effort (updates live agent)',
+        name: 'reasoning',
+        run: (arg, ctx) => {
+            if (!arg) {
+                return ctx.gateway
+                    .rpc('config.get', { key: 'reasoning' })
+                    .then(ctx.guarded(r => r.value && ctx.transcript.sys(`reasoning: ${r.value} · display ${r.display || 'hide'}`)));
+            }
+            ctx.gateway
+                .rpc('config.set', { key: 'reasoning', session_id: ctx.sid, value: arg })
+                .then(ctx.guarded(r => {
+                if (!r.value) {
+                    return;
+                }
+                if (r.value === 'hide') {
+                    patchUiState(state => ({
+                        ...state,
+                        sections: { ...state.sections, thinking: 'hidden' },
+                        showReasoning: false
+                    }));
+                }
+                else if (r.value === 'show') {
+                    patchUiState(state => ({
+                        ...state,
+                        sections: { ...state.sections, thinking: 'expanded' },
+                        showReasoning: true
+                    }));
+                }
+                ctx.transcript.sys(`reasoning: ${r.value}`);
+            }));
+        }
+    },
+    {
+        help: 'toggle fast mode [normal|fast|status|on|off|toggle]',
+        name: 'fast',
+        run: (arg, ctx) => {
+            const mode = arg.trim().toLowerCase();
+            const valid = new Set(['', 'status', 'normal', 'fast', 'on', 'off', 'toggle']);
+            if (!valid.has(mode)) {
+                return ctx.transcript.sys('usage: /fast [normal|fast|status|on|off|toggle]');
+            }
+            if (!mode || mode === 'status') {
+                return ctx.gateway
+                    .rpc('config.get', { key: 'fast', session_id: ctx.sid })
+                    .then(ctx.guarded(r => ctx.transcript.sys(`fast mode: ${r.value === 'fast' ? 'fast' : 'normal'}`)))
+                    .catch(ctx.guardedErr);
+            }
+            ctx.gateway
+                .rpc('config.set', { key: 'fast', session_id: ctx.sid, value: mode })
+                .then(ctx.guarded(r => {
+                const next = r.value === 'fast' ? 'fast' : 'normal';
+                ctx.transcript.sys(`fast mode: ${next}`);
+                patchUiState(state => ({
+                    ...state,
+                    info: state.info
+                        ? {
+                            ...state.info,
+                            fast: next === 'fast',
+                            service_tier: next === 'fast' ? 'priority' : ''
+                        }
+                        : state.info
+                }));
+            }))
+                .catch(ctx.guardedErr);
+        }
+    },
+    {
+        help: 'control busy enter mode [queue|steer|interrupt|status]',
+        name: 'busy',
+        run: (arg, ctx) => {
+            const mode = arg.trim().toLowerCase();
+            const valid = new Set(['', 'status', 'queue', 'steer', 'interrupt']);
+            if (!valid.has(mode)) {
+                return ctx.transcript.sys('usage: /busy [queue|steer|interrupt|status]');
+            }
+            if (!mode || mode === 'status') {
+                return ctx.gateway
+                    .rpc('config.get', { key: 'busy' })
+                    .then(ctx.guarded(r => {
+                    const current = r.value || 'interrupt';
+                    ctx.transcript.sys(`busy input mode: ${current}`);
+                }))
+                    .catch(ctx.guardedErr);
+            }
+            ctx.gateway
+                .rpc('config.set', { key: 'busy', value: mode })
+                .then(ctx.guarded(r => {
+                const next = r.value || mode;
+                ctx.transcript.sys(`busy input mode: ${next}`);
+            }))
+                .catch(ctx.guardedErr);
+        }
+    },
+    {
+        help: 'cycle verbose tool-output mode (updates live agent)',
+        name: 'verbose',
+        run: (arg, ctx) => {
+            ctx.gateway
+                .rpc('config.set', { key: 'verbose', session_id: ctx.sid, value: arg || 'cycle' })
+                .then(ctx.guarded(r => r.value && ctx.transcript.sys(`verbose: ${r.value}`)));
+        }
+    },
+    {
+        help: 'session usage (live counts — worker sees zeros)',
+        name: 'usage',
+        run: (_arg, ctx) => {
+            ctx.gateway.rpc('session.usage', { session_id: ctx.sid }).then(r => {
+                if (ctx.stale()) {
+                    return;
+                }
+                if (r) {
+                    patchUiState({
+                        usage: { calls: r.calls ?? 0, input: r.input ?? 0, output: r.output ?? 0, total: r.total ?? 0 }
+                    });
+                }
+                if (!r?.calls) {
+                    return ctx.transcript.sys('no API calls yet');
+                }
+                const f = (v) => (v ?? 0).toLocaleString();
+                const cost = r.cost_usd != null ? `${r.cost_status === 'estimated' ? '~' : ''}$${r.cost_usd.toFixed(4)}` : null;
+                const rows = [
+                    ['Model', r.model ?? ''],
+                    ['Input tokens', f(r.input)],
+                    ['Cache read tokens', f(r.cache_read)],
+                    ['Cache write tokens', f(r.cache_write)],
+                    ['Output tokens', f(r.output)],
+                    ['Total tokens', f(r.total)],
+                    ['API calls', f(r.calls)]
+                ];
+                if (cost) {
+                    rows.push(['Cost', cost]);
+                }
+                const sections = [{ rows }];
+                if (r.context_max) {
+                    sections.push({ text: `Context: ${f(r.context_used)} / ${f(r.context_max)} (${r.context_percent}%)` });
+                }
+                if (r.compressions) {
+                    sections.push({ text: `Compressions: ${r.compressions}` });
+                }
+                ctx.transcript.panel('Usage', sections);
+            });
+        }
+    }
+];

package/dist/app/slash/commands/setup.js

@@ -0,0 +1,20 @@
+// @ts-nocheck
+// SPDX-License-Identifier: MIT
+// Ported from CVC Agent (https://github.com/NousResearch/cvc)
+// Original Copyright (c) 2025 Nous Research. CVC adaptations (c) 2026 Jai Kumar Meena.
+import { withInkSuspended } from '../../../vendor/cvc-ink/index.js';
+import { launchHermesCommand } from '../../../lib/externalCli.js';
+import { runExternalSetup } from '../../setupHandoff.js';
+export const setupCommands = [
+    {
+        help: 'run full setup wizard (launches `hermes setup`)',
+        name: 'setup',
+        run: (arg, ctx) => void runExternalSetup({
+            args: ['setup', ...arg.split(/\s+/).filter(Boolean)],
+            ctx,
+            done: 'setup complete — starting session…',
+            launcher: launchHermesCommand,
+            suspend: withInkSuspended
+        })
+    }
+];

package/dist/app/slash/commands/toggles.js

@@ -0,0 +1,40 @@
+// @ts-nocheck
+// SPDX-License-Identifier: MIT
+// Ported from CVC Agent (https://github.com/NousResearch/cvc)
+// Original Copyright (c) 2025 Nous Research. CVC adaptations (c) 2026 Jai Kumar Meena.
+// Trivial toggle-style commands — boolean UI flags routed through patchUi
+// + a config.set RPC so the gateway can persist them.
+import { flagFromArg } from '../types.js';
+const TOGGLES = [
+    { name: 'verbose', help: 'toggle verbose logging', key: 'verbose' },
+    { name: 'reasoning', help: 'toggle reasoning trace display', key: 'reasoning' },
+    { name: 'fast', help: 'toggle fast mode (skip extras)', key: 'fast' },
+    { name: 'yolo', help: 'toggle YOLO mode (auto-approve)', key: 'yolo' },
+    { name: 'busy', help: 'toggle busy indicator', key: 'busy' },
+    { name: 'queue', help: 'toggle queued-input mode', key: 'queue' },
+    { name: 'background', help: 'toggle background-task display', key: 'background' },
+    { name: 'browser', help: 'toggle browser tool', key: 'browserEnabled', aliases: ['br'] },
+    { name: 'voice', help: 'toggle voice input/output', key: 'voice' },
+    { name: 'image', help: 'toggle inline image rendering', key: 'image' },
+];
+export const toggleCommands = TOGGLES.map(t => ({
+    name: t.name,
+    aliases: t.aliases,
+    category: 'toggles',
+    help: t.help,
+    run: (arg, ctx) => {
+        const cur = Boolean(ctx.ui[t.key]);
+        const next = flagFromArg(arg, cur);
+        if (next === null) {
+            ctx.emit({ kind: 'sys', text: `usage: /${t.name} [on|off|toggle]` });
+            return;
+        }
+        ctx.emit({ kind: 'patchUi', ui: { [t.key]: next } });
+        ctx.emit({
+            kind: 'rpc',
+            method: 'config.set',
+            params: { key: t.configKey ?? t.name, value: next ? 'on' : 'off' },
+        });
+        ctx.emit({ kind: 'sys', text: `${t.name} ${next ? 'on' : 'off'}` });
+    },
+}));

package/dist/app/slash/registry.js

@@ -0,0 +1,18 @@
+// @ts-nocheck
+// SPDX-License-Identifier: MIT
+// Ported from CVC Agent (https://github.com/NousResearch/cvc)
+// Original Copyright (c) 2025 Nous Research. CVC adaptations (c) 2026 Jai Kumar Meena.
+import { coreCommands } from './commands/core.js';
+import { debugCommands } from './commands/debug.js';
+import { opsCommands } from './commands/ops.js';
+import { sessionCommands } from './commands/session.js';
+import { setupCommands } from './commands/setup.js';
+export const SLASH_COMMANDS = [
+    ...coreCommands,
+    ...sessionCommands,
+    ...opsCommands,
+    ...setupCommands,
+    ...debugCommands
+];
+const byName = new Map(SLASH_COMMANDS.flatMap(cmd => [cmd.name, ...(cmd.aliases ?? [])].map(name => [name, cmd])));
+export const findSlashCommand = (name) => byName.get(name.toLowerCase());

package/dist/app/slash/types.js

@@ -0,0 +1 @@
+export {};

package/dist/app/spawnHistoryStore.js

@@ -0,0 +1,105 @@
+// @ts-nocheck
+// SPDX-License-Identifier: MIT
+// Ported from CVC Agent (https://github.com/NousResearch/cvc)
+// Original Copyright (c) 2025 Nous Research. CVC adaptations (c) 2026 Jai Kumar Meena.
+import { atom } from 'nanostores';
+const HISTORY_LIMIT = 10;
+export const $spawnHistory = atom([]);
+export const $spawnDiff = atom(null);
+export const getSpawnHistory = () => $spawnHistory.get();
+export const getSpawnDiff = () => $spawnDiff.get();
+export const clearSpawnHistory = () => $spawnHistory.set([]);
+export const clearDiffPair = () => $spawnDiff.set(null);
+export const setDiffPair = (pair) => $spawnDiff.set(pair);
+/**
+ * Commit a finished turn's spawn tree to history.  Keeps the last 10
+ * non-empty snapshots — empty turns (no subagents) are dropped.
+ *
+ * Why in-memory?  The primary investigation loop is "I just ran a fan-out,
+ * it misbehaved, let me look at what happened" — same-session debugging.
+ * Disk persistence across process restarts is a natural extension but
+ * adds RPC surface for a less-common path.
+ */
+export const pushSnapshot = (subagents, meta) => {
+    if (!subagents.length) {
+        return;
+    }
+    const now = Date.now();
+    const started = meta.startedAt ?? Math.min(...subagents.map(s => s.startedAt ?? now));
+    const snap = {
+        finishedAt: now,
+        id: `snap-${now.toString(36)}`,
+        label: summarizeLabel(subagents),
+        sessionId: meta.sessionId ?? null,
+        startedAt: Number.isFinite(started) ? started : now,
+        subagents: subagents.map(item => ({ ...item }))
+    };
+    const next = [snap, ...$spawnHistory.get()].slice(0, HISTORY_LIMIT);
+    $spawnHistory.set(next);
+};
+function summarizeLabel(subagents) {
+    const top = subagents
+        .filter(s => s.parentId == null || subagents.every(o => o.id !== s.parentId))
+        .slice(0, 2)
+        .map(s => s.goal || 'subagent')
+        .join(' · ');
+    return top || `${subagents.length} agent${subagents.length === 1 ? '' : 's'}`;
+}
+/**
+ * Push a disk-loaded snapshot onto the front of the history stack so the
+ * overlay can pick it up at index 1 via /replay load.  Normalises the
+ * server payload (arbitrary list) into the same SubagentProgress shape
+ * used for live data — defensive against cross-version reads.
+ */
+export const pushDiskSnapshot = (r, path) => {
+    const raw = Array.isArray(r.subagents) ? r.subagents : [];
+    const normalised = raw.map(normaliseSubagent);
+    if (!normalised.length) {
+        return;
+    }
+    const snap = {
+        finishedAt: (r.finished_at ?? Date.now() / 1000) * 1000,
+        fromDisk: true,
+        id: `disk-${path}`,
+        label: r.label || `${normalised.length} subagents`,
+        path,
+        sessionId: r.session_id ?? null,
+        startedAt: (r.started_at ?? r.finished_at ?? Date.now() / 1000) * 1000,
+        subagents: normalised
+    };
+    const next = [snap, ...$spawnHistory.get()].slice(0, HISTORY_LIMIT);
+    $spawnHistory.set(next);
+};
+function normaliseSubagent(raw) {
+    const o = raw;
+    const s = (v) => (typeof v === 'string' ? v : undefined);
+    const n = (v) => (typeof v === 'number' ? v : undefined);
+    const arr = (v) => (Array.isArray(v) ? v : undefined);
+    return {
+        apiCalls: n(o.apiCalls),
+        costUsd: n(o.costUsd),
+        depth: typeof o.depth === 'number' ? o.depth : 0,
+        durationSeconds: n(o.durationSeconds),
+        filesRead: arr(o.filesRead),
+        filesWritten: arr(o.filesWritten),
+        goal: s(o.goal) ?? 'subagent',
+        id: s(o.id) ?? `sa-${Math.random().toString(36).slice(2, 8)}`,
+        index: typeof o.index === 'number' ? o.index : 0,
+        inputTokens: n(o.inputTokens),
+        iteration: n(o.iteration),
+        model: s(o.model),
+        notes: (arr(o.notes) ?? []).filter(x => typeof x === 'string'),
+        outputTail: arr(o.outputTail),
+        outputTokens: n(o.outputTokens),
+        parentId: s(o.parentId) ?? null,
+        reasoningTokens: n(o.reasoningTokens),
+        startedAt: n(o.startedAt),
+        status: s(o.status) ?? 'completed',
+        summary: s(o.summary),
+        taskCount: typeof o.taskCount === 'number' ? o.taskCount : 1,
+        thinking: (arr(o.thinking) ?? []).filter(x => typeof x === 'string'),
+        toolCount: typeof o.toolCount === 'number' ? o.toolCount : 0,
+        tools: (arr(o.tools) ?? []).filter(x => typeof x === 'string'),
+        toolsets: arr(o.toolsets)
+    };
+}