zoe-agent 0.3.1

package/dist/adapters/cli/tui/hooks/use-agent.js

@@ -0,0 +1,177 @@
+/**
+ * use-agent — agent run state for the TUI.
+ *
+ * Drives `Agent.chat(input, signal, approveTool, permissionLevel, onStep)`,
+ * which (in TUI mode) opts into token streaming — the loop emits `text_delta`
+ * steps as tokens arrive. Those accumulate into `streamingText` (rendered live
+ * in the message area, since Ink `<Static>` freezes completed entries); on a
+ * tool call or turn end the accumulated text is committed to the feed history.
+ * ESC/Ctrl+C calls `agent.abort()`.
+ *
+ * `approveTool` runs inside the detached `runAgentLoop` promise, so it must
+ * pause and wait for the user to press y/n in `<PermissionPrompt>`. This hook
+ * owns that bridge: it stores the pending resolver in a ref (stable across
+ * renders) and the pending prompt's view in state (so the component re-renders).
+ */
+import { useCallback, useRef, useState } from 'react';
+export function useAgent({ agent, feed, permissionLevel }) {
+    const [isRunning, setIsRunning] = useState(false);
+    const [pendingPermission, setPendingPermission] = useState(null);
+    const [streamingText, setStreamingText] = useState('');
+    const [streamingTool, setStreamingTool] = useState(null);
+    const [usage, setUsage] = useState({
+        totalPromptTokens: 0,
+        totalCompletionTokens: 0,
+        totalCost: 0,
+        requestCount: 0,
+    });
+    const [contextTokens, setContextTokens] = useState(0);
+    const [latestTodos, setLatestTodos] = useState(null);
+    // Refs hold the latest values so the stable callbacks never close over
+    // stale state (CLAUDE.md §6: long-lived callbacks read through refs).
+    const feedRef = useRef(feed);
+    feedRef.current = feed;
+    const permissionLevelRef = useRef(permissionLevel);
+    permissionLevelRef.current = permissionLevel;
+    const resolverRef = useRef(null);
+    const streamingTextRef = useRef('');
+    const streamingToolRef = useRef(null);
+    /** Commit accumulated streaming text to the feed history as an assistant entry. */
+    const commitStreaming = useCallback(() => {
+        if (streamingTextRef.current) {
+            feedRef.current.appendEntry({ kind: 'assistant', content: streamingTextRef.current });
+            streamingTextRef.current = '';
+            setStreamingText('');
+        }
+    }, []);
+    const submit = useCallback(async (input) => {
+        const trimmed = input.trim();
+        if (!trimmed)
+            return;
+        setIsRunning(true);
+        streamingTextRef.current = '';
+        setStreamingText('');
+        streamingToolRef.current = null;
+        setStreamingTool(null);
+        feedRef.current.appendEntry({ kind: 'user', content: trimmed });
+        // Resolve @path file references at the caller, not inside Agent.chat (T022).
+        let resolvedInput = trimmed;
+        if (trimmed.includes('@')) {
+            try {
+                const { resolveReferences } = await import('../../../../skills/resolver.js');
+                resolvedInput = await resolveReferences(trimmed);
+            }
+            catch { /* resolver not available — use raw input */ }
+        }
+        const signal = agent.createAbortSignal();
+        const approveTool = async (call) => {
+            setPendingPermission({ toolName: call.name, args: call.args });
+            const decision = await new Promise((resolve) => {
+                resolverRef.current = resolve;
+            });
+            resolverRef.current = null;
+            setPendingPermission(null);
+            return decision;
+        };
+        const onStep = (step) => {
+            if (step.type === 'text_delta' && step.content) {
+                streamingTextRef.current += step.content;
+                setStreamingText(streamingTextRef.current);
+            }
+            else if (step.type === 'text' && step.content != null) {
+                // Non-streaming fallback (defensive; stream mode emits text_delta).
+                commitStreaming();
+                feedRef.current.appendEntry({ kind: 'assistant', content: step.content });
+            }
+            else if (step.type === 'tool_progress' && step.content != null) {
+                // Live tool output (e.g. streaming shell stdout). Accumulate into a
+                // streamingTool block rendered outside <Static> so it repaints per chunk.
+                if (streamingToolRef.current) {
+                    streamingToolRef.current.output += step.content;
+                }
+                else {
+                    streamingToolRef.current = {
+                        name: step.name ?? 'tool',
+                        args: step.args ?? {},
+                        output: step.content,
+                    };
+                }
+                setStreamingTool(streamingToolRef.current ? { ...streamingToolRef.current } : null);
+            }
+            else if (step.type === 'tool_call' && step.toolCall) {
+                commitStreaming();
+                streamingToolRef.current = null;
+                setStreamingTool(null);
+                const tc = step.toolCall;
+                // manage_todos updates the persistent todo panel (not the feed).
+                if (tc.name === 'manage_todos') {
+                    try {
+                        const parsed = JSON.parse(tc.result);
+                        if (Array.isArray(parsed))
+                            setLatestTodos(parsed);
+                    }
+                    catch { /* ignore parse error */ }
+                    return;
+                }
+                feedRef.current.appendEntry({
+                    kind: 'tool',
+                    name: tc.name,
+                    args: tc.args,
+                    status: 'ok',
+                    output: tc.result,
+                    durationMs: tc.duration,
+                    metadata: step.metadata,
+                });
+            }
+        };
+        try {
+            const result = await agent.chat(resolvedInput, signal, approveTool, permissionLevelRef.current, onStep);
+            commitStreaming(); // commit the final assistant message if any
+            if (result.finishReason === 'error' && result.error) {
+                feedRef.current.appendEntry({ kind: 'error', message: result.error });
+            }
+            if (result.usage) {
+                setUsage((u) => ({
+                    totalPromptTokens: u.totalPromptTokens + (result.usage?.promptTokens ?? 0),
+                    totalCompletionTokens: u.totalCompletionTokens + (result.usage?.completionTokens ?? 0),
+                    totalCost: u.totalCost + (result.usage?.cost ?? 0),
+                    requestCount: u.requestCount + 1,
+                }));
+                setContextTokens(result.usage.promptTokens ?? 0);
+            }
+        }
+        catch (error) {
+            commitStreaming();
+            const message = error instanceof Error ? error.message : String(error);
+            feedRef.current.appendEntry({ kind: 'error', message });
+        }
+        finally {
+            // Unblock the loop if the agent was aborted mid-approval.
+            if (resolverRef.current) {
+                resolverRef.current(false);
+                resolverRef.current = null;
+            }
+            setPendingPermission(null);
+            setIsRunning(false);
+        }
+    }, [agent, commitStreaming]);
+    const resolvePermission = useCallback((approve) => {
+        const resolve = resolverRef.current;
+        if (resolve) {
+            resolverRef.current = null;
+            resolve(approve);
+        }
+    }, []);
+    const abort = useCallback(() => {
+        // A pending approval is resolved as a deny so the loop unblocks before abort.
+        if (resolverRef.current) {
+            resolverRef.current(false);
+            resolverRef.current = null;
+            setPendingPermission(null);
+        }
+        agent.abort();
+    }, [agent]);
+    const resetTodos = useCallback(() => setLatestTodos(null), []);
+    const restoreTodos = useCallback((todos) => setLatestTodos(todos), []);
+    return { isRunning, pendingPermission, streamingText, streamingTool, usage, contextTokens, latestTodos, submit, resolvePermission, abort, resetTodos, restoreTodos };
+}

package/dist/adapters/cli/tui/hooks/use-feed.d.ts

@@ -0,0 +1,16 @@
+/**
+ * use-feed — owns the feed array.
+ *
+ * Entries are appended immutably (so completed history can render via Ink's
+ * `<Static>` without re-rendering) and updated by id (streaming/permission
+ * state). `appendEntry` generates and returns the entry id so callers can
+ * patch the same entry later (e.g. resolve a permission prompt).
+ */
+import type { FeedEntry, FeedEntryInput } from '../types.js';
+export interface FeedApi {
+    entries: FeedEntry[];
+    appendEntry: (entry: FeedEntryInput) => string;
+    updateEntry: (id: string, patch: Partial<FeedEntry>) => void;
+    clear: () => void;
+}
+export declare function useFeed(): FeedApi;

package/dist/adapters/cli/tui/hooks/use-feed.js

@@ -0,0 +1,25 @@
+/**
+ * use-feed — owns the feed array.
+ *
+ * Entries are appended immutably (so completed history can render via Ink's
+ * `<Static>` without re-rendering) and updated by id (streaming/permission
+ * state). `appendEntry` generates and returns the entry id so callers can
+ * patch the same entry later (e.g. resolve a permission prompt).
+ */
+import { useCallback, useState } from 'react';
+import { generateId } from '../../../../core/message-convert.js';
+export function useFeed() {
+    const [entries, setEntries] = useState([]);
+    const appendEntry = useCallback((entry) => {
+        const id = generateId();
+        setEntries((prev) => [...prev, { ...entry, id }]);
+        return id;
+    }, []);
+    const updateEntry = useCallback((id, patch) => {
+        setEntries((prev) => prev.map((e) => (e.id === id ? { ...e, ...patch } : e)));
+    }, []);
+    const clear = useCallback(() => {
+        setEntries([]);
+    }, []);
+    return { entries, appendEntry, updateEntry, clear };
+}

package/dist/adapters/cli/tui/hooks/use-file-watcher.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Watches the project directory for external file changes (using built-in
+ * `fs.watch` with recursive mode — supported on macOS/Windows). Fires only
+ * when the agent is idle (not running) so the agent's own writes don't
+ * trigger false notifications. Debounced (fs.watch fires multiple events).
+ */
+export declare function useFileWatcher(idle: boolean): {
+    changedFile: string | null;
+    clear: () => void;
+};

package/dist/adapters/cli/tui/hooks/use-file-watcher.js

@@ -0,0 +1,43 @@
+import { useEffect, useState, useCallback } from 'react';
+import * as fs from 'fs';
+const IGNORED_DIRS = new Set(['node_modules', '.git', 'dist', 'build', 'out', 'coverage', '.cache']);
+/**
+ * Watches the project directory for external file changes (using built-in
+ * `fs.watch` with recursive mode — supported on macOS/Windows). Fires only
+ * when the agent is idle (not running) so the agent's own writes don't
+ * trigger false notifications. Debounced (fs.watch fires multiple events).
+ */
+export function useFileWatcher(idle) {
+    const [changedFile, setChangedFile] = useState(null);
+    useEffect(() => {
+        if (!idle)
+            return; // only watch when idle (agent's writes suppressed)
+        let timer = null;
+        let watcher = null;
+        try {
+            watcher = fs.watch(process.cwd(), { recursive: true }, (_eventType, filename) => {
+                if (!filename)
+                    return;
+                const parts = filename.split(/[/\\]/);
+                if (parts.some((p) => IGNORED_DIRS.has(p) || p.startsWith('.')))
+                    return;
+                if (timer)
+                    clearTimeout(timer);
+                timer = setTimeout(() => {
+                    setChangedFile(filename);
+                    timer = null;
+                }, 600);
+            });
+        }
+        catch {
+            // recursive watch not supported (Linux) — no-op.
+        }
+        return () => {
+            watcher?.close();
+            if (timer)
+                clearTimeout(timer);
+        };
+    }, [idle]);
+    const clear = useCallback(() => setChangedFile(null), []);
+    return { changedFile, clear };
+}

package/dist/adapters/cli/tui/hooks/use-keybindings.d.ts

@@ -0,0 +1,16 @@
+export interface KeybindingHandlers {
+    onAbort: () => void;
+    onExit: () => void;
+    onExpandToggle: () => void;
+    onPalette: () => void;
+    onClear: () => void;
+}
+/**
+ * Global keybindings. Disabled while a modal overlay is open (`enabled: false`)
+ * so the overlay owns input. Ctrl+C aborts mid-run or exits when idle.
+ * (Help is `/?`, not bare `?` — bare `?` would fire mid-question.)
+ */
+export declare function useKeybindings(handlers: KeybindingHandlers, opts: {
+    enabled: boolean;
+    isRunning: boolean;
+}): void;

package/dist/adapters/cli/tui/hooks/use-keybindings.js

@@ -0,0 +1,25 @@
+import { useInput } from 'ink';
+/**
+ * Global keybindings. Disabled while a modal overlay is open (`enabled: false`)
+ * so the overlay owns input. Ctrl+C aborts mid-run or exits when idle.
+ * (Help is `/?`, not bare `?` — bare `?` would fire mid-question.)
+ */
+export function useKeybindings(handlers, opts) {
+    useInput((input, key) => {
+        if (!opts.enabled)
+            return;
+        if (key.ctrl) {
+            if (input === 'o' || input === '\x0f')
+                handlers.onExpandToggle();
+            else if (input === 'p' || input === '\x10')
+                handlers.onPalette();
+            else if (input === 'l' || input === '\x0c')
+                handlers.onClear();
+            else if (input === 'c' || input === '\x03')
+                (opts.isRunning ? handlers.onAbort() : handlers.onExit());
+            return;
+        }
+        if (key.escape)
+            handlers.onAbort();
+    });
+}

package/dist/adapters/cli/tui/hooks/use-theme.d.ts

@@ -0,0 +1,8 @@
+import { type ReactNode } from 'react';
+import { type Theme } from '../theme.js';
+/** Provides the theme to all descendants. Wrap the TUI root once. */
+export declare function ThemeProvider({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** Access the active theme. Single source of color tokens in components. */
+export declare function useTheme(): Theme;

package/dist/adapters/cli/tui/hooks/use-theme.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from 'react';
+import { theme } from '../theme.js';
+const ThemeContext = createContext(theme);
+/** Provides the theme to all descendants. Wrap the TUI root once. */
+export function ThemeProvider({ children }) {
+    return _jsx(ThemeContext.Provider, { value: theme, children: children });
+}
+/** Access the active theme. Single source of color tokens in components. */
+export function useTheme() {
+    return useContext(ThemeContext);
+}

package/dist/adapters/cli/tui/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * TUI public entry — lazy-loaded by `src/adapters/cli/index.ts` only when
+ * `resolveLaunchMode(options) === 'interactive'`. Headless / piped / --docker
+ * modes never import this module, so React/Ink stay out of memory there.
+ *
+ * The `.tsx` extension is required (the file contains JSX); the lazy import
+ * specifier `./tui/index.js` resolves to this source under `tsx` dev mode and
+ * to the compiled `dist/adapters/cli/tui/index.js` under `tsc`.
+ */
+export interface StartTuiArgs {
+    queryParts: string[];
+    options: any;
+}
+/**
+ * Run the shared session setup (same bootstrap as the readline REPL), build the
+ * shared command registry, then render the full-screen Ink TUI. `exitOnCtrlC`
+ * is false so the app owns Ctrl+C (abort mid-run, exit when idle) per FR-006.
+ */
+export declare function startTui({ queryParts, options }: StartTuiArgs): Promise<void>;

package/dist/adapters/cli/tui/index.js

@@ -0,0 +1,206 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * TUI public entry — lazy-loaded by `src/adapters/cli/index.ts` only when
+ * `resolveLaunchMode(options) === 'interactive'`. Headless / piped / --docker
+ * modes never import this module, so React/Ink stay out of memory there.
+ *
+ * The `.tsx` extension is required (the file contains JSX); the lazy import
+ * specifier `./tui/index.js` resolves to this source under `tsx` dev mode and
+ * to the compiled `dist/adapters/cli/tui/index.js` under `tsc`.
+ */
+import { render } from 'ink';
+import { TuiApp } from './app.js';
+import { formatJson, formatTranscript } from './session-export.js';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { bootstrapCliSession } from '../bootstrap.js';
+import { buildCommandRegistry } from '../commands/build-registry.js';
+import { warmInkReset, resetInkStatic } from './ink-reset.js';
+import { ThemeProvider } from './hooks/use-theme.js';
+import { MODEL_CATALOG } from '../../../models-catalog.js';
+import { resolveProviderConfigFromApp } from '../../../core/provider-resolver.js';
+import { createProvider } from '../../../providers/factory.js';
+import { SettingsManager } from '../../../core/settings-manager.js';
+import { SETTINGS_MAP, SETTINGS_SCHEMA } from '../../../core/settings-schema.js';
+import { loadMergedConfig, loadJsonConfig, getConfigPaths, applyEnvOverrides } from '../config-loader.js';
+/**
+ * Run the shared session setup (same bootstrap as the readline REPL), build the
+ * shared command registry, then render the full-screen Ink TUI. `exitOnCtrlC`
+ * is false so the app owns Ctrl+C (abort mid-run, exit when idle) per FR-006.
+ */
+export async function startTui({ queryParts, options }) {
+    const initialQuery = queryParts.join(' ').trim();
+    const ctx = await bootstrapCliSession(options);
+    const { agent, fullConfig, activeProviderType, gatewayInstance, permissionLevel, persistence } = ctx;
+    // Same registry the readline REPL uses — one owner of the command set.
+    const registry = buildCommandRegistry(agent, fullConfig, activeProviderType, gatewayInstance);
+    // Autocomplete sources: built-in commands + loaded skills.
+    const commands = registry.getAll()
+        .filter((e) => !e.hidden)
+        .map((e) => ({ name: e.name, description: e.description }));
+    const skills = (agent.getSkillRegistry()?.getAll() ?? [])
+        .map((s) => ({ name: s.name, description: s.description }));
+    // Model-selector options: catalog models for each CONFIGURED provider.
+    const modelOptions = [];
+    for (const pt of ['openai', 'anthropic', 'glm', 'openai-compatible']) {
+        if (!resolveProviderConfigFromApp(fullConfig, pt))
+            continue;
+        for (const m of MODEL_CATALOG[pt]) {
+            modelOptions.push({ providerType: pt, modelId: m.id, modelName: m.name });
+        }
+    }
+    const onSwitchModel = async (providerType, modelId) => {
+        const pc = resolveProviderConfigFromApp(fullConfig, providerType);
+        if (!pc)
+            return;
+        pc.model = modelId;
+        const provider = await createProvider(pc);
+        agent.switchProvider(provider, modelId);
+    };
+    // Fresh settings list each time the overlay opens (so edits via /settings set
+    // are reflected without a restart).
+    const getSettingsList = () => {
+        const paths = getConfigPaths();
+        const sm = new SettingsManager({
+            config: applyEnvOverrides(loadMergedConfig()),
+            projectConfigPath: paths.local,
+            globalConfigPath: paths.global,
+            projectConfig: loadJsonConfig(paths.local),
+            globalConfig: loadJsonConfig(paths.global),
+        });
+        return sm.list().map((s) => {
+            const mapEntry = SETTINGS_MAP.get(s.dotKey);
+            const schemaEntry = SETTINGS_SCHEMA.get(s.dotKey);
+            return {
+                dotKey: s.dotKey,
+                value: s.masked ? '******' : String(s.value),
+                category: s.category,
+                label: mapEntry?.label ?? s.dotKey,
+                type: schemaEntry?.type ?? 'string',
+                secret: schemaEntry?.secret ?? false,
+                enumValues: schemaEntry?.enumValues,
+                restartRequired: schemaEntry?.restartRequired ?? false,
+            };
+        });
+    };
+    const onSetSetting = async (dotKey, value) => {
+        const paths = getConfigPaths();
+        const sm = new SettingsManager({
+            config: applyEnvOverrides(loadMergedConfig()),
+            projectConfigPath: paths.local,
+            globalConfigPath: paths.global,
+            projectConfig: loadJsonConfig(paths.local),
+            globalConfig: loadJsonConfig(paths.global),
+        });
+        await sm.set(dotKey, value);
+    };
+    // ── Sessions ────────────────────────────────────────────────────────────
+    // list() returns bare ids; load() each to get metadata for the selector.
+    // N+1 I/O is fine for O(10s) of local sessions. Derive a preview from the
+    // first user message (SessionData has no title field). Forward-compatible:
+    // swap this closure for registry.sessionsForUser() once 002 lands (see
+    // specs/002-channels-integration migration note).
+    const PREVIEW_LEN = 80;
+    const listSessions = async () => {
+        const ids = await persistence.list();
+        const loaded = await Promise.all(ids.map((id) => persistence.load(id)));
+        return loaded
+            .filter((s) => s != null)
+            .map((s) => {
+            const firstUser = s.messages.find((m) => m.role === 'user');
+            const preview = (firstUser?.content ?? s.id).split('\n')[0].trim();
+            return {
+                id: s.id,
+                preview: preview.length > PREVIEW_LEN ? preview.slice(0, PREVIEW_LEN - 1) + '…' : preview,
+                updatedAt: s.updatedAt,
+                userMessageCount: s.messages.filter((m) => m.role === 'user').length,
+                toolCallCount: s.messages.filter((m) => m.role === 'tool').length,
+                assistantMessageCount: s.messages.filter((m) => m.role === 'assistant').length,
+                title: s.metadata?.title,
+                provider: s.provider,
+                model: s.model,
+            };
+        })
+            .sort((a, b) => b.updatedAt - a.updatedAt);
+    };
+    // Load the session into the agent and return a short summary for the info
+    // notice. The caller (TuiApp) rebuilds the feed from agent.getMessages().
+    const onSwitchSession = async (sessionId) => {
+        const ok = await agent.loadSession(sessionId);
+        if (!ok)
+            return null;
+        const msgs = agent.getMessages();
+        const firstUser = msgs.find((m) => m.role === 'user');
+        const preview = (firstUser?.content ?? sessionId).split('\n')[0].trim();
+        return {
+            preview,
+            userMessageCount: msgs.filter((m) => m.role === 'user').length,
+            toolCallCount: msgs.filter((m) => m.role === 'tool').length,
+        };
+    };
+    const onDeleteSession = async (sessionId) => {
+        await persistence.delete(sessionId);
+    };
+    // Export: write full SessionData as JSON to ./<short-id>.json. Returns the
+    // written path so the app can show a confirmation notice.
+    const onExportSession = async (sessionId) => {
+        const data = await persistence.load(sessionId);
+        if (!data)
+            return null;
+        const outPath = path.join(process.cwd(), `${sessionId.slice(0, 8)}.json`);
+        await fs.promises.writeFile(outPath, formatJson(data), 'utf-8');
+        return outPath;
+    };
+    // Transcript: write a human-readable Markdown render to ./<short-id>.md.
+    const onTranscriptSession = async (sessionId) => {
+        const data = await persistence.load(sessionId);
+        if (!data)
+            return null;
+        const outPath = path.join(process.cwd(), `${sessionId.slice(0, 8)}.md`);
+        await fs.promises.writeFile(outPath, formatTranscript(data), 'utf-8');
+        return outPath;
+    };
+    // Rename: set metadata.title via a full round-trip (load → set title → save).
+    // The backend's metadata merge (`data.metadata ?? existing.metadata`) means
+    // regular chat saves (which pass metadata: undefined) preserve the title.
+    const onRenameSession = async (sessionId, title) => {
+        const data = await persistence.load(sessionId);
+        if (!data)
+            return false;
+        await persistence.save(sessionId, {
+            ...data,
+            metadata: { ...data.metadata, title },
+        });
+        return true;
+    };
+    // Bridge the registry to the TUI: defer interactive (stdin/stdout-owning)
+    // commands; otherwise dispatch and surface the returned output.
+    const dispatchCommand = async (input) => {
+        const entry = registry.resolveCommand(input);
+        if (entry?.interactive)
+            return { status: 'handled', deferred: true };
+        const { status, output } = await registry.dispatch(input, { agent, args: '', config: fullConfig }, agent.getSkillRegistry());
+        const isExit = status === 'exit';
+        return { status: isExit ? 'handled' : status, output, exit: isExit };
+    };
+    // Clear any bootstrap status output (Loaded config / Gateway initialized) so
+    // the TUI launches on a clean screen.
+    process.stdout.write('\x1B[2J\x1B[1;1H');
+    // Pre-load Ink's internal instances store (absolute-path import; see
+    // ink-reset.ts) so resize/expand resets are synchronous.
+    await warmInkReset();
+    let instance;
+    const onExit = () => {
+        instance.unmount();
+        process.exit(0);
+    };
+    // Reset Ink's accumulated Static output + clear the screen before a `<Static>`
+    // remount (resize / expand-toggle), so history repaints cleanly without
+    // phantom duplicates. (Command Code's fullStaticOutput reset pattern.)
+    const resetView = () => {
+        resetInkStatic(process.stdout);
+        instance.clear();
+        process.stdout.write('\x1B[2J\x1B[3J\x1B[H');
+    };
+    instance = render(_jsx(ThemeProvider, { children: _jsx(TuiApp, { agent: agent, permissionLevel: permissionLevel, initialQuery: initialQuery, onExit: onExit, dispatchCommand: dispatchCommand, commands: commands, skills: skills, resetView: resetView, providerType: activeProviderType, gatewayOn: !!gatewayInstance, skillCount: skills.length, mcpCount: gatewayInstance?.getTargets ? Object.keys(gatewayInstance.getTargets()).length : 0, modelOptions: modelOptions, onSwitchModel: onSwitchModel, getSettingsList: getSettingsList, onSetSetting: onSetSetting, listSessions: listSessions, onSwitchSession: onSwitchSession, onDeleteSession: onDeleteSession, onExportSession: onExportSession, onTranscriptSession: onTranscriptSession, onRenameSession: onRenameSession, getSessionId: () => agent.getSessionId() }) }), { exitOnCtrlC: false });
+}

package/dist/adapters/cli/tui/ink-reset.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Ink internals reset — the Command Code pattern, adapted for stock Ink 6.6.0
+ * without a bundler.
+ *
+ * Why: `<Static>` renders each item once and freezes it, so resize-reflow and
+ * tool-block expand/collapse (which need to re-render history) don't work.
+ * Remounting `<Static>` via a `key` bump re-paints everything — BUT Ink
+ * accumulates the re-emitted items in its internal `fullStaticOutput`, causing
+ * duplicate "phantom" lines. Resetting `fullStaticOutput` + `lastOutput` before
+ * the remount fixes that.
+ *
+ * Stock Ink doesn't expose the instance. Its `package.json` `exports` field
+ * blocks `ink/build/instances.js` as a subpath, BUT importing the file by its
+ * resolved absolute path (derived from the exported main entry) bypasses
+ * package-exports enforcement — no bundler required.
+ *
+ * This is internals-poking, so it's shape-guarded: if a future Ink changes the
+ * internal field names or the instances store, `resetInkStatic` returns false
+ * and callers fall back to the frozen-on-resize behavior (no crash). Mirror of
+ * Command Code's `registerInkControl` + `warnPatchSkipped`.
+ */
+/** Pre-load the internal instances store (async; call once at TUI start). */
+export declare function warmInkReset(): Promise<void>;
+/**
+ * Reset Ink's accumulated Static output + last-frame tracking so a `<Static>`
+ * remount repaints cleanly. Returns false (no-op) if the internals are
+ * unavailable or shaped differently than expected.
+ */
+export declare function resetInkStatic(stdout: object): boolean;

package/dist/adapters/cli/tui/ink-reset.js

@@ -0,0 +1,57 @@
+/**
+ * Ink internals reset — the Command Code pattern, adapted for stock Ink 6.6.0
+ * without a bundler.
+ *
+ * Why: `<Static>` renders each item once and freezes it, so resize-reflow and
+ * tool-block expand/collapse (which need to re-render history) don't work.
+ * Remounting `<Static>` via a `key` bump re-paints everything — BUT Ink
+ * accumulates the re-emitted items in its internal `fullStaticOutput`, causing
+ * duplicate "phantom" lines. Resetting `fullStaticOutput` + `lastOutput` before
+ * the remount fixes that.
+ *
+ * Stock Ink doesn't expose the instance. Its `package.json` `exports` field
+ * blocks `ink/build/instances.js` as a subpath, BUT importing the file by its
+ * resolved absolute path (derived from the exported main entry) bypasses
+ * package-exports enforcement — no bundler required.
+ *
+ * This is internals-poking, so it's shape-guarded: if a future Ink changes the
+ * internal field names or the instances store, `resetInkStatic` returns false
+ * and callers fall back to the frozen-on-resize behavior (no crash). Mirror of
+ * Command Code's `registerInkControl` + `warnPatchSkipped`.
+ */
+import { createRequire } from 'node:module';
+import * as path from 'node:path';
+const nodeRequire = createRequire(import.meta.url);
+const inkBuildDir = path.dirname(nodeRequire.resolve('ink'));
+let inkInstances;
+/** Pre-load the internal instances store (async; call once at TUI start). */
+export async function warmInkReset() {
+    if (inkInstances !== undefined)
+        return;
+    try {
+        // Absolute-path import sidesteps Ink's `exports` restriction.
+        const mod = await import(path.join(inkBuildDir, 'instances.js'));
+        inkInstances = mod.default instanceof WeakMap ? mod.default : null;
+    }
+    catch {
+        inkInstances = null;
+    }
+}
+/**
+ * Reset Ink's accumulated Static output + last-frame tracking so a `<Static>`
+ * remount repaints cleanly. Returns false (no-op) if the internals are
+ * unavailable or shaped differently than expected.
+ */
+export function resetInkStatic(stdout) {
+    if (!inkInstances)
+        return false;
+    const ink = inkInstances.get(stdout);
+    if (!ink)
+        return false;
+    if (typeof ink.fullStaticOutput !== 'string' || typeof ink.lastOutput !== 'string') {
+        return false;
+    }
+    ink.fullStaticOutput = '';
+    ink.lastOutput = '';
+    return true;
+}