zoe-agent 0.3.1

package/dist/adapters/cli/system-prompts.js

@@ -0,0 +1,131 @@
+/**
+ * Zoe CLI — System Prompts
+ *
+ * Two system prompts, selected by launch mode:
+ *   - non-interactive (headless / piped / docker / --no-interactive):
+ *       the Docker-native "worker unit" prompt — byte-identical to the
+ *       historical CLI system prompt.
+ *   - interactive (TTY + interactive flag): a general-purpose agent
+ *       prompt tuned for a live terminal session (the TUI, or
+ *       interactive readline).
+ *
+ * Mode detection reuses the CLI's existing signals — Commander's
+ * `options.interactive` (`--no-interactive`) and `isNonInteractive()`
+ * (TTY / docker / env). Core's `runAgentLoop` stays mode-agnostic: it
+ * only receives the selected prompt string.
+ */
+import * as os from 'os';
+import { isNonInteractive } from './docker-utils.js';
+/**
+ * Shared, runtime-derived environment block embedded in every prompt.
+ * Leading and trailing newlines are intentional — callers interpolate it
+ * between section headers.
+ */
+export function buildSystemInfoBlock() {
+    return `
+System Information:
+- OS: ${os.type()} ${os.release()} (${os.platform()})
+- Architecture: ${os.arch()}
+- Node.js Version: ${process.version}
+- Current Working Directory: ${process.cwd()}
+- User: ${os.userInfo().username}
+- Home Directory: ${os.homedir()}
+- Current Date: ${new Date().toLocaleString()}
+`;
+}
+/**
+ * Non-interactive / Docker / headless prompt.
+ * Byte-identical to the historical CLI system prompt.
+ */
+export function buildSystemPrompt() {
+    return `You are Zoe, a Docker-Native Autonomous Agent designed for massive scale automation.
+You are likely running inside a container or headless server, possibly as one of thousands of parallel units in a swarm.
+
+CONTEXT:
+${buildSystemInfoBlock()}
+
+ENVIRONMENT CONSTRAINTS:
+1. HEADLESS: No GUI available. Do not try to open browsers or apps.
+2. CONTAINER-OPTIMIZED: Assume you are in a sandbox. You can be aggressive with file creation but robust with errors.
+3. NON-INTERACTIVE: Always use flags to suppress prompts (e.g., 'apt-get -y', 'rm -rf').
+
+GUIDELINES:
+1. EFFICIENCY: Your goal is speed and success. Write scripts that just work.
+2. ROBUSTNESS: Use standard Linux/Unix tools found in minimal images (Alpine/Debian).
+3. TOOLS: Use 'execute_shell_command' for actions, 'write_file' for code generation.
+4. CLARITY: Output concise logs. You are a worker unit, not a chat bot.
+5. OPTIMIZATION: When asked to generate creative content (images, stories, complex code), use 'optimize_prompt' first to ensure the best possible output quality.`;
+}
+/**
+ * Interactive prompt for terminal sessions (TUI or interactive readline).
+ *
+ * Role, tool list, numbered process, and output format follow the
+ * interactive-agent conventions shared by tools like Command Code; the
+ * working principles mirror this project's own engineering standards
+ * (think before acting, surgical changes, simplicity, goal-driven).
+ */
+export function buildInteractiveSystemPrompt() {
+    return `You are Zoe — the user's AI person. You're a general-purpose assistant in a terminal who gains new capabilities through skills. Coding is one of the things you do, not the whole of it: you also research, write, automate, communicate, and generate media, and each loaded skill adds more. You work through conversation, tool calls, and verified results.
+
+CONTEXT:
+${buildSystemInfoBlock()}
+
+TOOLS AVAILABLE:
+- execute_shell_command: Run shell commands
+- read_file / write_file: Read and write files
+- get_current_datetime: Current date and time
+- web_search, send_email, send_notification: Look things up and communicate
+- read_website, take_screenshot, generate_image, optimize_prompt: Advanced tools
+- use_skill: Invoke a domain skill (loaded skills are listed at startup)
+- manage_todos: Maintain a visible task list (pending / in_progress / completed / blocked). Replace the full list each call.
+
+TOOL RULES:
+- Non-interactive flags always: shell commands must never prompt — pass -y/--yes (e.g. apt-get -y, rm -f) so they don't hang waiting on stdin.
+- Optimize first for creative work: when asked for creative output (images via generate_image, stories, or complex code), call optimize_prompt on the request before generating, to maximize quality.
+- Track multi-step work with manage_todos: for any task with 2 or more steps, call manage_todos FIRST with the full plan (every item status "pending"), mark one item "in_progress" when you start it, and mark items "completed" (or "blocked") as you finish. Replace the ENTIRE list on every call — do not append. This keeps the user informed of progress in the task panel. Treat "add N items to the todo/task list", "make a plan", and similar as an explicit request to use manage_todos.
+
+WORKING PRINCIPLES:
+1. Think before acting. State assumptions. If a request is ambiguous or a simpler approach exists, say so before implementing.
+2. Surgical changes. Touch only what the task requires. Match existing code style. Don't refactor working code unprompted.
+3. Simplicity first. Write the minimum code that solves the problem. No speculative features.
+4. Goal-driven. Know what "done" means, then verify it — run the tests, re-read the changed code, show the evidence.
+
+PROCESS:
+1. Understand: read the relevant files before editing. Don't guess at structure.
+2. Plan: for non-trivial changes, outline the approach in a few lines first.
+3. Act: make focused edits; prefer targeted edits over full rewrites.
+4. Verify: run a build or tests, or re-read the result, to confirm the change works.
+
+OUTPUT:
+- Be concise. Lead with what you did and what to check, not preamble.
+- Use short fenced code blocks for commands and code.
+- When a tool changes files, name the files and summarize the diff in one line.
+- Stop when the task is verified complete, or state precisely what is blocking you.
+
+The user is present and interactive. You may ask a clarifying question when truly blocked, but prefer to make a reasonable choice, proceed, and note the assumption.`;
+}
+/**
+ * Resolve launch mode from the CLI's two existing interactive signals.
+ *
+ * A session is interactive only when the Commander interactive flag is on
+ * (i.e. not `--no-interactive`) AND the process is in an interactive
+ * context (TTY, not docker, no non-interactive env). This matches every
+ * documented launch path:
+ *   - plain `zoe` in a TTY               -> interactive
+ *   - `zoe -n` / `--no-interactive`      -> non-interactive
+ *   - piped stdin                          -> non-interactive
+ *   - `zoe --docker`                     -> non-interactive
+ */
+export function resolveLaunchMode(options) {
+    if (options.interactive === false)
+        return 'non-interactive';
+    if (isNonInteractive())
+        return 'non-interactive';
+    return 'interactive';
+}
+/**
+ * Select the system prompt for a launch mode.
+ */
+export function selectSystemPrompt(mode) {
+    return mode === 'interactive' ? buildInteractiveSystemPrompt() : buildSystemPrompt();
+}

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

@@ -0,0 +1,58 @@
+import { type ModelOption } from './overlays/model-selector.js';
+import { type SessionListItem } from './overlays/session-selector.js';
+import { type SettingItem } from './overlays/settings-overlay.js';
+import type { Suggestion } from './components/autocomplete.js';
+import type { Agent } from '../agent.js';
+import type { PermissionLevel } from '../../../core/types.js';
+/** Outcome of dispatching a slash command in the TUI (built in startTui). */
+export interface TuiCommandOutcome {
+    status: 'handled' | 'fallthrough';
+    /** Command owns stdin/stdout — the TUI can't run it (deferred to a later phase). */
+    deferred?: boolean;
+    /** ANSI-styled text; the TUI strips ANSI before rendering. */
+    output?: string;
+    /** Session should terminate. */
+    exit?: boolean;
+}
+interface TuiAppProps {
+    agent: Agent;
+    permissionLevel?: PermissionLevel;
+    initialQuery?: string;
+    onExit: () => void;
+    dispatchCommand: (input: string) => Promise<TuiCommandOutcome>;
+    commands: Suggestion[];
+    skills: Suggestion[];
+    /** Reset Ink's accumulated Static output + clear screen before a `<Static>`
+     *  remount (resize / expand / session-resume) so history repaints cleanly. */
+    resetView: () => void;
+    /** Footer status info from the session. */
+    providerType: string;
+    gatewayOn: boolean;
+    skillCount: number;
+    mcpCount: number;
+    modelOptions: ModelOption[];
+    onSwitchModel: (providerType: string, modelId: string) => Promise<void>;
+    getSettingsList: () => SettingItem[];
+    onSetSetting: (dotKey: string, value: string) => Promise<void>;
+    listSessions: () => Promise<SessionListItem[]>;
+    onSwitchSession: (sessionId: string) => Promise<{
+        preview: string;
+        userMessageCount: number;
+        toolCallCount: number;
+    } | null>;
+    onDeleteSession: (sessionId: string) => Promise<void>;
+    onExportSession: (sessionId: string) => Promise<string | null>;
+    onTranscriptSession: (sessionId: string) => Promise<string | null>;
+    onRenameSession: (sessionId: string, title: string) => Promise<boolean>;
+    getSessionId: () => string;
+}
+/**
+ * TuiApp — Ink `<Static>` + native terminal scroll (like Command Code: the wheel
+ * scrolls the terminal's own scrollback, so no mouse capture / no gibberish).
+ * `<MessageArea>` grows the scrollback; the live region swaps between modal
+ * overlays, the inline permission prompt, a "working" indicator, and the input
+ * prompt. A status footer is always at the bottom of the written content.
+ * `ink-reset.ts` (`resetView`) keeps resize/expand repaints artifact-free.
+ */
+export declare function TuiApp({ agent, permissionLevel, initialQuery, onExit, dispatchCommand, commands, skills, resetView, providerType, gatewayOn, skillCount, mcpCount, modelOptions, onSwitchModel, getSettingsList, onSetSetting, listSessions, onSwitchSession, onDeleteSession, onExportSession, onTranscriptSession, onRenameSession, getSessionId, }: TuiAppProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,314 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from 'react';
+import { Box, Text } from 'ink';
+import { useTheme } from './hooks/use-theme.js';
+import { useFeed } from './hooks/use-feed.js';
+import { useAgent } from './hooks/use-agent.js';
+import { useKeybindings } from './hooks/use-keybindings.js';
+import { useFileWatcher } from './hooks/use-file-watcher.js';
+import { MessageArea } from './components/message-area.js';
+import { PromptArea } from './components/prompt-area.js';
+import { PermissionPrompt } from './components/permission-prompt.js';
+import { AssistantMessage } from './components/assistant-message.js';
+import { ToolCallBlock } from './components/tool-call-block.js';
+import { GoalStatus } from './components/goal-status.js';
+import { Footer } from './components/footer.js';
+import Spinner from 'ink-spinner';
+import { CommandPalette } from './components/command-palette.js';
+import { HelpDialog } from './overlays/help-dialog.js';
+import { ModelSelector } from './overlays/model-selector.js';
+import { SessionSelector } from './overlays/session-selector.js';
+import { SettingsEditor } from './overlays/settings-overlay.js';
+import { messagesToFeedEntries } from './feed-serializer.js';
+import { getModelMeta } from '../../../models-catalog.js';
+import { HORIZONTAL_PADDING } from './layout.js';
+/** Strip ANSI escapes — handler output is chalk-styled for the readline path. */
+function stripAnsi(text) {
+    return text.replace(/\x1b\[[0-9;?]*[a-zA-Z]/g, '');
+}
+/**
+ * TuiApp — Ink `<Static>` + native terminal scroll (like Command Code: the wheel
+ * scrolls the terminal's own scrollback, so no mouse capture / no gibberish).
+ * `<MessageArea>` grows the scrollback; the live region swaps between modal
+ * overlays, the inline permission prompt, a "working" indicator, and the input
+ * prompt. A status footer is always at the bottom of the written content.
+ * `ink-reset.ts` (`resetView`) keeps resize/expand repaints artifact-free.
+ */
+export function TuiApp({ agent, permissionLevel, initialQuery, onExit, dispatchCommand, commands, skills, resetView, providerType, gatewayOn, skillCount, mcpCount, modelOptions, onSwitchModel, getSettingsList, onSetSetting, listSessions, onSwitchSession, onDeleteSession, onExportSession, onTranscriptSession, onRenameSession, getSessionId, }) {
+    const theme = useTheme();
+    const feed = useFeed();
+    const { isRunning, pendingPermission, streamingText, streamingTool, usage, contextTokens, latestTodos, submit, resolvePermission, abort, resetTodos, restoreTodos } = useAgent({
+        agent,
+        feed,
+        permissionLevel,
+    });
+    const [input, setInput] = useState('');
+    const [overlay, setOverlay] = useState(null);
+    const [settingsList, setSettingsList] = useState([]);
+    const [sessionsList, setSessionsList] = useState([]);
+    // File-watcher: notifies when project files change externally while idle.
+    const { changedFile, clear: clearFileChange } = useFileWatcher(!isRunning);
+    // Input history lives here (not in PromptArea) so it survives PromptArea
+    // unmounting during a run — otherwise every turn wiped the history.
+    const historyRef = useRef([]);
+    const historyIndexRef = useRef(-1);
+    // The in-progress prompt, saved on first ↑ so ↓ back to the present restores it.
+    const draftRef = useRef('');
+    // Queue: chat messages typed during a run are buffered and drained one per
+    // run completion (like other AI coding TUIs). isRunningRef mirrors state for
+    // synchronous reads inside the handleUserInput event handler.
+    const isRunningRef = useRef(false);
+    isRunningRef.current = isRunning;
+    const queueRef = useRef([]);
+    const [queuedCount, setQueuedCount] = useState(0);
+    const [staticKey, setStaticKey] = useState(0);
+    const [expanded, setExpanded] = useState(false);
+    // Resize → reset Ink's Static buffer + remount <Static> for a clean repaint.
+    useEffect(() => {
+        const onResize = () => {
+            resetView();
+            setStaticKey((k) => k + 1);
+        };
+        process.stdout.on('resize', onResize);
+        return () => {
+            process.stdout.off('resize', onResize);
+        };
+    }, [resetView]);
+    const didInit = useRef(false);
+    useEffect(() => {
+        if (didInit.current)
+            return;
+        didInit.current = true;
+        feed.appendEntry({ kind: 'logo' });
+        if (initialQuery && initialQuery.trim()) {
+            void submit(initialQuery);
+        }
+    }, [initialQuery, submit, feed]);
+    // Drain the queue when a run finishes — submit the next queued message.
+    // Each submission's completion (isRunning→false) re-fires this effect,
+    // draining one message at a time until the queue is empty.
+    useEffect(() => {
+        if (!isRunning && queueRef.current.length > 0) {
+            const next = queueRef.current.shift();
+            setQueuedCount(queueRef.current.length);
+            void submit(next);
+        }
+    }, [isRunning, submit]);
+    // Full clear — start a new session (the agent rotates the session id) + a
+    // fresh TUI: empty the feed, reset todos, re-seed the logo, clear the screen
+    // and remount <Static>. Shared by the `/clear` command and the Ctrl+L binding.
+    const clearAll = () => {
+        agent.clearConversation();
+        feed.clear();
+        resetTodos();
+        feed.appendEntry({ kind: 'logo' });
+        resetView();
+        setStaticKey((k) => k + 1);
+    };
+    // Run a /command via the shared registry; surface its output in the feed.
+    const runSlash = async (raw) => {
+        const name = raw.split(/\s+/)[0];
+        const result = await dispatchCommand(raw);
+        if (result.deferred) {
+            feed.appendEntry({ kind: 'assistant', content: `${name} is interactive — run it in the readline REPL (zoe), or wait for the TUI overlay.` });
+        }
+        else if (result.exit) {
+            onExit();
+        }
+        else if (result.output) {
+            feed.appendEntry({ kind: 'assistant', content: stripAnsi(result.output) });
+        }
+        else if (result.status === 'fallthrough') {
+            feed.appendEntry({ kind: 'assistant', content: `${name} skill launch from the TUI arrives in US2 — ask in chat, or run it in the readline REPL.` });
+        }
+    };
+    const handleUserInput = async (value) => {
+        const trimmed = value.trim();
+        if (trimmed) {
+            historyRef.current.push(trimmed);
+            historyIndexRef.current = -1;
+        }
+        setInput('');
+        clearFileChange();
+        // /steer <message> — interrupt the current run and send a new message.
+        if (trimmed === '/steer' || trimmed.startsWith('/steer ')) {
+            const steerMsg = trimmed.slice('/steer'.length).trim();
+            if (!steerMsg) {
+                feed.appendEntry({ kind: 'info', content: 'Usage: /steer <message> — interrupts the current run and sends a new message.' });
+                return;
+            }
+            if (isRunningRef.current) {
+                abort();
+                queueRef.current.unshift(steerMsg);
+                setQueuedCount(queueRef.current.length);
+                feed.appendEntry({ kind: 'info', content: 'Steering — current run aborted, sending next.' });
+            }
+            else {
+                void submit(steerMsg);
+            }
+            return;
+        }
+        // During an active run, queue chat messages and block all other commands.
+        if (isRunningRef.current) {
+            if (trimmed.startsWith('/')) {
+                feed.appendEntry({ kind: 'info', content: 'Command unavailable during a run — use /steer <message> to interrupt, or wait for the run to finish.' });
+            }
+            else if (trimmed) {
+                queueRef.current.push(trimmed);
+                setQueuedCount(queueRef.current.length);
+                feed.appendEntry({ kind: 'info', content: `Queued (${queueRef.current.length}) — will submit when the run finishes. /steer to send now.` });
+            }
+            return;
+        }
+        if (trimmed === '/?') {
+            setOverlay('help');
+            return;
+        }
+        if (trimmed === '/models' || trimmed === '/model') {
+            setOverlay('model');
+            return;
+        }
+        if (trimmed === '/sessions' || trimmed === '/session') {
+            setSessionsList(await listSessions());
+            setOverlay('sessions');
+            return;
+        }
+        // `/clear` starts a fresh session + TUI (logo, empty feed) — handled here,
+        // not via the registry (which only clears the agent, not the visible feed).
+        if (trimmed === '/clear') {
+            clearAll();
+            return;
+        }
+        {
+            const parts = trimmed.split(/\s+/);
+            const cmd = parts[0]?.toLowerCase();
+            const sub = parts[1]?.toLowerCase();
+            if (['/settings', '/setting', '/config'].includes(cmd)) {
+                if (sub === undefined) {
+                    setSettingsList(getSettingsList());
+                    setOverlay('settings');
+                    return;
+                }
+                if (sub === 'set' && parts.length <= 3) {
+                    feed.appendEntry({ kind: 'info', content: 'Provide a value: /settings set <key> <value>  (e.g. /settings set gateway.enabled true)' });
+                    return;
+                }
+            }
+        }
+        if (trimmed.startsWith('/')) {
+            await runSlash(trimmed);
+        }
+        else {
+            void submit(value);
+        }
+    };
+    const onHistoryUp = () => {
+        const h = historyRef.current;
+        if (h.length === 0)
+            return;
+        if (historyIndexRef.current === -1)
+            draftRef.current = input; // save in-progress prompt
+        const next = historyIndexRef.current === -1 ? h.length - 1 : Math.max(0, historyIndexRef.current - 1);
+        historyIndexRef.current = next;
+        setInput(h[next]);
+    };
+    const onHistoryDown = () => {
+        const h = historyRef.current;
+        if (h.length === 0 || historyIndexRef.current === -1)
+            return;
+        const next = historyIndexRef.current + 1;
+        if (next >= h.length) {
+            historyIndexRef.current = -1;
+            setInput(draftRef.current); // restore in-progress prompt
+        }
+        else {
+            historyIndexRef.current = next;
+            setInput(h[next]);
+        }
+    };
+    // Palette includes synthetic entries that open overlays.
+    const paletteCommands = [
+        ...commands,
+        { name: 'shortcuts', description: 'Keyboard reference' },
+        { name: 'model', description: 'Switch model' },
+        { name: 'settings', description: 'View settings' },
+        { name: 'sessions', description: 'Resume / delete a session' },
+    ];
+    const onPaletteRun = (name) => {
+        setOverlay(null);
+        if (name === 'shortcuts') {
+            setOverlay('help');
+        }
+        else if (name === 'model') {
+            setOverlay('model');
+        }
+        else if (name === 'settings') {
+            setSettingsList(getSettingsList());
+            setOverlay('settings');
+        }
+        else if (name === 'sessions') {
+            void (async () => {
+                setSessionsList(await listSessions());
+                setOverlay('sessions');
+            })();
+        }
+        else {
+            void runSlash('/' + name);
+        }
+    };
+    const handleSetSetting = async (dotKey, value) => {
+        await onSetSetting(dotKey, value);
+        setSettingsList(getSettingsList());
+    };
+    // Resume a session: load messages into the agent, rebuild the visual feed,
+    // and remount <Static> so history repaints without phantom duplicates.
+    const handleSelectSession = async (sessionId) => {
+        const summary = await onSwitchSession(sessionId);
+        setOverlay(null);
+        if (!summary) {
+            feed.appendEntry({ kind: 'info', content: `Session ${sessionId.slice(0, 8)} could not be loaded.` });
+            return;
+        }
+        feed.clear();
+        resetTodos();
+        const { entries, latestTodos: sessionTodos } = messagesToFeedEntries(agent.getMessages());
+        for (const entry of entries)
+            feed.appendEntry(entry);
+        restoreTodos(sessionTodos);
+        resetView();
+        setStaticKey((k) => k + 1);
+        feed.appendEntry({ kind: 'info', content: `Resumed session: ${summary.preview} (${summary.userMessageCount} turns, ${summary.toolCallCount} tool calls)` });
+    };
+    const handleDeleteSession = async (sessionId) => {
+        await onDeleteSession(sessionId);
+        setSessionsList(await listSessions());
+    };
+    const handleExportSession = async (sessionId) => {
+        const outPath = await onExportSession(sessionId);
+        feed.appendEntry({ kind: 'info', content: outPath ? `Exported session to ${outPath}` : `Session ${sessionId.slice(0, 8)} could not be exported.` });
+    };
+    const handleTranscriptSession = async (sessionId) => {
+        const outPath = await onTranscriptSession(sessionId);
+        feed.appendEntry({ kind: 'info', content: outPath ? `Transcript written to ${outPath}` : `Session ${sessionId.slice(0, 8)} could not be exported.` });
+    };
+    const handleRenameSession = async (sessionId, title) => {
+        const ok = await onRenameSession(sessionId, title);
+        if (ok)
+            setSessionsList(await listSessions());
+        return ok;
+    };
+    useKeybindings({
+        onAbort: abort,
+        onExit,
+        onExpandToggle: () => { resetView(); setExpanded((e) => !e); setStaticKey((k) => k + 1); },
+        onPalette: () => setOverlay('palette'),
+        onClear: clearAll,
+    }, { enabled: overlay === null, isRunning });
+    const showSpinner = isRunning && !streamingText && !pendingPermission;
+    // The bordered input is always visible (003 US1). While a tool needs approval
+    // the inline prompt replaces it; otherwise the spinner (with queued count)
+    // renders ABOVE the input — the input stays active so queued/steered messages
+    // can be typed during a run.
+    const inputAreaSlot = pendingPermission ? (_jsx(PermissionPrompt, { toolName: pendingPermission.toolName, args: pendingPermission.args, onResolve: resolvePermission })) : (_jsxs(Box, { flexDirection: "column", children: [showSpinner ? (_jsxs(Box, { children: [_jsxs(Text, { color: theme.yellow, children: [_jsx(Spinner, { type: "dots" }), " Zoe is working "] }), _jsxs(Text, { color: theme.fgDim, children: ["(Esc to abort)", queuedCount > 0 ? ` · ${queuedCount} queued` : ''] })] })) : null, _jsx(PromptArea, { value: input, onChange: setInput, onSubmit: (v) => { void handleUserInput(v); }, onHistoryUp: onHistoryUp, onHistoryDown: onHistoryDown, commands: commands, skills: skills })] }));
+    return (_jsxs(Box, { flexDirection: "column", paddingLeft: HORIZONTAL_PADDING, paddingRight: HORIZONTAL_PADDING, children: [_jsx(MessageArea, { entries: feed.entries, staticKey: staticKey, expanded: expanded }), latestTodos ? _jsx(GoalStatus, { todos: latestTodos }) : null, streamingText ? (_jsx(AssistantMessage, { entry: { id: '__streaming', kind: 'assistant', content: streamingText } })) : null, streamingTool ? (_jsx(ToolCallBlock, { entry: { id: '__running-tool', kind: 'tool', name: streamingTool.name, args: streamingTool.args, status: 'running', output: streamingTool.output }, expanded: true })) : null, _jsx(Box, { flexDirection: "column", children: overlay === 'palette' ? (_jsx(CommandPalette, { commands: paletteCommands, skills: skills, onRun: onPaletteRun, onClose: () => setOverlay(null) })) : overlay === 'help' ? (_jsx(HelpDialog, { onClose: () => setOverlay(null) })) : overlay === 'model' ? (_jsx(ModelSelector, { options: modelOptions, currentModel: agent.getModel(), onSwitch: (pt, m) => { setOverlay(null); void onSwitchModel(pt, m); }, onClose: () => setOverlay(null) })) : overlay === 'settings' ? (_jsx(SettingsEditor, { settings: settingsList, onSet: handleSetSetting, onClose: () => setOverlay(null) })) : overlay === 'sessions' ? (_jsx(SessionSelector, { sessions: sessionsList, currentSessionId: getSessionId(), onSelect: (id) => { void handleSelectSession(id); }, onDelete: (id) => { void handleDeleteSession(id); }, onExport: (id) => { void handleExportSession(id); }, onTranscript: (id) => { void handleTranscriptSession(id); }, onRename: (id, title) => handleRenameSession(id, title), onClose: () => setOverlay(null) })) : (inputAreaSlot) }), changedFile ? (_jsxs(Text, { color: theme.yellow, children: ["~ ", changedFile, " changed externally"] })) : null, _jsx(Footer, { providerType: providerType, model: agent.getModel(), usage: usage, permissionLevel: permissionLevel, skillCount: skillCount, gatewayOn: gatewayOn, mcpCount: mcpCount, contextTokens: contextTokens, contextWindow: getModelMeta(agent.getModel())?.contextWindow })] }));
+}

package/dist/adapters/cli/tui/components/assistant-message.d.ts

@@ -0,0 +1,5 @@
+import type { AssistantMessageEntry } from '../types.js';
+/** An LLM text response entry — blue speaker token + markdown-rendered content. */
+export declare function AssistantMessage({ entry }: {
+    entry: AssistantMessageEntry;
+}): import("react").JSX.Element;

package/dist/adapters/cli/tui/components/assistant-message.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { useTheme } from '../hooks/use-theme.js';
+import { Markdown } from './markdown.js';
+/** An LLM text response entry — blue speaker token + markdown-rendered content. */
+export function AssistantMessage({ entry }) {
+    const theme = useTheme();
+    return (_jsxs(Box, { children: [_jsx(Text, { color: theme.blue, bold: true, children: "Zoe \u203A " }), _jsx(Markdown, { content: entry.content })] }));
+}

package/dist/adapters/cli/tui/components/autocomplete.d.ts

@@ -0,0 +1,19 @@
+export interface Suggestion {
+    name: string;
+    description?: string;
+}
+/** Filter to matches and rank by relevance score (desc). */
+export declare function fuzzyFilter(items: Suggestion[], query: string): Suggestion[];
+/**
+ * Fuzzy suggestion dropdown rendered above the prompt. Caller owns selection
+ * state and key handling (Tab/arrows/Esc in `prompt-area`); this is pure view.
+ *
+ * The list is windowed: only MAX_VISIBLE rows render, and the window follows
+ * `selectedIndex` (clamped) so ↑/↓ scroll through every match — not just the
+ * first page. Count hints show how many are hidden above/below.
+ */
+export declare function Autocomplete({ suggestions, selectedIndex, prefix, }: {
+    suggestions: Suggestion[];
+    selectedIndex: number;
+    prefix: '/' | '@';
+}): import("react").JSX.Element | null;

package/dist/adapters/cli/tui/components/autocomplete.js

@@ -0,0 +1,75 @@
+import { jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { useTheme } from '../hooks/use-theme.js';
+/** Subsequence check — do query's chars appear in order within text? */
+function isSubsequence(text, query) {
+    if (!query)
+        return true;
+    let qi = 0;
+    for (let i = 0; i < text.length && qi < query.length; i++) {
+        if (text[i] === query[qi])
+            qi++;
+    }
+    return qi === query.length;
+}
+function basename(name) {
+    const slash = name.lastIndexOf('/');
+    return slash === -1 ? name : name.slice(slash + 1);
+}
+/**
+ * Relevance score for `name` against `query` (higher = better; -1 = no match).
+ * Contiguous matches in the basename dominate so `@read` ranks README over a
+ * file that merely has r…e scattered in its path. Falls back to subsequence.
+ */
+function scoreSuggestion(name, query) {
+    if (!query)
+        return 0;
+    const q = query.toLowerCase();
+    const full = name.toLowerCase();
+    const base = basename(name).toLowerCase();
+    if (!isSubsequence(full, q))
+        return -1;
+    let score = 0;
+    if (base.startsWith(q))
+        score += 100;
+    else if (base.includes(q))
+        score += 60;
+    else if (full.includes(q))
+        score += 30;
+    else
+        score += 5; // subsequence only — weakest
+    score -= name.split('/').length; // shallower paths rank higher
+    if (base.startsWith('.'))
+        score -= 15; // hidden / artifacts sink
+    return score;
+}
+/** Filter to matches and rank by relevance score (desc). */
+export function fuzzyFilter(items, query) {
+    return items
+        .map((s) => ({ s, score: scoreSuggestion(s.name, query) }))
+        .filter((x) => x.score >= 0)
+        .sort((a, b) => b.score - a.score)
+        .map((x) => x.s);
+}
+const MAX_VISIBLE = 8;
+/**
+ * Fuzzy suggestion dropdown rendered above the prompt. Caller owns selection
+ * state and key handling (Tab/arrows/Esc in `prompt-area`); this is pure view.
+ *
+ * The list is windowed: only MAX_VISIBLE rows render, and the window follows
+ * `selectedIndex` (clamped) so ↑/↓ scroll through every match — not just the
+ * first page. Count hints show how many are hidden above/below.
+ */
+export function Autocomplete({ suggestions, selectedIndex, prefix, }) {
+    const theme = useTheme();
+    if (suggestions.length === 0)
+        return null;
+    const half = Math.floor(MAX_VISIBLE / 2);
+    const start = Math.max(0, Math.min(selectedIndex - half, suggestions.length - MAX_VISIBLE));
+    const visible = suggestions.slice(start, start + MAX_VISIBLE);
+    const end = start + visible.length;
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.fgGutter, paddingLeft: 1, paddingRight: 1, children: [start > 0 ? (_jsxs(Text, { color: theme.fgDim, children: ["  \u2191 ", start, " more"] })) : null, visible.map((s, i) => {
+                const selected = start + i === selectedIndex;
+                return (_jsxs(Box, { children: [_jsxs(Text, { backgroundColor: selected ? theme.blue : undefined, color: selected ? theme.bg : theme.green, children: [selected ? '▶ ' : '  ', prefix, s.name] }), s.description ? (_jsxs(Text, { color: theme.fgDim, children: [" ", s.description.split('\n')[0].slice(0, 50)] })) : null] }, s.name));
+            }), end < suggestions.length ? (_jsxs(Text, { color: theme.fgDim, children: ["  \u2193 ", suggestions.length - end, " more"] })) : null] }));
+}

package/dist/adapters/cli/tui/components/command-palette.d.ts

@@ -0,0 +1,15 @@
+import { type Suggestion } from './autocomplete.js';
+interface CommandPaletteProps {
+    commands: Suggestion[];
+    skills: Suggestion[];
+    /** Run the selected command/skill by name (no leading slash). */
+    onRun: (name: string) => void;
+    onClose: () => void;
+}
+/**
+ * Ctrl+P command palette: type to fuzzy-filter commands + skills, ↑/↓ to
+ * navigate, Enter to run, Esc to close. Owns its input (the prompt is hidden
+ * while the palette is open).
+ */
+export declare function CommandPalette({ commands, skills, onRun, onClose }: CommandPaletteProps): import("react").JSX.Element;
+export {};