@nodetool-ai/cli 0.7.0-rc.22 → 0.8.1

package/dist/app.js

@@ -1,767 +1,1069 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-/**
- * NodeTool Chat CLI — Ink-based terminal UI.
- *
- * Layout:
- *   ╭─ nodetool ─────────────────── provider · model ─╮
- *   │                                                  │
- *   │  You: message                                    │
- *   │                                                  │
- *   │  response with markdown                          │
- *   │                                                  │
- *   │  ◆ tool_name result preview                      │
- *   │                                                  │
- *   ├──────────────────────────────────────────────────┤
- *   │ › input                                          │
- *   ╰──────────────────────────────────────────────────╯
- */
-import { useState, useEffect, useCallback, useRef } from "react";
-import { Box, Text, Static, useApp, useInput } from "ink";
-import ReadlineInput from "./readline-input.js";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect, useRef } from "react";
+import { Box, Text, useApp, useInput } from "ink";
 import Spinner from "ink-spinner";
-import { ExecutionTree } from "./ExecutionTree.js";
-import { useExecutionState } from "./useExecutionState.js";
-import { ProcessingContext } from "@nodetool-ai/runtime";
+import { writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { PERMISSION_GATE_CONTEXT_KEY, RUN_BUDGET_CONTEXT_KEY, estimatePromptTokens } from "@nodetool-ai/runtime";
 import { processChat } from "@nodetool-ai/chat";
-import { MultiModeAgent } from "@nodetool-ai/agents";
-import { ReadFileTool, WriteFileTool, ListDirectoryTool, EditFileTool, GlobTool, GrepTool, DownloadFileTool, HttpRequestTool, GoogleSearchTool, GoogleNewsTool, GoogleImagesTool, BrowserTool, ScreenshotTool, RunCodeTool, CalculatorTool, ExtractPDFTextTool, ConvertPDFToMarkdownTool, ConvertDocumentTool, StatisticsTool, GeometryTool, ConversionTool, OpenAIWebSearchTool, OpenAIImageGenerationTool, OpenAITextToSpeechTool, DataForSEOSearchTool, DataForSEONewsTool, SearchEmailTool, ArchiveEmailTool, getAllMcpTools, } from "@nodetool-ai/agents";
-import { createProvider, DEFAULT_MODELS, KNOWN_PROVIDERS, WebSocketProvider } from "./providers.js";
+import { availableProviders, createProvider, listConfiguredLanguageModels } from "./providers.js";
 import { WebSocketChatClient } from "./websocket-client.js";
+import { budgetStopReason, budgetSummaryLine, createCliRunBudget } from "./run-budget.js";
 import { renderMarkdown } from "./markdown.js";
+import { friendlyToolName, formatToolResult, isFormattedTool } from "./tool-format.js";
 import { saveSettings } from "./settings.js";
-import { getSecret } from "@nodetool-ai/models";
-// ---------------------------------------------------------------------------
-// Command definitions
-// ---------------------------------------------------------------------------
-const COMMANDS = {
-    "/help": "Show available commands",
-    "/clear": "Clear conversation history",
-    "/model": "Set model: /model <model-id>",
-    "/provider": "Set provider: /provider <name>",
-    "/agent": "Toggle agent mode",
-    "/planner": "Set agent planner: /planner graph|multi",
-    "/tools": "List enabled tools",
-    "/exit": "Exit the chat",
-    "/quit": "Exit the chat",
+import { buildCliToolbelt } from "./agent-toolbelt.js";
+import { BashTool } from "./bash-tool.js";
+import { applySystemPrompt, buildCliAgentBelt, createCliCodeActTurn } from "./chat-codeact.js";
+import { createChatContext } from "./chat-context.js";
+import { isNumber, isRecord, isString } from "./predicates.js";
+import { parsePermissionMode } from "./permission-gate.js";
+import ReadlineInput from "./readline-input.js";
+import { Transcript, terminalLines, terminalText, useTerminalSize } from "./terminal-screen.js";
+import { ChatSessionStore, newSessionId, exportTranscript } from "./chat-sessions.js";
+import { ChatPrompts } from "./chat-prompts.js";
+import { attachmentLines } from "./chat-media.js";
+export const CHAT_COMMANDS = {
+    "/help": "Commands and keyboard shortcuts",
+    "/new": "Start a new conversation",
+    "/clear": "Clear the screen, keep conversation context",
+    "/compact": "Summarize retained context",
+    "/model": "Choose a model",
+    "/agent": "Inspect sub-agent threads: /agent [id|main]",
+    "/mode": "Permissions: default, auto, plan",
+    "/sessions": "Browse saved conversations",
+    "/resume": "Resume a session: /resume <id>",
+    "/export": "Save transcript: /export <path.md>",
+    "/tools": "Show available tools",
+    "/details": "Toggle tool arguments, code and diffs",
+    "/exit": "Save and quit",
+    "/quit": "Save and quit"
 };
-// ---------------------------------------------------------------------------
-// Individual message rendering
-// ---------------------------------------------------------------------------
-function UserMessage({ content }) {
-    return (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: "magenta", dimColor: true, bold: true, children: "❯ " }), _jsx(Text, { bold: true, inverse: true, children: " " + content + " " })] }));
-}
-function AssistantMessage({ content, rendered }) {
-    return (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: "green", children: "● " }), _jsx(Text, { children: rendered ?? content })] }));
-}
-function ToolMessage({ toolName, toolArgs, content }) {
-    const argsStr = toolArgs
-        ? Object.entries(toolArgs)
-            .map(([k, v]) => `${k}: ${JSON.stringify(v)}`)
-            .join(", ")
-        : "";
-    const preview = content.split("\n").slice(0, 3).join(" ").slice(0, 200);
-    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: "green", children: "● " }), _jsx(Text, { bold: true, children: toolName }), argsStr ? _jsxs(Text, { color: "gray", dimColor: true, children: ["(", argsStr, ")"] }) : null] }), preview ? (_jsxs(Box, { marginLeft: 2, children: [_jsx(Text, { color: "gray", dimColor: true, children: "└ " }), _jsx(Text, { color: "gray", dimColor: true, children: preview })] })) : null] }));
-}
-function SystemMessage({ content }) {
-    return (_jsx(Box, { children: _jsx(Text, { color: "gray", dimColor: true, children: "  " + content }) }));
-}
-function ChatMessageItem({ msg }) {
-    switch (msg.role) {
-        case "user": return _jsx(UserMessage, { content: msg.content });
-        case "assistant": return _jsx(AssistantMessage, { content: msg.content, rendered: msg.rendered });
-        case "tool": return _jsx(ToolMessage, { toolName: msg.toolName ?? "tool", toolArgs: msg.toolArgs, content: msg.content });
-        case "system": return _jsx(SystemMessage, { content: msg.content });
+const APPROVAL_CHOICES = [
+    { key: "y", label: "Allow once", value: "allow" },
+    { key: "a", label: "Allow for chat", value: "allow_for_chat" },
+    { key: "n", label: "Deny", value: "deny" }
+];
+function parseSubAgentEventTags(message) {
+    if (!isRecord(message) || !isString(message.parent_tool_call_id)) {
+        return null;
     }
+    return {
+        parentId: message.parent_tool_call_id,
+        depth: isNumber(message.subtask_depth) ? message.subtask_depth : 1
+    };
 }
-// ---------------------------------------------------------------------------
-// Autocomplete menu
-// ---------------------------------------------------------------------------
-const CMD_WIDTH = 14;
-function AutocompleteMenu({ matches, selectedIndex, }) {
-    return (_jsx(Box, { flexDirection: "column", marginLeft: 2, children: matches.map(({ cmd, desc }, i) => {
-            const selected = i === selectedIndex;
-            return (_jsxs(Box, { children: [_jsxs(Text, { color: selected ? "cyan" : "gray", bold: selected, children: [selected ? "› " : "  ", cmd.padEnd(CMD_WIDTH)] }), _jsx(Text, { color: "gray", dimColor: true, children: desc })] }, cmd));
-        }) }));
+const DELEGATION_TOOLS = new Set([
+    "run_subtask",
+    "start_subtask",
+    "run_search"
+]);
+function errorText(error) {
+    return error instanceof Error ? error.message : String(error);
 }
-// ---------------------------------------------------------------------------
-// Help panel
-// ---------------------------------------------------------------------------
-function HelpPanel() {
-    return (_jsxs(Box, { flexDirection: "column", marginLeft: 2, marginTop: 1, marginBottom: 1, children: [_jsx(Text, { color: "gray", dimColor: true, bold: true, children: "Commands" }), Object.entries(COMMANDS).map(([cmd, desc]) => (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: ("  " + cmd).padEnd(16) }), _jsx(Text, { color: "gray", dimColor: true, children: desc })] }, cmd))), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "gray", dimColor: true, children: "  \u2191\u2193 history  \u00B7  Tab complete  \u00B7  Ctrl+C exit" }) })] }));
+function displayResult(name, args, result) {
+    return isFormattedTool(name)
+        ? formatToolResult(name, args, result)
+        : isString(result)
+            ? result
+            : (JSON.stringify(result, null, 2) ?? "Done");
 }
-// ---------------------------------------------------------------------------
-// Main App
-// ---------------------------------------------------------------------------
-export function App({ initialProvider, initialModel, initialAgentMode, initialAgentPlanner = "graph", enabledTools, workspaceDir, wsUrl, extraTools, registry, agentProviders, }) {
+export function App({ initialProvider, initialModel, enabledTools, workspaceDir, wsUrl, registry, agentProviders, costCap, timeout, permissionMode = "default", enableReadOnlySearch = true, resume, sessionStore, mouseEvents }) {
     const { exit } = useApp();
-    // --- State ---
+    const { columns, rows } = useTerminalSize();
     const [provider, setProvider] = useState(initialProvider);
     const [model, setModel] = useState(initialModel);
-    const [agentMode, setAgentMode] = useState(initialAgentMode);
-    const [agentPlanner, setAgentPlanner] = useState(initialAgentPlanner);
+    const [mode, setMode] = useState(permissionMode);
     const [messages, setMessages] = useState([]);
-    const [chatHistory, setChatHistory] = useState([]);
-    const [inputValue, setInputValue] = useState("");
-    const [, setInputHistory] = useState([]);
-    const [, setHistoryIndex] = useState(-1);
-    const [historyDraft, setHistoryDraft] = useState("");
-    const [streaming, setStreaming] = useState(false);
-    const [streamContent, setStreamContent] = useState("");
-    const [streamLabel, setStreamLabel] = useState("");
-    // Buffer messages during streaming to avoid Ink <Static> artifacts
-    const pendingMessagesRef = useRef([]);
-    const streamingRef = useRef(false);
-    const [error, setError] = useState(null);
-    const [showHelp, setShowHelp] = useState(false);
-    const execState = useExecutionState();
-    const [acIndex, setAcIndex] = useState(0);
-    const [modelList, setModelList] = useState([]);
-    // Fetch available models when provider changes
+    const [clearedCount, setClearedCount] = useState(0);
+    const [input, setInput] = useState("");
+    const [busy, setBusy] = useState(false);
+    const [status, setStatus] = useState("Ready");
+    const [live, setLive] = useState("");
+    const [details, setDetails] = useState(false);
+    const [prompt, setPrompt] = useState(null);
+    const [completionIndex, setCompletionIndex] = useState(0);
+    const [models, setModels] = useState([]);
+    const [configuredProviders, setConfiguredProviders] = useState(() => new Set(availableProviders()));
+    const [agentThreads, setAgentThreads] = useState({});
+    const [selectedAgentId, setSelectedAgentId] = useState(null);
+    const [sessions, setSessions] = useState([]);
+    const [todos, setTodos] = useState([]);
+    const [tasks, setTasks] = useState({});
+    const [activeTools, setActiveTools] = useState({});
+    const [elapsed, setElapsed] = useState(0);
+    const [usage, setUsage] = useState("");
+    const [contextTokens, setContextTokens] = useState(null);
+    const refreshContextTokens = () => {
+        setContextTokens(wsUrl ? null : estimatePromptTokens(history.current));
+    };
+    const [connection, setConnection] = useState(wsUrl ? "Connecting" : "Local");
+    const [sessionId, setSessionId] = useState(newSessionId);
+    const [historyIndex, setHistoryIndex] = useState(-1);
+    const [inputHistory, setInputHistory] = useState([]);
+    const [draft, setDraft] = useState("");
+    const store = useRef(sessionStore ?? new ChatSessionStore());
+    const prompts = useRef(new ChatPrompts(setPrompt));
+    const controller = useRef(null);
+    const client = useRef(null);
+    const history = useRef([]);
+    const transcript = useRef([]);
+    const agentThreadsRef = useRef({});
+    const stream = useRef("");
+    const thread = useRef(newSessionId());
+    const providerSession = useRef(null);
+    const sessionAllow = useRef(new Set());
+    const active = useRef(false);
+    const mounted = useRef(true);
+    const scrollGeneration = useRef(0);
+    const [scrollKey, setScrollKey] = useState("0");
+    function updateMessages(next) {
+        transcript.current = next;
+        setMessages(next);
+    }
+    function updateAgentThread(id, update) {
+        const next = {
+            ...agentThreadsRef.current,
+            [id]: update(agentThreadsRef.current[id])
+        };
+        agentThreadsRef.current = next;
+        setAgentThreads(next);
+    }
+    function startAgentThread(id, name, args, parentId, depth = 1) {
+        if (!DELEGATION_TOOLS.has(name) || agentThreadsRef.current[id]) {
+            return;
+        }
+        const title = [args.description, args.query, args.task].find(isString);
+        const thread = {
+            id,
+            title: title || friendlyToolName(name),
+            depth,
+            status: "running",
+            messages: []
+        };
+        if (parentId) {
+            Object.assign(thread, { parentId });
+        }
+        updateAgentThread(id, () => thread);
+    }
+    function appendAgentMessage(id, message, status) {
+        updateAgentThread(id, (thread) => {
+            const next = {
+                ...(thread ?? {
+                    id,
+                    title: "Sub-agent",
+                    depth: 1,
+                    status: "running",
+                    messages: []
+                }),
+                messages: [...(thread?.messages ?? []), message]
+            };
+            if (status) {
+                Object.assign(next, { status });
+            }
+            return next;
+        });
+    }
+    function agentEvent(message) {
+        const tags = parseSubAgentEventTags(message);
+        if (!tags) {
+            return;
+        }
+        const { parentId, depth } = tags;
+        if (message.type === "tool_call_update" &&
+            message.tool_call_id &&
+            DELEGATION_TOOLS.has(message.name)) {
+            startAgentThread(message.tool_call_id, message.name, message.args, parentId, depth + 1);
+        }
+        let content;
+        let role = "system";
+        let status;
+        if (message.type === "chunk" && isString(message.content)) {
+            if (!message.thinking && message.content) {
+                content = message.content;
+                role = "assistant";
+            }
+        }
+        else if (message.type === "tool_call_update") {
+            content = `${friendlyToolName(message.name)}\n${JSON.stringify(message.args, null, 2)}`;
+            role = "tool";
+        }
+        else if (message.type === "tool_result_update") {
+            content = displayResult(message.name ?? "tool", undefined, message.result);
+            role = "tool";
+        }
+        else if (message.type === "planning_update") {
+            content = message.content ?? `Planning: ${message.status}`;
+        }
+        else if (message.type === "task_update") {
+            content = `${message.task.title ?? message.task.id}: ${message.event}`;
+        }
+        else if (message.type === "step_result") {
+            content = message.error
+                ? `Error: ${message.error}`
+                : displayResult("result", undefined, message.result);
+            if (message.is_task_result) {
+                status = message.error ? "failed" : "completed";
+            }
+        }
+        else if (message.type === "error") {
+            content = `Error: ${message.message}`;
+            status = "failed";
+        }
+        if (content) {
+            appendAgentMessage(parentId, { id: newSessionId(), role, content }, status);
+        }
+    }
+    function add(role, content, toolName, toolArgs) {
+        const message = {
+            id: newSessionId(),
+            role,
+            content,
+            toolName,
+            toolArgs
+        };
+        updateMessages([...transcript.current, message]);
+        if (role === "assistant") {
+            void renderMarkdown(terminalText(content))
+                .then((rendered) => {
+                if (mounted.current) {
+                    updateMessages(transcript.current.map((item) => item.id === message.id ? { ...item, rendered } : item));
+                }
+            })
+                .catch(() => {
+                /* Raw content stays visible when formatting fails. */
+            });
+        }
+    }
+    function flush() {
+        if (stream.current.trim()) {
+            add("assistant", stream.current);
+        }
+        stream.current = "";
+        setLive("");
+    }
+    function append(text) {
+        stream.current += text;
+        setLive(stream.current);
+    }
+    function latest() {
+        setScrollKey(String(++scrollGeneration.current));
+    }
     useEffect(() => {
-        let cancelled = false;
-        createProvider(provider).then(async (prov) => {
-            try {
-                const models = await prov.getAvailableLanguageModels();
-                if (!cancelled) {
-                    setModelList(models.map((m) => ({ id: m.id, name: m.name })));
+        mounted.current = true;
+        return () => {
+            mounted.current = false;
+            controller.current?.abort();
+        };
+    }, []);
+    useEffect(() => {
+        const abort = new AbortController();
+        setModels([]);
+        if (!wsUrl) {
+            void listConfiguredLanguageModels()
+                .then((catalog) => {
+                if (!abort.signal.aborted) {
+                    setConfiguredProviders(new Set(catalog.providers));
+                    setModels(catalog.models);
                 }
+            })
+                .catch(() => {
+                /* Explicit provider/model specs remain available. */
+            });
+        }
+        return () => abort.abort();
+    }, [wsUrl]);
+    useEffect(() => {
+        if (!wsUrl) {
+            return;
+        }
+        const socket = new WebSocketChatClient(wsUrl);
+        client.current = socket;
+        let cancelled = false;
+        void socket
+            .connect()
+            .then(() => {
+            if (!cancelled) {
+                setConnection("Connected");
             }
-            catch {
-                if (!cancelled)
-                    setModelList([]);
+        })
+            .catch((error) => {
+            if (!cancelled) {
+                setConnection("Disconnected");
+                setStatus(`Connection failed: ${errorText(error)}`);
             }
-        }).catch(() => {
-            if (!cancelled)
-                setModelList([]);
         });
-        return () => { cancelled = true; };
-    }, [provider]);
-    // WebSocket client state (when --url is passed)
-    const wsClientRef = useRef(null);
-    const [threadId, setThreadId] = useState(() => crypto.randomUUID());
-    // Refs to hold latest values without causing re-renders in async callbacks
-    const chatHistoryRef = useRef(chatHistory);
-    const providerRef = useRef(provider);
-    const modelRef = useRef(model);
-    const agentModeRef = useRef(agentMode);
-    const agentPlannerRef = useRef(agentPlanner);
-    const abortRef = useRef(false);
-    const abortControllerRef = useRef(null);
-    // Guard against double-submit: useInput autocomplete Enter + TextInput onSubmit fire for the same keypress
-    const submittingRef = useRef(false);
-    useEffect(() => { chatHistoryRef.current = chatHistory; }, [chatHistory]);
-    useEffect(() => { providerRef.current = provider; }, [provider]);
-    useEffect(() => { modelRef.current = model; }, [model]);
-    useEffect(() => { agentModeRef.current = agentMode; }, [agentMode]);
-    useEffect(() => { agentPlannerRef.current = agentPlanner; }, [agentPlanner]);
-    useEffect(() => { setAcIndex(0); }, [inputValue]);
-    // Connect WebSocket when --url is provided
+        return () => {
+            cancelled = true;
+            socket.disconnect();
+            client.current = null;
+        };
+    }, [wsUrl]);
     useEffect(() => {
-        if (!wsUrl)
+        if (!busy) {
             return;
-        const client = new WebSocketChatClient(wsUrl);
-        client.connect().then(() => {
-            wsClientRef.current = client;
-        }).catch((err) => {
-            const msg = err instanceof Error ? err.message : String(err);
-            addMessage("system", `WebSocket connection failed: ${msg}`);
+        }
+        const started = Date.now();
+        setElapsed(0);
+        const timer = setInterval(() => setElapsed(Math.floor((Date.now() - started) / 1000)), 1000);
+        return () => clearInterval(timer);
+    }, [busy]);
+    useEffect(() => {
+        if (!resume) {
+            return;
+        }
+        let cancelled = false;
+        active.current = true;
+        setBusy(true);
+        void store.current
+            .list(workspaceDir, wsUrl)
+            .then((saved) => {
+            if (cancelled) {
+                return;
+            }
+            const selected = resume === true ? saved[0] : saved.find((item) => item.id === resume);
+            if (!selected) {
+                throw new Error("No matching saved session in this workspace.");
+            }
+            restore(selected);
+        })
+            .catch((error) => {
+            if (!cancelled) {
+                setStatus(errorText(error));
+            }
+        })
+            .finally(() => {
+            if (!cancelled) {
+                active.current = false;
+                setBusy(false);
+            }
         });
         return () => {
-            client.disconnect();
-            wsClientRef.current = null;
+            cancelled = true;
         };
-    }, [wsUrl]);
-    // Unique ID generator
-    const nextId = useRef(0);
-    const genId = () => `msg-${++nextId.current}`;
-    // Add a message to the display history.
-    // During streaming, tool/system messages are buffered to avoid Ink <Static> artifacts.
-    // User and assistant messages (which mark start/end of a turn) are added immediately.
-    const addMessage = useCallback(async (role, content, opts) => {
-        let rendered;
-        if (role === "assistant") {
-            rendered = await renderMarkdown(content);
+    }, [resume, workspaceDir, wsUrl]);
+    function restore(session) {
+        history.current = session.history;
+        refreshContextTokens();
+        providerSession.current = session.providerSession ?? null;
+        thread.current = session.threadId;
+        setSessionId(session.id);
+        setProvider(session.provider);
+        setModel(session.model);
+        updateMessages(session.messages);
+        setClearedCount(0);
+        setInputHistory(session.messages
+            .filter((item) => item.role === "user")
+            .map((item) => item.content)
+            .reverse());
+        sessionAllow.current.clear();
+        setTodos([]);
+        setTasks({});
+        setUsage("");
+        latest();
+        setStatus(`Resumed ${session.title}`);
+    }
+    async function persist() {
+        if (!transcript.current.length) {
+            return;
         }
-        const msg = {
-            id: genId(),
-            role,
-            content,
-            rendered,
-            toolName: opts?.toolName,
-            toolArgs: opts?.toolArgs,
-        };
-        if (streamingRef.current && role !== "user" && role !== "assistant") {
-            pendingMessagesRef.current.push(msg);
+        await store.current.save({
+            version: 1,
+            id: sessionId,
+            threadId: thread.current,
+            title: transcript.current
+                .find((item) => item.role === "user")
+                ?.content.slice(0, 80) ?? "Conversation",
+            updatedAt: new Date().toISOString(),
+            workspace: resolve(workspaceDir),
+            server: wsUrl,
+            provider,
+            model,
+            history: history.current,
+            messages: transcript.current,
+            providerSession: providerSession.current
+        });
+    }
+    async function quit() {
+        try {
+            await persist();
+            await saveSettings({ provider, model });
+            exit();
         }
-        else {
-            setMessages(prev => [...prev, msg]);
+        catch (error) {
+            setStatus(`Could not save session: ${errorText(error)}. Try /export.`);
         }
-    }, []);
-    // Flush buffered messages when streaming ends
-    const flushPendingMessages = useCallback(() => {
-        if (pendingMessagesRef.current.length > 0) {
-            const pending = pendingMessagesRef.current;
-            pendingMessagesRef.current = [];
-            setMessages(prev => [...prev, ...pending]);
+    }
+    function tools() {
+        const belt = [
+            ...buildCliToolbelt(agentProviders ?? {}, registry),
+            new BashTool(workspaceDir)
+        ];
+        return enabledTools
+            ? belt.filter((tool) => enabledTools.includes(tool.name))
+            : belt;
+    }
+    function processEvent(message) {
+        agentEvent(message);
+        if (message.type === "todo_update") {
+            setTodos(message.todos);
         }
-    }, []);
-    // Create tools from enabled list
-    function buildTools() {
-        const toolMap = {
-            // Filesystem
-            read_file: new ReadFileTool(),
-            write_file: new WriteFileTool(),
-            edit_file: new EditFileTool(),
-            list_directory: new ListDirectoryTool(),
-            glob: new GlobTool(),
-            grep: new GrepTool(),
-            // HTTP
-            download_file: new DownloadFileTool(),
-            http_request: new HttpRequestTool(),
-            // Search (SERPAPI)
-            google_search: new GoogleSearchTool(),
-            google_news: new GoogleNewsTool(),
-            google_images: new GoogleImagesTool(),
-            // Browser
-            browser: new BrowserTool(),
-            screenshot: new ScreenshotTool(),
-            // Code & math
-            run_code: new RunCodeTool(),
-            calculator: new CalculatorTool(),
-            statistics: new StatisticsTool(),
-            geometry: new GeometryTool(),
-            conversion: new ConversionTool(),
-            // PDF & documents
-            extract_pdf_text: new ExtractPDFTextTool(),
-            convert_pdf_to_markdown: new ConvertPDFToMarkdownTool(),
-            convert_document: new ConvertDocumentTool(),
-            // OpenAI tools
-            openai_web_search: new OpenAIWebSearchTool(),
-            openai_image_generation: new OpenAIImageGenerationTool(),
-            openai_text_to_speech: new OpenAITextToSpeechTool(),
-            // DataForSEO
-            dataseo_search: new DataForSEOSearchTool(),
-            dataseo_news: new DataForSEONewsTool(),
-            // Email (IMAP)
-            search_email: new SearchEmailTool(),
-            archive_email: new ArchiveEmailTool(),
-        };
-        // NodeTool MCP tools (workflows, nodes, jobs, assets, models).
-        // When a NodeRegistry is in process, this swaps the REST node-search
-        // tools for the local biased versions (and adds `find_model`) so any
-        // agent loop gets the same node-selection bias as the GraphPlanner.
-        for (const tool of getAllMcpTools({
-            registry,
-            providers: agentProviders,
+        else if (message.type === "task_update" && message.task.id) {
+            const id = message.task.id;
+            setTasks((previous) => ({
+                ...previous,
+                [id]: `${message.task.title ?? id}: ${message.event}`
+            }));
+        }
+        else if (message.type === "planning_update") {
+            setStatus(message.content ?? `Planning: ${message.status}`);
+        }
+        else if (message.type === "output_update") {
+            add("system", `Output ${message.node_id}: ${displayResult("output", undefined, message.value)}`);
+        }
+        else if (message.type === "prediction") {
+            setStatus(`Generation: ${message.status ?? "running"}`);
+        }
+        else if (message.type === "chunk" &&
+            isString(message.content) &&
+            !message.thinking) {
+            if (message.parent_tool_call_id || message.subtask_depth) {
+                setStatus(`Subtask: ${message.content.slice(-100)}`);
+            }
+        }
+    }
+    function startTool(id, name, args) {
+        flush();
+        startAgentThread(id, name, args);
+        setActiveTools((previous) => ({ ...previous, [id]: { name, args } }));
+        setStatus(friendlyToolName(name));
+    }
+    function finishTool(id, name, args, result) {
+        if (DELEGATION_TOOLS.has(name) && name !== "start_subtask") {
+            const failed = isRecord(result) && isString(result.error);
+            updateAgentThread(id, (thread) => ({
+                ...(thread ?? {
+                    id,
+                    title: friendlyToolName(name),
+                    depth: 1,
+                    messages: []
+                }),
+                status: failed ? "failed" : "completed"
+            }));
+        }
+        add("tool", displayResult(name, args, result), name, args);
+        setActiveTools((previous) => {
+            const next = { ...previous };
+            delete next[id];
+            return next;
+        });
+        setStatus("Thinking");
+    }
+    async function remoteEvent(event, socket, signal) {
+        if (event.type === "chunk") {
+            append(event.content);
+            setStatus("Responding");
+        }
+        else if (event.type === "assistant_message") {
+            if (event.text) {
+                append(event.text);
+            }
+            const attachments = attachmentLines(event.content);
+            if (attachments.length) {
+                flush();
+                add("system", attachments.join("\n"));
+            }
+        }
+        else if (event.type === "processing") {
+            processEvent(event.message);
+        }
+        else if (event.type === "tool_approval_request") {
+            const answer = await prompts.current.ask({
+                title: `Approve ${event.toolName}`,
+                body: `${event.description || event.message}\n\n${JSON.stringify(event.args, null, 2)}`,
+                choices: APPROVAL_CHOICES
+            }, signal);
+            socket.respondToolApproval(event.approvalId, answer === "allow" || answer === "allow_for_chat" ? answer : "deny");
+        }
+        else if (event.type === "plan_approval_request") {
+            const answer = await prompts.current.ask({
+                title: event.plan.title,
+                body: event.plan.tasks
+                    .map((task) => `${task.title}\n${task.steps.map((step) => `  ${step.instructions}`).join("\n")}`)
+                    .join("\n\n"),
+                choices: [
+                    { key: "y", label: "Execute plan", value: "approve" },
+                    { key: "n", label: "Reject", value: "reject" }
+                ]
+            }, signal);
+            socket.respondPlanApproval(event.approvalId, answer === "approve" ? "approve" : "reject");
+        }
+        else if (event.type === "secret_request") {
+            const answer = await prompts.current.ask({
+                title: `Configure ${event.key}`,
+                body: `${event.description}\n${event.reason}\nConfigure this secret on the connected server, then continue.\n${event.helpUrl ?? ""}`,
+                choices: [
+                    { key: "y", label: "Configured, retry", value: "provided" },
+                    { key: "n", label: "Cancel", value: "cancelled" }
+                ]
+            }, signal);
+            socket.respondSecretRequest(event.approvalId, answer === "provided" ? "saved" : "declined");
+        }
+        else if (event.type === "client_tool_call") {
+            socket.respondToolResult(event.id, event.threadId, {
+                error: `The terminal does not provide browser tool ${event.name}. Use a server tool.`
+            }, false);
+        }
+        else if (event.type === "output_update") {
+            add("system", `Output ${event.node_id}: ${displayResult("output", undefined, event.value)}`);
+        }
+        else if (event.type === "error") {
+            throw new Error(event.message);
+        }
+    }
+    async function compact(instructions, signal) {
+        if (wsUrl) {
+            throw new Error("Remote context is managed by the server. Ask the agent to summarize, or use /new for a fresh thread.");
+        }
+        if (!history.current.length) {
+            setStatus("Nothing to compact");
+            return;
+        }
+        setStatus("Compacting");
+        const prov = await createProvider(provider);
+        let summary = "";
+        for await (const item of prov.generateMessagesTraced({
+            model,
+            signal,
+            messages: [
+                {
+                    role: "user",
+                    content: `Summarize decisions, files, tool results and outstanding work to continue this conversation. ${instructions}\n\n${JSON.stringify(history.current)}`
+                }
+            ]
         })) {
-            toolMap[tool.name] = tool;
-        }
-        // When sandbox tools are present, exclude host tools that have sandbox
-        // equivalents so the agent is forced to execute inside the sandbox.
-        const sandboxMode = extraTools && extraTools.length > 0;
-        const hostToolsToExclude = sandboxMode
-            ? new Set([
-                "read_file",
-                "write_file",
-                "edit_file",
-                "list_directory",
-                "glob",
-                "grep",
-                "run_code",
-                "browser",
-                "screenshot",
-                "google_search",
-                "google_news",
-                "google_images",
-                "dataseo_search",
-                "dataseo_news"
-            ])
-            : null;
-        const enabled = enabledTools
-            .filter(name => name in toolMap && !(hostToolsToExclude?.has(name)))
-            .map(name => toolMap[name]);
-        return extraTools && extraTools.length > 0
-            ? [...enabled, ...extraTools]
-            : enabled;
+            if (signal.aborted) {
+                return;
+            }
+            if ("type" in item && item.type === "chunk" && isString(item.content)) {
+                summary += item.content;
+            }
+        }
+        if (!summary.trim()) {
+            throw new Error("The model returned an empty summary. Context was kept.");
+        }
+        // The first system message is replaced by applySystemPrompt on each turn.
+        history.current = [
+            { role: "system", content: "" },
+            { role: "system", content: `Retained conversation context:\n${summary}` }
+        ];
+        providerSession.current = null;
+        refreshContextTokens();
+        add("system", "Conversation compacted. Context retained.");
     }
-    // ---------------------------------------------------------------------------
-    // Command handler
-    // ---------------------------------------------------------------------------
-    const handleCommand = useCallback(async (raw) => {
-        const parts = raw.trim().split(/\s+/);
-        const cmd = parts[0].toLowerCase();
-        const args = parts.slice(1);
-        switch (cmd) {
+    async function command(value, signal) {
+        const [name = "", ...words] = value.split(/\s+/);
+        const argument = words.join(" ");
+        switch (name.toLowerCase()) {
             case "/help":
-                setShowHelp(prev => !prev);
-                return true;
+                add("system", Object.entries(CHAT_COMMANDS)
+                    .map(([cmd, description]) => `${cmd.padEnd(12)} ${description}`)
+                    .join("\n") +
+                    "\n\nEnter send · Alt+Enter or Ctrl+J newline · Tab complete\n↑↓ history · PgUp/PgDn or wheel scroll · Ctrl+G latest\nDrag transcript text to copy · Ctrl+O tool details\nEsc cancel/dismiss · Ctrl+C cancel/clear/quit");
+                break;
             case "/clear":
-                setMessages([{ id: genId(), role: "system", content: "History cleared." }]);
-                setChatHistory([]);
-                setShowHelp(false);
-                if (wsClientRef.current) {
-                    setThreadId(crypto.randomUUID()); // next message starts a fresh server thread
-                }
-                return true;
-            case "/exit":
-            case "/quit":
-                await saveSettings({ provider, model, agentMode, agentPlanner });
-                exit();
-                return true;
-            case "/agent":
-                setAgentMode(prev => {
-                    const next = !prev;
-                    addMessage("system", `Agent mode ${next ? "ON" : "OFF"}.`);
-                    return next;
-                });
-                return true;
-            case "/planner": {
-                const arg = args[0]?.toLowerCase();
-                if (arg === "graph" || arg === "multi") {
-                    setAgentPlanner(arg);
-                    await saveSettings({ agentPlanner: arg });
-                    addMessage("system", arg === "graph"
-                        ? "Planner set to graph (workflow builder)."
-                        : "Planner set to multi (parallel task plan).");
+                setClearedCount(transcript.current.length);
+                latest();
+                break;
+            case "/new":
+                await persist();
+                history.current = [];
+                refreshContextTokens();
+                providerSession.current = null;
+                updateMessages([]);
+                thread.current = newSessionId();
+                setSessionId(newSessionId());
+                sessionAllow.current.clear();
+                setClearedCount(0);
+                setTodos([]);
+                setTasks({});
+                agentThreadsRef.current = {};
+                setAgentThreads({});
+                setSelectedAgentId(null);
+                setUsage("");
+                latest();
+                break;
+            case "/compact":
+                await compact(argument, signal);
+                break;
+            case "/model":
+                if (!argument) {
+                    setInput("/model ");
+                    break;
                 }
-                else {
-                    addMessage("system", `Current planner: ${agentPlanner}. Usage: /planner graph|multi`);
+                {
+                    const qualified = models.find((item) => `${item.provider}/${item.id}` === argument);
+                    const matchingIds = models.filter((item) => item.id === argument);
+                    if (!qualified && matchingIds.length > 1) {
+                        throw new Error(`Model "${argument}" is available from multiple providers. Choose a provider/model entry.`);
+                    }
+                    const inferred = qualified ?? matchingIds[0];
+                    const separator = argument.indexOf("/");
+                    const explicitProvider = separator > 0 &&
+                        configuredProviders.has(argument.slice(0, separator))
+                        ? argument.slice(0, separator)
+                        : undefined;
+                    const nextProvider = inferred?.provider ?? explicitProvider ?? provider;
+                    const nextModel = inferred
+                        ? inferred.id
+                        : explicitProvider
+                            ? argument.slice(separator + 1)
+                            : argument;
+                    setProvider(nextProvider);
+                    setModel(nextModel);
+                    providerSession.current = null;
+                    await saveSettings({ provider: nextProvider, model: nextModel });
                 }
-                return true;
+                break;
+            case "/agent": {
+                inspectAgent(argument);
+                break;
             }
-            case "/model":
-                if (args[0]) {
-                    setModel(args[0]);
-                    await saveSettings({ model: args[0] });
-                    addMessage("system", `Model set to: ${args[0]}`);
+            case "/mode":
+                setMode(parsePermissionMode(argument) ?? "default");
+                break;
+            case "/sessions": {
+                const saved = await store.current.list(workspaceDir, wsUrl);
+                setSessions(saved);
+                if (!saved.length) {
+                    add("system", "No saved conversations in this workspace yet.");
                 }
                 else {
-                    addMessage("system", `Current model: ${model}. Usage: /model <model-id>`);
-                }
-                return true;
-            case "/provider": {
-                if (args[0]) {
-                    const newProvider = args[0].toLowerCase();
-                    const newModel = DEFAULT_MODELS[newProvider] ?? model;
-                    setProvider(newProvider);
-                    setModel(newModel);
-                    await saveSettings({ provider: newProvider, model: newModel });
-                    addMessage("system", `Provider: ${newProvider} • Model: ${newModel}`);
+                    setInput("/resume ");
                 }
-                else {
-                    addMessage("system", `Current provider: ${provider}. Usage: /provider <name>`);
+                break;
+            }
+            case "/resume": {
+                const saved = await store.current.list(workspaceDir, wsUrl);
+                const selected = argument
+                    ? saved.find((item) => item.id === argument)
+                    : saved[0];
+                if (!selected) {
+                    throw new Error("Session not found. Use /sessions to choose a saved conversation.");
                 }
-                return true;
+                await persist();
+                restore(selected);
+                break;
+            }
+            case "/export": {
+                const path = resolve(workspaceDir, argument || `nodetool-chat-${sessionId}.md`);
+                await writeFile(path, exportTranscript(transcript.current), {
+                    encoding: "utf8",
+                    flag: "wx",
+                    mode: 0o600
+                });
+                add("system", `Exported ${path}`);
+                break;
             }
             case "/tools":
-                addMessage("system", `Enabled tools: ${enabledTools.join(", ") || "(none)"}`);
-                return true;
+                add("system", wsUrl
+                    ? "Connected server manages the toolbelt. Ask the agent to list its available tools."
+                    : tools()
+                        .map((tool) => `${tool.name} — ${tool.description.split("\n")[0]}`)
+                        .join("\n"));
+                break;
+            case "/details":
+                setDetails((previous) => !previous);
+                break;
+            case "/exit":
+            case "/quit":
+                await quit();
+                break;
             default:
-                if (cmd.startsWith("/")) {
-                    addMessage("system", `Unknown command: ${cmd}. Type /help for commands.`);
-                    return true;
-                }
-                return false;
+                throw new Error(`Unknown command: ${name}. Use /help.`);
         }
-    }, [provider, model, agentMode, enabledTools, addMessage, exit]);
-    // ---------------------------------------------------------------------------
-    // Chat submission
-    // ---------------------------------------------------------------------------
-    const handleSubmit = useCallback(async (value) => {
-        const trimmed = value.trim();
-        if (!trimmed)
+    }
+    function inspectAgent(argument) {
+        if (!argument) {
+            const threads = Object.values(agentThreadsRef.current);
+            if (!threads.length) {
+                add("system", "No sub-agent threads in this conversation yet.");
+            }
+            else {
+                setInput("/agent ");
+            }
             return;
-        // Deduplicate: useInput autocomplete Enter + TextInput onSubmit both fire for the same keypress
-        if (submittingRef.current)
+        }
+        if (argument === "main") {
+            setSelectedAgentId(null);
+            latest();
             return;
-        submittingRef.current = true;
-        // Add to history (deduplicated)
-        setInputHistory(prev => {
-            const filtered = prev.filter(h => h !== trimmed);
-            return [trimmed, ...filtered].slice(0, 100);
-        });
-        setHistoryIndex(-1);
-        setHistoryDraft("");
-        setInputValue("");
-        setError(null);
-        setShowHelp(false);
-        // Handle commands
-        if (trimmed.startsWith("/")) {
-            await handleCommand(trimmed);
-            submittingRef.current = false;
+        }
+        const selectedThread = agentThreadsRef.current[argument];
+        if (!selectedThread) {
+            throw new Error(`Unknown sub-agent thread: ${argument}. Use /agent.`);
+        }
+        setSelectedAgentId(selectedThread.id);
+        latest();
+    }
+    async function submit(value) {
+        const trimmed = value.trim();
+        if (!trimmed) {
             return;
         }
-        // Add user message to display
-        await addMessage("user", trimmed);
-        abortRef.current = false;
-        const abortController = new AbortController();
-        abortControllerRef.current = abortController;
-        streamingRef.current = true;
-        setStreaming(true);
-        setStreamContent("");
-        setStreamLabel("thinking");
-        try {
-            const ctx = new ProcessingContext({ jobId: crypto.randomUUID(), userId: "1", workspaceDir, secretResolver: getSecret });
-            const tools = buildTools();
-            if (agentModeRef.current) {
-                // --- Agent mode ---
-                setStreamLabel("planning");
-                execState.reset();
-                const prov = wsClientRef.current
-                    ? new WebSocketProvider(wsClientRef.current, modelRef.current, providerRef.current)
-                    : await createProvider(providerRef.current);
-                // Pick the planner. The "graph" planner needs a registry; without
-                // one we silently downgrade to the multi-task planner.
-                const useGraphPlanner = agentPlannerRef.current === "graph" && !!registry;
-                const markdownOutputSchema = {
-                    type: "object",
-                    properties: {
-                        markdown: {
-                            type: "string",
-                            description: "The markdown content of the response",
-                        },
-                    },
-                    required: ["markdown"],
-                };
-                const agent = new MultiModeAgent({
-                    name: "chat-agent",
-                    objective: trimmed,
-                    provider: prov,
-                    model: modelRef.current,
-                    mode: "plan",
-                    tools,
-                    useGraphPlanner,
-                    registry: useGraphPlanner ? registry : undefined,
-                    providers: useGraphPlanner ? agentProviders : undefined,
-                    maxStepIterations: 20,
-                    outputSchema: markdownOutputSchema,
-                });
-                // Feed all messages into the execution tree state.
-                let synthesisContent = "";
-                for await (const msg of agent.execute(ctx)) {
-                    if (abortRef.current)
-                        break;
-                    execState.processMessage(msg);
-                    // Stream the agent's final synthesis so the user sees the answer
-                    // forming in real time. Other chunks (step thinking, planner
-                    // commentary) are noise in the chat pane and stay in the tree.
-                    if (msg.type === "chunk") {
-                        const ch = msg;
-                        if (ch.node_id === "agent_synthesizer" && ch.content) {
-                            synthesisContent += ch.content;
-                            setStreamContent(synthesisContent);
-                            setStreamLabel("finalizing");
-                        }
-                    }
+        if (active.current) {
+            const [name = "", ...words] = trimmed.split(/\s+/);
+            if (name.toLowerCase() === "/agent") {
+                setInput("");
+                try {
+                    inspectAgent(words.join(" "));
                 }
-                execState.markDone();
-                setStreamContent("");
-                const finalResults = agent.getResults();
-                const finalText = typeof finalResults === "string"
-                    ? finalResults
-                    : finalResults &&
-                        typeof finalResults === "object" &&
-                        "markdown" in finalResults &&
-                        typeof finalResults.markdown ===
-                            "string"
-                        ? finalResults.markdown
-                        : finalResults != null
-                            ? JSON.stringify(finalResults, null, 2)
-                            : "";
-                if (finalText) {
-                    await addMessage("assistant", finalText);
+                catch (error) {
+                    setStatus(errorText(error));
                 }
             }
-            else if (wsClientRef.current && !extraTools?.length) {
-                // --- Regular chat via WebSocket (server handles everything) ---
-                const wsClient = wsClientRef.current;
-                let assistantContent = "";
-                const toolSchemas = tools.map(t => t.toProviderTool());
-                const pendingToolArgs = new Map();
-                for await (const event of wsClient.chat(trimmed, threadId, modelRef.current, providerRef.current, toolSchemas)) {
-                    if (abortRef.current)
+            return;
+        }
+        active.current = true;
+        const abort = new AbortController();
+        controller.current = abort;
+        setBusy(true);
+        setInput("");
+        setStatus("Thinking");
+        latest();
+        setHistoryIndex(-1);
+        setDraft("");
+        setInputHistory((previous) => [value, ...previous.filter((item) => item !== value)].slice(0, 100));
+        let budget;
+        try {
+            if (value.startsWith("/")) {
+                await command(value.trim(), abort.signal);
+                return;
+            }
+            add("user", value);
+            if (wsUrl) {
+                const socket = client.current;
+                if (!socket || connection !== "Connected") {
+                    throw new Error("Server is not connected. Restart chat to reconnect.");
+                }
+                const calls = new Map();
+                for await (const event of socket.chat(value, thread.current, model, provider, undefined, { permissionMode: mode, signal: abort.signal })) {
+                    if (abort.signal.aborted) {
                         break;
-                    if (event.type === "chunk") {
-                        assistantContent += event.content;
-                        setStreamContent(assistantContent);
-                        setStreamLabel("streaming");
                     }
-                    else if (event.type === "tool_call") {
-                        pendingToolArgs.set(event.id, event.args);
-                        setStreamLabel(`tool: ${event.name}`);
+                    if (event.type === "tool_call") {
+                        calls.set(event.id, event);
+                        startTool(event.id, event.name, event.args);
                     }
                     else if (event.type === "tool_result") {
-                        const preview = event.content.length > 100 ? event.content.slice(0, 100) + "…" : event.content;
-                        const args = pendingToolArgs.get(event.id);
-                        pendingToolArgs.delete(event.id);
-                        await addMessage("tool", preview, { toolName: event.name, toolArgs: args });
-                        setStreamLabel("thinking");
-                    }
-                    else if (event.type === "error") {
-                        throw new Error(event.message);
+                        const call = calls.get(event.id);
+                        finishTool(event.id, event.name || call?.name || "tool", call?.args, event.content);
+                        calls.delete(event.id);
                     }
-                    else if (event.type === "done") {
-                        break;
+                    else {
+                        await remoteEvent(event, socket, abort.signal);
                     }
                 }
-                if (assistantContent) {
-                    await addMessage("assistant", assistantContent);
-                }
             }
-            else if (wsClientRef.current && extraTools?.length) {
-                // --- Regular chat via WebSocket inference + local sandbox tool execution ---
-                const prov = new WebSocketProvider(wsClientRef.current, modelRef.current, providerRef.current);
-                let assistantContent = "";
-                const updatedHistory = [...chatHistoryRef.current];
-                await processChat({
-                    userInput: trimmed,
-                    messages: updatedHistory,
-                    model: modelRef.current,
-                    provider: prov,
-                    context: ctx,
-                    tools,
-                    signal: abortController.signal,
-                    callbacks: {
-                        onChunk: (text) => {
-                            if (abortRef.current)
-                                throw new Error("aborted");
-                            assistantContent += text;
-                            setStreamContent(assistantContent);
-                            setStreamLabel("streaming");
-                        },
-                        onToolCall: (tc) => {
-                            setStreamLabel(`tool: ${tc.name}`);
-                        },
-                        onToolResult: (tc, result) => {
-                            const preview = typeof result === "string"
-                                ? result
-                                : JSON.stringify(result).slice(0, 100);
-                            addMessage("tool", preview, { toolName: tc.name, toolArgs: tc.args });
-                        },
-                    },
-                });
-                setChatHistory(updatedHistory);
-                if (assistantContent) {
-                    await addMessage("assistant", assistantContent);
+            else {
+                const ctx = await createChatContext({ workspaceDir });
+                const unsubscribe = ctx.addMessageListener(processEvent);
+                try {
+                    budget = await createCliRunBudget({ costCap, timeout });
+                    const gate = {
+                        mode,
+                        sessionAllow: sessionAllow.current,
+                        requestApproval: async (request) => {
+                            const answer = await prompts.current.ask({
+                                title: `Approve ${request.toolName}`,
+                                body: `${request.description || request.message}\n\n${JSON.stringify(request.args, null, 2)}`,
+                                choices: APPROVAL_CHOICES
+                            }, abort.signal);
+                            return answer === "allow" || answer === "allow_for_chat"
+                                ? answer
+                                : "deny";
+                        }
+                    };
+                    ctx.set(PERMISSION_GATE_CONTEXT_KEY, gate);
+                    ctx.set(RUN_BUDGET_CONTEXT_KEY, budget);
+                    const prov = await createProvider(provider);
+                    const belt = buildCliAgentBelt({
+                        baseTools: tools(),
+                        provider: prov,
+                        model,
+                        forwardMessage: processEvent,
+                        gate,
+                        budget,
+                        readOnlySearch: enableReadOnlySearch,
+                        planning: true
+                    });
+                    const turn = createCliCodeActTurn({
+                        tools: belt,
+                        context: ctx,
+                        signal: abort.signal,
+                        onToolCall: ({ name }) => setStatus(friendlyToolName(name))
+                    });
+                    applySystemPrompt(history.current, turn.systemPrompt);
+                    refreshContextTokens();
+                    const historyStart = history.current.length;
+                    let displayedText = "";
+                    await processChat({
+                        userInput: value,
+                        messages: history.current,
+                        provider: prov,
+                        model,
+                        threadId: thread.current,
+                        providerSession: providerSession.current,
+                        context: ctx,
+                        tools: turn.tools,
+                        signal: abort.signal,
+                        turnBudget: budget,
+                        callbacks: {
+                            onChunk: (text) => {
+                                if (!abort.signal.aborted) {
+                                    displayedText += text;
+                                    append(text);
+                                    setStatus("Responding");
+                                }
+                            },
+                            onToolCall: (call) => startTool(call.id, call.name, call.args),
+                            onToolResult: (call, result) => finishTool(call.id, call.name, call.args, result),
+                            onProviderSession: (session) => {
+                                providerSession.current = session;
+                            }
+                        }
+                    });
+                    const answers = history.current
+                        .slice(historyStart)
+                        .filter((message) => message.role === "assistant");
+                    const finalText = answers
+                        .map((message) => isString(message.content)
+                        ? message.content
+                        : (message.content
+                            ?.flatMap((part) => part.type === "text" ? [part.text] : [])
+                            .join("") ?? ""))
+                        .join("");
+                    if (finalText.startsWith(displayedText)) {
+                        append(finalText.slice(displayedText.length));
+                    }
+                    else if (finalText && !abort.signal.aborted) {
+                        flush();
+                        add("assistant", finalText);
+                    }
+                    const attachments = answers.flatMap((message) => attachmentLines(message.content));
+                    if (attachments.length) {
+                        flush();
+                        add("system", attachments.join("\n"));
+                    }
+                }
+                finally {
+                    unsubscribe();
                 }
             }
-            else {
-                // --- Regular chat mode (direct provider) ---
-                const prov = await createProvider(providerRef.current);
-                let assistantContent = "";
-                const updatedHistory = [...chatHistoryRef.current];
-                await processChat({
-                    userInput: trimmed,
-                    messages: updatedHistory,
-                    model: modelRef.current,
-                    provider: prov,
-                    context: ctx,
-                    tools,
-                    signal: abortController.signal,
-                    callbacks: {
-                        onChunk: (text) => {
-                            if (abortRef.current)
-                                throw new Error("aborted");
-                            assistantContent += text;
-                            setStreamContent(assistantContent);
-                            setStreamLabel("streaming");
-                        },
-                        onToolCall: (tc) => {
-                            setStreamLabel(`tool: ${tc.name}`);
-                        },
-                        onToolResult: (tc, result) => {
-                            const preview = typeof result === "string"
-                                ? result
-                                : JSON.stringify(result).slice(0, 100);
-                            addMessage("tool", preview, { toolName: tc.name, toolArgs: tc.args });
-                        },
-                    },
-                });
-                setChatHistory(updatedHistory);
-                if (assistantContent) {
-                    await addMessage("assistant", assistantContent);
+            flush();
+            refreshContextTokens();
+            if (budget) {
+                setUsage(budgetSummaryLine(budget));
+                const reason = budgetStopReason(budget);
+                if (reason) {
+                    add("system", `Stopped: ${reason}`);
                 }
             }
         }
-        catch (err) {
-            if (!abortRef.current) {
-                const msg = err instanceof Error ? err.message : String(err);
-                setError(msg);
-                await addMessage("system", `Error: ${msg}`);
+        catch (error) {
+            if (!abort.signal.aborted) {
+                add("system", `Error: ${errorText(error)}`);
             }
         }
         finally {
-            streamingRef.current = false;
-            setStreaming(false);
-            setStreamContent("");
-            setStreamLabel("");
-            flushPendingMessages();
-            submittingRef.current = false;
-            abortControllerRef.current = null;
-        }
-    }, [handleCommand, addMessage, flushPendingMessages, workspaceDir, enabledTools]);
-    let acMatches = [];
-    if (!streaming && inputValue.startsWith("/")) {
-        const lower = inputValue.toLowerCase();
-        const spaceIdx = lower.indexOf(" ");
-        if (spaceIdx === -1) {
-            // Command completion: /pro → /provider
-            acMatches = Object.entries(COMMANDS)
-                .filter(([cmd]) => cmd.startsWith(lower))
-                .map(([cmd, desc]) => ({ cmd, desc }));
-        }
-        else {
-            // Argument completion for specific commands
-            const cmd = lower.slice(0, spaceIdx);
-            const arg = lower.slice(spaceIdx + 1);
-            if (cmd === "/provider") {
-                acMatches = KNOWN_PROVIDERS
-                    .filter((p) => p.startsWith(arg))
-                    .map((p) => ({
-                    cmd: p,
-                    desc: DEFAULT_MODELS[p] ?? "",
-                    replaceAll: `/provider ${p}`,
-                }));
-            }
-            else if (cmd === "/model") {
-                acMatches = modelList
-                    .filter((m) => m.id.toLowerCase().startsWith(arg))
-                    .map((m) => ({
-                    cmd: m.id,
-                    desc: m.name !== m.id ? m.name : "",
-                    replaceAll: `/model ${m.id}`,
-                }));
+            flush();
+            refreshContextTokens();
+            if (abort.signal.aborted) {
+                add("system", "Stopped. You can continue this conversation.");
+            }
+            setActiveTools({});
+            if (!value.startsWith("/") || value.startsWith("/compact")) {
+                try {
+                    await persist();
+                }
+                catch (error) {
+                    add("system", `Session could not be saved: ${errorText(error)}`);
+                }
             }
+            controller.current = null;
+            active.current = false;
+            setBusy(false);
+            setStatus("Ready");
         }
     }
-    const acOpen = acMatches.length > 0;
-    useInput((input, key) => {
-        // Escape or Ctrl+C: cancel streaming, or exit when idle
-        if (key.escape || (key.ctrl && input === "c")) {
-            if (streaming) {
-                abortRef.current = true;
-                abortControllerRef.current?.abort();
-                abortControllerRef.current = null;
-                if (wsClientRef.current) {
-                    wsClientRef.current.stop(agentModeRef.current ? undefined : threadId);
+    const completions = [];
+    if (input.startsWith("/") && (!busy || input.startsWith("/agent"))) {
+        const space = input.indexOf(" ");
+        const name = space < 0 ? input : input.slice(0, space);
+        const argument = space < 0 ? "" : input.slice(space + 1).toLowerCase();
+        if (space < 0) {
+            for (const [value, description] of Object.entries(CHAT_COMMANDS)) {
+                if (value.startsWith(name.toLowerCase())) {
+                    completions.push({ value, description });
                 }
-                // Immediately reset UI — don't wait for async cleanup
-                setStreaming(false);
-                setStreamContent("");
-                setStreamLabel("");
-                submittingRef.current = false;
             }
-            else {
-                saveSettings({ provider, model, agentMode }).then(() => exit());
+        }
+        else if (name === "/model") {
+            for (const item of models) {
+                if (`${item.provider} ${item.id} ${item.name}`
+                    .toLowerCase()
+                    .includes(argument)) {
+                    completions.push({
+                        value: `/model ${item.provider}/${item.id}`,
+                        description: item.name
+                    });
+                }
             }
-            return;
         }
-        // During agent streaming, allow tree navigation
-        if (streaming && agentModeRef.current) {
-            if (key.upArrow) {
-                execState.navigate("up");
-                return;
+        else if (name === "/agent") {
+            if (selectedAgentId && "main".includes(argument)) {
+                completions.push({
+                    value: "/agent main",
+                    description: "Return to the main conversation"
+                });
             }
-            if (key.downArrow) {
-                execState.navigate("down");
-                return;
+            for (const thread of Object.values(agentThreads)) {
+                if (`${thread.id} ${thread.title}`.toLowerCase().includes(argument)) {
+                    completions.push({
+                        value: `/agent ${thread.id}`,
+                        description: `${thread.status} · ${thread.title}`
+                    });
+                }
             }
-            if (key.return || key.rightArrow) {
-                execState.toggleExpand();
-                return;
+        }
+        else if (name === "/mode") {
+            for (const modeName of ["default", "auto", "plan"]) {
+                if (modeName.startsWith(argument)) {
+                    completions.push({
+                        value: `/mode ${modeName}`,
+                        description: "Permission mode"
+                    });
+                }
             }
-            if (key.leftArrow) {
-                execState.toggleExpand();
-                return;
+        }
+        else if (name === "/resume") {
+            for (const session of sessions) {
+                if (`${session.id} ${session.title}`.toLowerCase().includes(argument)) {
+                    completions.push({
+                        value: `/resume ${session.id}`,
+                        description: session.title
+                    });
+                }
             }
+        }
+    }
+    const selected = Math.min(completionIndex, Math.max(0, completions.length - 1));
+    function changeInput(value) {
+        setInput(value);
+        setCompletionIndex(0);
+    }
+    function complete(direction) {
+        if (direction === "up" || direction === "down") {
+            setCompletionIndex((selected + (direction === "up" ? -1 : 1) + completions.length) %
+                completions.length);
             return;
         }
-        if (streaming)
-            return; // block other input while streaming
-        // Autocomplete navigation
-        if (acOpen) {
-            if (key.upArrow) {
-                setAcIndex(i => (i <= 0 ? acMatches.length - 1 : i - 1));
-                return;
-            }
-            if (key.downArrow) {
-                setAcIndex(i => (i >= acMatches.length - 1 ? 0 : i + 1));
-                return;
+        const item = completions[selected];
+        if (!item) {
+            return;
+        }
+        if (direction === "accept") {
+            changeInput(item.value + (item.value.includes(" ") ? "" : " "));
+            return;
+        }
+        if (item.value.includes(" ")) {
+            void submit(item.value);
+            return;
+        }
+        if (["/model", "/agent", "/mode", "/resume", "/export"].includes(item.value)) {
+            changeInput(`${item.value} `);
+        }
+        else {
+            void submit(item.value);
+        }
+    }
+    function recall(direction) {
+        if (busy || !inputHistory.length) {
+            return;
+        }
+        if (historyIndex < 0) {
+            setDraft(input);
+        }
+        const next = direction === "up"
+            ? Math.min(historyIndex + 1, inputHistory.length - 1)
+            : Math.max(-1, historyIndex - 1);
+        setHistoryIndex(next);
+        changeInput(next < 0 ? draft : (inputHistory[next] ?? ""));
+    }
+    useInput((keyInput, key) => {
+        // Ink re-registers this handler in an effect after each render, so a key
+        // pressed as a prompt opens can reach the handler from before it. Read the
+        // live prompt rather than the rendered state.
+        const pending = prompts.current.current;
+        if (pending) {
+            const choice = pending.choices.find((item) => item.key === keyInput.toLowerCase());
+            if (choice) {
+                prompts.current.answer(choice.value);
             }
-            if (key.tab) {
-                const selected = acMatches[acIndex] ?? acMatches[0];
-                if (selected)
-                    setInputValue(selected.replaceAll ?? selected.cmd + " ");
-                setAcIndex(0);
-                return;
+            if (key.escape) {
+                prompts.current.answer("cancel");
             }
-            if (key.return) {
-                const selected = acMatches[acIndex] ?? acMatches[0];
-                if (selected) {
-                    const completed = selected.replaceAll ?? selected.cmd + " ";
-                    // Submit complete commands directly; partial ones go into input for editing
-                    if (completed.trimEnd() in COMMANDS) {
-                        handleSubmit(completed);
-                    }
-                    else {
-                        setInputValue(completed);
-                    }
-                    setAcIndex(0);
-                }
+            if (!(key.ctrl && keyInput === "c")) {
                 return;
             }
         }
-        // History navigation (only when autocomplete is closed)
-        if (!acOpen) {
-            if (key.upArrow) {
-                setInputHistory(hist => {
-                    if (hist.length === 0)
-                        return hist;
-                    setHistoryIndex(prev => {
-                        if (prev === -1)
-                            setHistoryDraft(inputValue);
-                        const next = Math.min(prev + 1, hist.length - 1);
-                        setInputValue(hist[next] ?? "");
-                        return next;
-                    });
-                    return hist;
-                });
-                return;
+        if (key.ctrl && keyInput === "o") {
+            setDetails((previous) => !previous);
+            return;
+        }
+        if (key.escape || (key.ctrl && keyInput === "c")) {
+            if (active.current) {
+                controller.current?.abort();
+                setStatus("Stopping…");
             }
-            if (key.downArrow) {
-                setHistoryIndex(prev => {
-                    if (prev <= 0) {
-                        setInputValue(historyDraft);
-                        return -1;
-                    }
-                    const next = prev - 1;
-                    setInputHistory(hist => {
-                        setInputValue(hist[next] ?? "");
-                        return hist;
-                    });
-                    return next;
-                });
-                return;
+            else if (input) {
+                changeInput("");
+            }
+            else if (key.ctrl) {
+                void quit();
             }
         }
     });
-    // ---------------------------------------------------------------------------
-    // Render
-    // ---------------------------------------------------------------------------
-    const statusParts = [
-        provider,
-        model,
-        agentMode ? `agent:${agentPlanner}` : null,
-        wsUrl ? "ws" : null,
-    ].filter(Boolean).join("  ");
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: messages, children: (msg) => (_jsx(Box, { children: _jsx(ChatMessageItem, { msg: msg }) }, msg.id)) }), showHelp && _jsx(HelpPanel, {}), streaming && agentMode && (_jsx(ExecutionTree, { state: execState.state, treeActive: true })), streaming && !agentMode && (() => {
-                // Truncate streaming preview to avoid overflowing the terminal's dynamic area.
-                const maxPreviewLines = Math.max((process.stdout.rows ?? 24) - 4, 5);
-                const lines = streamContent ? streamContent.split("\n") : [];
-                const truncated = lines.length > maxPreviewLines
-                    ? lines.slice(-maxPreviewLines).join("\n")
-                    : streamContent;
-                return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [truncated ? (_jsxs(Box, { children: [_jsx(Text, { color: "green", children: "● " }), _jsx(Text, { children: truncated })] })) : null, _jsx(Box, { children: _jsxs(Text, { color: "gray", dimColor: true, children: ["  ", _jsx(Spinner, { type: "dots" }), " ", streamLabel || "thinking"] }) })] }));
-            })(), error && (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: "red", children: "● " }), _jsx(Text, { color: "red", children: error })] })), acOpen && (_jsx(AutocompleteMenu, { matches: acMatches, selectedIndex: Math.min(acIndex, acMatches.length - 1) })), !streaming && (_jsxs(_Fragment, { children: [_jsx(Box, { children: _jsx(Text, { color: "gray", dimColor: true, children: "─".repeat(process.stdout.columns ?? 80) }) }), _jsxs(Box, { children: [_jsx(Text, { color: "magenta", dimColor: true, bold: true, children: "❯ " }), _jsx(ReadlineInput, { value: inputValue, onChange: setInputValue, onSubmit: handleSubmit })] }), _jsx(Box, { children: _jsx(Text, { color: "gray", dimColor: true, children: "─".repeat(process.stdout.columns ?? 80) }) }), _jsx(Box, { children: _jsxs(Text, { color: "gray", dimColor: true, children: ["  ", statusParts] }) })] }))] }));
+    const sidebarWidth = columns >= 112 ? 30 : 0;
+    const width = Math.max(1, columns - 4 - sidebarWidth);
+    const editorRows = Math.min(5, Math.max(1, terminalLines(input || " ", Math.max(1, columns - 6)).length));
+    const menuRows = Math.min(5, completions.length, Math.max(0, rows - 14));
+    const bodyHeight = Math.max(1, rows - editorRows - menuRows - 8);
+    const menuStart = Math.max(0, selected - menuRows + 1);
+    const work = [
+        ...todos.map((todo) => `${todo.status === "completed" ? "✓" : todo.status === "in_progress" ? "›" : "○"} ${todo.content}`),
+        ...Object.values(tasks),
+        ...Object.values(activeTools).map((tool) => `› ${friendlyToolName(tool.name)}`)
+    ];
+    const selectedAgent = selectedAgentId
+        ? agentThreads[selectedAgentId]
+        : undefined;
+    return (_jsxs(Box, { flexDirection: "column", width: columns, height: rows, overflow: "hidden", paddingX: 1, children: [_jsxs(Box, { height: 1, justifyContent: "space-between", children: [_jsx(Text, { bold: true, color: "cyan", children: "NodeTool" }), _jsxs(Text, { dimColor: true, wrap: "truncate", children: [terminalText(provider), " / ", terminalText(model)] })] }), _jsxs(Text, { dimColor: true, wrap: "truncate", children: [terminalText(workspaceDir), " \u00B7 ", connection, " \u00B7 ", mode] }), _jsx(Text, { dimColor: true, children: "─".repeat(Math.max(1, columns - 2)) }), _jsxs(Box, { height: bodyHeight, flexShrink: 0, children: [prompt ? (_jsxs(Box, { width: width, height: bodyHeight, flexDirection: "column", overflow: "hidden", children: [_jsx(Text, { bold: true, color: "yellow", children: terminalText(prompt.title) }), _jsx(Transcript, { mouseEvents: mouseEvents, screenY: 5, messages: [
+                                    { id: "prompt", role: "system", content: prompt.body }
+                                ], live: "", width: width, height: Math.max(1, bodyHeight - 3), details: true, resetKey: prompt.title, startAtTop: true }), _jsx(Text, { color: "cyan", wrap: "truncate", children: prompt.choices
+                                    .map((choice) => `[${choice.key}] ${choice.label}`)
+                                    .join("  ") }), _jsx(Text, { dimColor: true, children: "Esc dismiss \u00B7 Ctrl+C stop" })] })) : selectedAgent ? (_jsxs(Box, { width: width, height: bodyHeight, flexDirection: "column", overflow: "hidden", children: [_jsxs(Text, { bold: true, color: "cyan", wrap: "truncate", children: [terminalText(selectedAgent.title), " \u00B7 ", selectedAgent.status] }), _jsx(Transcript, { mouseEvents: mouseEvents, screenY: 5, messages: selectedAgent.messages, live: "", width: width, height: Math.max(1, bodyHeight - 2), details: details, resetKey: `${selectedAgent.id}-${scrollKey}` }), _jsx(Text, { dimColor: true, children: "/agent main returns to the conversation" })] })) : (_jsx(Transcript, { mouseEvents: mouseEvents, messages: messages.slice(clearedCount), live: live, width: width, height: bodyHeight, details: details, resetKey: `${sessionId}-${scrollKey}` })), sidebarWidth > 0 && (_jsxs(Box, { width: sidebarWidth, paddingLeft: 2, flexDirection: "column", overflow: "hidden", children: [_jsx(Text, { bold: true, children: "Session" }), _jsx(Text, { dimColor: true, children: sessionId.slice(0, 12) }), _jsx(Text, { children: " " }), _jsx(Text, { bold: true, children: "Context" }), _jsx(Text, { dimColor: true, children: wsUrl
+                                    ? "Managed by server"
+                                    : contextTokens === null
+                                        ? "Not measured yet"
+                                        : `~${contextTokens.toLocaleString()} tokens` }), _jsx(Text, { children: " " }), _jsx(Text, { bold: true, children: "Work" }), _jsx(Text, { dimColor: true, children: terminalLines(terminalText(work.join("\n") || "No active tasks"), sidebarWidth - 2)
+                                    .slice(0, Math.max(1, bodyHeight - 9))
+                                    .join("\n") }), _jsx(Text, { children: " " }), _jsx(Text, { bold: true, children: "Agents" }), _jsx(Text, { dimColor: true, children: terminalLines(terminalText(Object.values(agentThreads)
+                                    .map((thread) => `${thread.status === "running" ? "›" : thread.status === "completed" ? "✓" : "×"} ${thread.title}`)
+                                    .join("\n") || "No sub-agents"), sidebarWidth - 2)
+                                    .slice(0, 5)
+                                    .join("\n") })] }))] }), _jsx(Box, { height: 1, children: _jsxs(Text, { color: prompt ? "yellow" : busy ? "cyan" : "gray", wrap: "truncate", children: [busy && _jsx(Spinner, { type: "dots" }), " ", terminalText(status), busy ? ` · ${elapsed}s · Esc stop` : usage ? ` · ${usage}` : ""] }) }), menuRows > 0 && (_jsx(Box, { height: menuRows, flexDirection: "column", children: completions.slice(menuStart, menuStart + menuRows).map((item, i) => (_jsxs(Text, { color: menuStart + i === selected ? "cyan" : "gray", wrap: "truncate", children: [menuStart + i === selected ? "› " : "  ", terminalText(item.value), " ", terminalText(item.description)] }, item.value))) })), _jsx(Text, { dimColor: true, children: "─".repeat(Math.max(1, columns - 2)) }), _jsxs(Box, { height: editorRows, children: [_jsx(Text, { color: "cyan", children: "\u203A " }), _jsx(ReadlineInput, { value: input, onChange: changeInput, onSubmit: submit, onHistory: recall, onComplete: completions.length ? complete : undefined, width: Math.max(1, columns - 6), maxRows: editorRows, focus: !prompt, placeholder: busy ? "Draft your next message…" : "Ask NodeTool…" })] }), _jsx(Text, { dimColor: true, children: "─".repeat(Math.max(1, columns - 2)) }), _jsx(Text, { dimColor: true, wrap: "truncate", children: columns < 70
+                    ? "Enter send · Ctrl+J newline · /help"
+                    : "Enter send · Alt+Enter newline · Wheel scroll · Drag to copy · /help" })] }));
 }
 //# sourceMappingURL=app.js.map