miii-cli 0.2.9 → 0.3.1

package/dist/tui/components/InputArea.js

@@ -32,11 +32,15 @@ const PLANNING_COMMANDS = [
     { ns: 'plan', name: 'review', description: 'review and critique the plan so far' },
     { ns: 'plan', name: 'done', description: 'exit planning mode' },
 ];
-export function InputArea({ status, skills, cwd, planningMode, onSubmit, onAbort }) {
+const PASTE_MIN_LINES = 3;
+const PASTE_MIN_CHARS = 200;
+export function InputArea({ status, skills, cwd, planningMode, permissionRequest, onPermissionResponse, onSubmit, onAbort }) {
     const [lines, setLines] = useState(['']);
     const [cursor, setCursor] = useState({ row: 0, col: 0 });
     const [overlay, setOverlay] = useState('none');
     const [overlayIdx, setOverlayIdx] = useState(0);
+    const [pasteLines, setPasteLines] = useState(0);
+    const pasteRef = useRef(null);
     const [files, setFiles] = useState([]);
     const filesLoadedRef = useRef(false);
     // built-ins first, then loaded skills (deduplicated by name)
@@ -87,6 +91,8 @@ export function InputArea({ status, skills, cwd, planningMode, onSubmit, onAbort
         setCursor({ row: 0, col: 0 });
         setOverlay('none');
         setOverlayIdx(0);
+        pasteRef.current = null;
+        setPasteLines(0);
     }
     function appendChar(ch) {
         setLines(prev => {
@@ -142,6 +148,18 @@ export function InputArea({ status, skills, cwd, planningMode, onSubmit, onAbort
         setOverlayIdx(0);
     }
     useInput((input, key) => {
+        // Permission prompt intercepts all input
+        if (permissionRequest && onPermissionResponse) {
+            if (input === 'y' || input === 'Y') {
+                onPermissionResponse(true);
+                return;
+            }
+            if (input === 'n' || input === 'N' || key.escape) {
+                onPermissionResponse(false);
+                return;
+            }
+            return;
+        }
         // ESC: close overlay, abort stream, or clear input
         if (key.escape) {
             if (overlay !== 'none') {
@@ -200,7 +218,11 @@ export function InputArea({ status, skills, cwd, planningMode, onSubmit, onAbort
             // backspace/typing falls through to normal handling below
         }
         if (key.return) {
-            const text = fullInput.trim();
+            const typed = fullInput.trim();
+            const pasted = pasteRef.current;
+            const text = pasted
+                ? typed ? `${typed}\n${pasted}` : pasted
+                : typed;
             if (text) {
                 clearInput();
                 onSubmit(text);
@@ -208,6 +230,11 @@ export function InputArea({ status, skills, cwd, planningMode, onSubmit, onAbort
             return;
         }
         if (key.backspace || key.delete) {
+            if (pasteRef.current) {
+                pasteRef.current = null;
+                setPasteLines(0);
+                return;
+            }
             deleteChar();
             // Recompute overlay trigger for updated input
             const r = cursor.row;
@@ -245,6 +272,13 @@ export function InputArea({ status, skills, cwd, planningMode, onSubmit, onAbort
             return;
         }
         if (input && !key.ctrl && !key.meta) {
+            // Detect paste: Ink delivers entire pasted chunk as one input string
+            const lineCount = input.split('\n').length;
+            if (input.length > 1 && (lineCount >= PASTE_MIN_LINES || input.length >= PASTE_MIN_CHARS)) {
+                pasteRef.current = input;
+                setPasteLines(lineCount);
+                return;
+            }
             // Compute prospective new input to decide overlay
             const r = cursor.row;
             const col = cursor.col;
@@ -274,17 +308,21 @@ export function InputArea({ status, skills, cwd, planningMode, onSubmit, onAbort
         }
     });
     const isProcessing = status !== 'idle';
-    const borderColor = isProcessing ? 'yellow' : 'cyan';
-    const hint = isProcessing
-        ? 'esc to abort'
-        : overlay === 'command' && !commandQuery.includes(' ')
-            ? '↑↓ navigate  enter select  esc close'
-            : overlay === 'at'
-                ? '↑↓ navigate  enter select  esc close'
-                : planningMode
-                    ? '📋 planning mode  / suggestions  enter send  /plan:done to exit'
-                    : '@ file  / command  enter send  ctrl+c exit';
-    return (_jsxs(Box, { flexDirection: "column", children: [overlay === 'command' && (_jsx(CommandPalette, { skills: allCommands, query: commandQuery, idx: overlayIdx })), overlay === 'at' && (_jsx(AtPicker, { files: filteredFiles, query: atQuery, idx: overlayIdx })), _jsxs(Box, { borderStyle: "round", borderColor: borderColor, paddingX: 1, flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: borderColor, bold: true, children: '❯ ' }), _jsx(Box, { flexDirection: "column", flexGrow: 1, children: lines.length === 1 && !lines[0] ? (_jsx(Text, { color: isActive ? 'white' : 'gray', dimColor: isProcessing, children: isActive ? '█' : 'processing...' })) : (lines.map((line, i) => (_jsx(Text, { wrap: "wrap", children: i === cursor.row
+    const borderColor = permissionRequest ? 'yellow' : isProcessing ? 'yellow' : 'cyan';
+    const hint = permissionRequest
+        ? 'y approve  n deny'
+        : isProcessing
+            ? 'esc to abort'
+            : pasteLines > 0
+                ? 'backspace removes paste  enter to send'
+                : overlay === 'command' && !commandQuery.includes(' ')
+                    ? '↑↓ navigate  enter select  esc close'
+                    : overlay === 'at'
+                        ? '↑↓ navigate  enter select  esc close'
+                        : planningMode
+                            ? '📋 planning mode  / suggestions  enter send  /plan:done to exit'
+                            : '@ file  / command  enter send  ctrl+c exit';
+    return (_jsxs(Box, { flexDirection: "column", children: [overlay === 'command' && (_jsx(CommandPalette, { skills: allCommands, query: commandQuery, idx: overlayIdx })), overlay === 'at' && (_jsx(AtPicker, { files: filteredFiles, query: atQuery, idx: overlayIdx })), _jsxs(Box, { borderStyle: "round", borderColor: borderColor, paddingX: 1, flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: borderColor, bold: true, children: '❯ ' }), _jsx(Box, { flexDirection: "column", flexGrow: 1, children: permissionRequest ? (_jsxs(Box, { gap: 2, children: [_jsx(Text, { color: "green", bold: true, children: "y  yes" }), _jsx(Text, { color: "red", bold: true, children: "n  no" })] })) : pasteLines > 0 ? (_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: "cyan", children: "\u2398" }), _jsxs(Text, { color: "cyan", children: ["pasted ", pasteLines, " lines"] }), (lines.length > 1 || lines[0]) && (_jsx(Text, { color: "gray", dimColor: true, children: "+ typed text" }))] })) : lines.length === 1 && !lines[0] ? (_jsx(Text, { color: isActive ? 'white' : 'gray', dimColor: isProcessing, children: isActive ? '█' : 'processing...' })) : (lines.map((line, i) => (_jsx(Text, { wrap: "wrap", children: i === cursor.row
                                         ? renderLineWithCursor(line, cursor.col, isActive)
                                         : line }, i)))) })] }), _jsx(Text, { color: "gray", dimColor: true, children: hint })] })] }));
 }

package/dist/tui/deepThink.js

@@ -0,0 +1,94 @@
+import { chat } from '../llm/stream.js';
+import { tools as staticTools } from '../tools/index.js';
+import { StreamParser } from '../parser/stream-parser.js';
+const ALLOWED_TOOLS = new Set([
+    'read_file', 'list_files', 'web_search', 'web_extract',
+    'git_status', 'git_log', 'git_diff',
+]);
+const MAX_DEPTH = 6;
+const MAX_WEB = 4;
+export async function runDeepThink(query, config, model, signal, onStep) {
+    const gatherTools = staticTools.filter(t => ALLOWED_TOOLS.has(t.name));
+    const toolDocs = gatherTools.map(t => `- ${t.name}(${t.params}): ${t.description}`).join('\n');
+    const sysPrompt = `You are a research agent. Gather information to answer: "${query}"
+
+Available tools (read-only — no file writes, no mutations):
+${toolDocs}
+
+Guardrails:
+- Max ${MAX_DEPTH} tool calls total
+- Max ${MAX_WEB} web calls (web_search + web_extract combined)
+- No file edits, no shell commands that modify state
+- When you have enough info, output a detailed plain-text research summary
+- No markdown formatting in output`;
+    const messages = [
+        { role: 'system', content: sysPrompt },
+        { role: 'user', content: `Research and gather all relevant information for: ${query}` },
+    ];
+    let depth = 0;
+    let webCalls = 0;
+    let totalCalls = 0;
+    let findings = '';
+    async function gather(msgs) {
+        if (depth >= MAX_DEPTH)
+            return;
+        depth++;
+        let fullText = '';
+        await chat({
+            provider: config.provider,
+            model,
+            baseUrl: config.baseUrl,
+            apiKey: config.apiKey,
+            messages: msgs,
+            signal,
+            async onDone(text) { fullText = text; },
+            onError(err) { if (err.name !== 'AbortError')
+                throw err; },
+        });
+        if (!fullText)
+            return;
+        const pending = [];
+        const parser = new StreamParser();
+        for (const item of [...parser.feed(fullText), ...parser.flush()]) {
+            if (item.type === 'tool_call')
+                pending.push({ name: item.toolName, args: item.toolArgs });
+        }
+        if (!pending.length) {
+            findings = fullText;
+            return;
+        }
+        const next = [...msgs, { role: 'assistant', content: fullText }];
+        for (const tc of pending) {
+            if (!ALLOWED_TOOLS.has(tc.name)) {
+                next.push({ role: 'user', content: `Tool "${tc.name}" not permitted in research phase.` });
+                continue;
+            }
+            const isWeb = tc.name === 'web_search' || tc.name === 'web_extract';
+            if (isWeb && webCalls >= MAX_WEB) {
+                next.push({ role: 'user', content: `Web call limit (${MAX_WEB}) reached. Summarize findings now.` });
+                continue;
+            }
+            if (totalCalls >= MAX_DEPTH) {
+                next.push({ role: 'user', content: `Tool call limit (${MAX_DEPTH}) reached. Summarize findings now.` });
+                continue;
+            }
+            const tool = gatherTools.find(t => t.name === tc.name);
+            if (!tool)
+                continue;
+            onStep?.(tc.name);
+            totalCalls++;
+            if (isWeb)
+                webCalls++;
+            try {
+                const result = await tool.execute(tc.args);
+                next.push({ role: 'user', content: `Tool ${tc.name} result:\n${result}` });
+            }
+            catch (e) {
+                next.push({ role: 'user', content: `Tool ${tc.name} error: ${e}` });
+            }
+        }
+        await gather(next);
+    }
+    await gather(messages);
+    return { findings, toolCalls: totalCalls, webCalls };
+}

package/dist/tui/git-context.js

@@ -0,0 +1,59 @@
+import { readFile } from '../files/ops.js';
+import { resolve } from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const gitRun = promisify(exec);
+const CODE_PATTERN = /\.(ts|js|tsx|jsx|py|go|rs|java|rb|sh|css|html|json|yaml|yml)\b|function|class|import|export|const|let|var|def |async|await|error|bug|fix|refactor|implement|`[^`]+`/i;
+export function looksCodeRelated(text) {
+    return text.length >= 10 && CODE_PATTERN.test(text);
+}
+export async function buildGitContext(cwd, lastStatusRef) {
+    try {
+        const { stdout } = await gitRun('git status --short', { cwd, timeout: 5000 });
+        const status = stdout.trim();
+        if (!status || status === lastStatusRef.current)
+            return { prefix: '', label: '' };
+        lastStatusRef.current = status;
+        const MAX_TOTAL = 40_000;
+        const MAX_FILE = 15_000;
+        let total = 0;
+        const parts = [];
+        const skipped = [];
+        for (const line of status.split('\n')) {
+            const code = line.slice(0, 2);
+            if (code.includes('D'))
+                continue;
+            const raw = line.slice(3).trim().replace(/^"|"$/g, '');
+            const rel = raw.includes(' -> ') ? raw.split(' -> ')[1] : raw;
+            if (!rel)
+                continue;
+            try {
+                const content = readFile(resolve(cwd, rel));
+                if (!content || content.length > MAX_FILE) {
+                    skipped.push(rel);
+                    continue;
+                }
+                total += content.length;
+                if (total > MAX_TOTAL) {
+                    skipped.push(rel);
+                    continue;
+                }
+                parts.push(`<file path="${rel}">\n${content}\n</file>`);
+            }
+            catch {
+                skipped.push(rel);
+            }
+        }
+        if (!parts.length && !skipped.length)
+            return { prefix: '', label: '' };
+        let prefix = '[Auto-context: git-changed files]\n' + parts.join('\n') + '\n';
+        if (skipped.length)
+            prefix += `Files changed but too large to auto-load: ${skipped.join(', ')}\n`;
+        prefix += '\n';
+        const label = `auto-loaded ${parts.length} changed file(s)${skipped.length ? `, skipped ${skipped.length} (too large)` : ''}`;
+        return { prefix, label };
+    }
+    catch {
+        return { prefix: '', label: '' };
+    }
+}

package/dist/tui/hooks/useModelPicker.js

@@ -0,0 +1,63 @@
+import { useState, useRef, useCallback, useEffect } from 'react';
+import { listModels, pullModel } from '../../llm/ollama.js';
+import * as printer from '../printer.js';
+export function useModelPicker(config) {
+    const [currentModel, setCurrentModel] = useState(config.model);
+    const currentModelRef = useRef(config.model);
+    const [pickerOpen, setPickerOpen] = useState(true);
+    const [pickerModels, setPickerModels] = useState([]);
+    const [pickerLoading, setPickerLoading] = useState(false);
+    const [pickerError, setPickerError] = useState();
+    const [pullState, setPullState] = useState();
+    const pullAbortRef = useRef(null);
+    useEffect(() => { currentModelRef.current = currentModel; }, [currentModel]);
+    useEffect(() => {
+        setPickerLoading(true);
+        listModels(config.baseUrl)
+            .then(m => { setPickerModels(m); setPickerLoading(false); })
+            .catch(e => { setPickerError(String(e)); setPickerLoading(false); });
+    }, []);
+    const openPicker = useCallback(async () => {
+        setPickerOpen(true);
+        setPickerLoading(true);
+        setPickerError(undefined);
+        try {
+            setPickerModels(await listModels(config.baseUrl));
+        }
+        catch (e) {
+            setPickerError(String(e));
+        }
+        finally {
+            setPickerLoading(false);
+        }
+    }, [config.baseUrl]);
+    const handleModelSelect = useCallback((name) => {
+        setCurrentModel(name);
+        currentModelRef.current = name;
+        setPickerOpen(false);
+        printer.systemMsg(`model → ${name}`);
+    }, []);
+    const handleModelPull = useCallback(async (name) => {
+        setPullState({ name, status: 'starting...', pct: undefined });
+        pullAbortRef.current = new AbortController();
+        try {
+            await pullModel(config.baseUrl, name, (s, p) => setPullState({ name, status: s, pct: p }), pullAbortRef.current.signal);
+            setPickerModels(await listModels(config.baseUrl));
+            setPullState(undefined);
+            setCurrentModel(name);
+            currentModelRef.current = name;
+            setPickerOpen(false);
+            printer.systemMsg(`pulled ${name} → active`);
+        }
+        catch (e) {
+            setPullState(undefined);
+            setPickerError(`pull failed: ${e}`);
+        }
+    }, [config.baseUrl]);
+    return {
+        currentModel, setCurrentModel, currentModelRef,
+        pickerOpen, setPickerOpen,
+        pickerModels, pickerLoading, pickerError, pullState,
+        openPicker, handleModelSelect, handleModelPull,
+    };
+}

package/dist/tui/hooks/useRunLoop.js

@@ -0,0 +1,173 @@
+import { useState, useRef, useCallback, useEffect } from 'react';
+import { chat } from '../../llm/stream.js';
+import { tools as staticTools } from '../../tools/index.js';
+import { StreamParser, extractBareToolCall } from '../../parser/stream-parser.js';
+import { shouldCompact, compactContext } from '../../tasks/compactor.js';
+import * as printer from '../printer.js';
+const MAX_TOOL_DEPTH = 6;
+const FILE_EDIT_TOOLS = new Set(['edit_file', 'create_file', 'patch_file', 'delete_file']);
+const SHOW_RESULT_TOOLS = new Set(['run_tests', 'git_commit']);
+const PERMISSION_TOOLS = new Set(['edit_file', 'patch_file', 'delete_file', 'create_file', 'move_file', 'run_command', 'git_commit']);
+export function useRunLoop(config, currentModelRef, pushHistory, extraTools = [], abortRef) {
+    const [status, setStatus] = useState('idle');
+    const [tick, setTick] = useState(0);
+    const [currentTool, setCurrentTool] = useState();
+    const [taskLabel, setTaskLabel] = useState();
+    const [permissionRequest, setPermissionRequest] = useState(null);
+    const permissionResolveRef = useRef(null);
+    const thinkingStartRef = useRef(0);
+    const extraToolsRef = useRef(extraTools);
+    extraToolsRef.current = extraTools;
+    const pushHistoryRef = useRef(pushHistory);
+    useEffect(() => { pushHistoryRef.current = pushHistory; }, [pushHistory]);
+    const resolvePermission = useCallback((approved) => {
+        permissionResolveRef.current?.(approved);
+        permissionResolveRef.current = null;
+        setPermissionRequest(null);
+    }, []);
+    useEffect(() => {
+        if (status === 'idle')
+            return;
+        const t = setInterval(() => setTick(n => n + 1), 80);
+        return () => clearInterval(t);
+    }, [status]);
+    const runLoop = useCallback(async (contextMsgs, depth = 0, goal) => {
+        if (depth >= MAX_TOOL_DEPTH) {
+            setStatus('idle');
+            return;
+        }
+        setStatus('thinking');
+        if (depth === 0)
+            thinkingStartRef.current = Date.now();
+        const msgs = shouldCompact(contextMsgs) ? compactContext(contextMsgs, goal) : contextMsgs;
+        abortRef.current = new AbortController();
+        await chat({
+            provider: config.provider,
+            model: currentModelRef.current,
+            baseUrl: config.baseUrl,
+            messages: msgs,
+            signal: abortRef.current.signal,
+            async onDone(fullText) {
+                const pendingTools = [];
+                const textParts = [];
+                const parser = new StreamParser();
+                for (const item of [...parser.feed(fullText), ...parser.flush()]) {
+                    if (item.type === 'tool_call')
+                        pendingTools.push({ name: item.toolName, args: item.toolArgs });
+                    else
+                        textParts.push(item.content);
+                }
+                if (!pendingTools.length) {
+                    const bare = extractBareToolCall(fullText);
+                    if (bare)
+                        pendingTools.push({ name: bare.name, args: bare.args });
+                }
+                const displayText = textParts.join('').trim();
+                if (displayText)
+                    printer.assistantMsg(displayText);
+                pushHistoryRef.current({ role: 'assistant', content: fullText });
+                if (!pendingTools.length) {
+                    const hasFencedCode = /```[\w]*\n[\s\S]{50,}?\n```/.test(fullText);
+                    if (hasFencedCode && depth < MAX_TOOL_DEPTH - 1) {
+                        const nudge = {
+                            role: 'user',
+                            content: 'You showed code in your response but did not use any file tools. Use edit_file or patch_file to actually write the changes to disk.',
+                        };
+                        await runLoop([...msgs, { role: 'assistant', content: fullText }, nudge], depth + 1, goal);
+                        return;
+                    }
+                    setStatus('idle');
+                    return;
+                }
+                setStatus('tool');
+                const next = [...msgs, { role: 'assistant', content: fullText }];
+                try {
+                    for (const tc of pendingTools) {
+                        const allTools = [...staticTools, ...extraToolsRef.current];
+                        const tool = allTools.find(t => t.name === tc.name);
+                        setCurrentTool(tc.name);
+                        if (PERMISSION_TOOLS.has(tc.name)) {
+                            const approved = await new Promise(resolve => {
+                                permissionResolveRef.current = resolve;
+                                setPermissionRequest({ toolName: tc.name, args: tc.args });
+                            });
+                            if (!approved) {
+                                printer.systemMsg(`denied: ${tc.name}`);
+                                next.push({ role: 'user', content: `Tool ${tc.name} was denied by the user` });
+                                break;
+                            }
+                        }
+                        if (tool) {
+                            try {
+                                printer.toolCallStart(tc.name, tc.args);
+                                const result = await tool.execute(tc.args);
+                                if (SHOW_RESULT_TOOLS.has(tc.name))
+                                    printer.toolMsg(tc.name, result);
+                                next.push({ role: 'user', content: `Tool ${tc.name} result:\n${result}` });
+                            }
+                            catch (e) {
+                                const err = `Tool ${tc.name} error: ${e}`;
+                                printer.errorMsg(err);
+                                next.push({ role: 'user', content: err });
+                            }
+                        }
+                        else {
+                            printer.errorMsg(`unknown tool: ${tc.name}`);
+                            next.push({ role: 'user', content: `unknown tool: ${tc.name}` });
+                        }
+                    }
+                }
+                finally {
+                    setCurrentTool(undefined);
+                }
+                // Auto-run tests after file edits
+                const didEditFiles = pendingTools.some(tc => FILE_EDIT_TOOLS.has(tc.name));
+                if (didEditFiles) {
+                    const testTool = staticTools.find(t => t.name === 'run_tests');
+                    if (testTool) {
+                        setCurrentTool('run_tests');
+                        try {
+                            printer.toolCallStart('run_tests', {});
+                            const testResult = await testTool.execute({});
+                            if (testResult && !testResult.startsWith('(no test script') && !testResult.startsWith('(no package.json')) {
+                                printer.toolMsg('run_tests', testResult);
+                                next.push({ role: 'user', content: `Test results after edits:\n${testResult}` });
+                            }
+                        }
+                        catch (e) {
+                            const err = `run_tests error: ${e}`;
+                            printer.errorMsg(err);
+                            next.push({ role: 'user', content: err });
+                        }
+                        finally {
+                            setCurrentTool(undefined);
+                        }
+                    }
+                }
+                await runLoop(next, depth + 1, goal);
+            },
+            onError(err) {
+                if (err.name !== 'AbortError')
+                    printer.errorMsg(err.message);
+                setStatus('idle');
+            },
+        });
+    }, [config]);
+    const handleAbort = useCallback(() => {
+        abortRef.current?.abort();
+        if (permissionResolveRef.current) {
+            permissionResolveRef.current(false);
+            permissionResolveRef.current = null;
+            setPermissionRequest(null);
+        }
+        setStatus('idle');
+    }, []);
+    return {
+        status, setStatus, tick,
+        currentTool, setCurrentTool,
+        taskLabel, setTaskLabel,
+        thinkingStartRef,
+        runLoop, handleAbort,
+        permissionRequest, resolvePermission,
+    };
+}

package/dist/tui/hooks/useSession.js

@@ -0,0 +1,93 @@
+import { useState, useRef, useEffect } from 'react';
+import { loadSession, saveSession, deleteSession } from '../../sessions.js';
+import { getSystemPrompt } from '../../tools/index.js';
+import { getTavilyKey, saveTavilyKey } from '../../tavily/client.js';
+import * as printer from '../printer.js';
+import { loadLongMemory, saveLongMemory, mergeFacts, formatMemoryBlock } from '../../memory/store.js';
+import { extractFacts } from '../../memory/extractor.js';
+const SHORT_MEMORY_SIZE = 40;
+function buildSystemPrompt(cwd, facts) {
+    return getSystemPrompt(`\n- CWD: ${cwd}`) + formatMemoryBlock(facts);
+}
+export function useSession(initialSession, cwd, config) {
+    const [sessionName, setSessionName] = useState(initialSession);
+    const sessionNameRef = useRef(initialSession);
+    const historyRef = useRef([]);
+    const saveTimerRef = useRef(null);
+    const firstMessageSentRef = useRef(false);
+    const longMemoryRef = useRef([]);
+    const systemPromptRef = useRef(buildSystemPrompt(cwd, []));
+    useEffect(() => { sessionNameRef.current = sessionName; }, [sessionName]);
+    useEffect(() => {
+        const facts = loadLongMemory(initialSession);
+        longMemoryRef.current = facts;
+        systemPromptRef.current = buildSystemPrompt(cwd, facts);
+        if (facts.length)
+            printer.systemMsg(`long memory: ${facts.length} facts loaded`);
+        const history = loadSession(initialSession);
+        historyRef.current = history;
+        if (history.length)
+            printer.systemMsg(`resumed "${initialSession}" — ${history.length} messages`);
+        if (config.tavilyApiKey && !getTavilyKey())
+            saveTavilyKey(config.tavilyApiKey);
+        if (!getTavilyKey()) {
+            printer.systemMsg('Tavily API key not set — web search disabled. Run /tavily-key <key> to enable. Get a free key at https://tavily.com');
+        }
+    }, []);
+    function scheduleSave() {
+        if (saveTimerRef.current)
+            clearTimeout(saveTimerRef.current);
+        saveTimerRef.current = setTimeout(() => {
+            saveSession(sessionNameRef.current, historyRef.current);
+            saveTimerRef.current = null;
+        }, 2000);
+    }
+    function pushHistory(msg) {
+        historyRef.current.push(msg);
+        if (historyRef.current.length > SHORT_MEMORY_SIZE) {
+            const dropped = historyRef.current.splice(0, historyRef.current.length - SHORT_MEMORY_SIZE);
+            extractFacts(dropped, config, config.model).then(newFacts => {
+                if (!newFacts.length)
+                    return;
+                const updated = mergeFacts(longMemoryRef.current, newFacts);
+                longMemoryRef.current = updated;
+                systemPromptRef.current = buildSystemPrompt(cwd, updated);
+                saveLongMemory(sessionNameRef.current, updated);
+            });
+        }
+        scheduleSave();
+    }
+    function renameFromMessage(text) {
+        if (firstMessageSentRef.current)
+            return;
+        firstMessageSentRef.current = true;
+        const slug = text
+            .toLowerCase()
+            .split(/\s+/)
+            .slice(0, 5)
+            .join('-')
+            .replace(/[^\w-]/g, '')
+            .replace(/-+/g, '-')
+            .replace(/^-|-$/g, '')
+            .slice(0, 40) || 'chat';
+        const oldName = sessionNameRef.current;
+        sessionNameRef.current = slug;
+        setSessionName(slug);
+        try {
+            deleteSession(oldName);
+        }
+        catch { }
+    }
+    function buildContext(extra) {
+        const ctx = [{ role: 'system', content: systemPromptRef.current }];
+        ctx.push(...historyRef.current);
+        if (extra)
+            ctx.push(extra);
+        return ctx;
+    }
+    return {
+        sessionName, setSessionName, sessionNameRef,
+        historyRef, saveTimerRef, systemPromptRef,
+        pushHistory, buildContext, renameFromMessage,
+    };
+}

package/dist/tui/printer.js

@@ -1,4 +1,12 @@
 // ANSI-formatted stdout output — goes into terminal scrollback
+let _inkClear = null;
+export function setInkInstance(clear) {
+    _inkClear = clear;
+}
+function write(s) {
+    _inkClear?.();
+    process.stdout.write(s);
+}
 const R = '\x1b[0m';
 const BOLD = '\x1b[1m';
 const DIM = '\x1b[2m';
@@ -55,7 +63,7 @@ function formatContent(text) {
 function truncate(s, n) {
     return s.length > n ? s.slice(0, n) + '…' : s;
 }
-function toolArgSummary(args) {
+export function toolArgSummary(args) {
     if (args.message)
         return `"${truncate(String(args.message), 60)}"`;
     if (args.path)
@@ -134,7 +142,7 @@ export function welcome(provider, model, cwd, version, updateAvailable, linked)
 }
 export function userMsg(text) {
     const atHighlighted = text.replace(/(@[\w./\-]+)/g, (m) => cyan(m));
-    console.log(`\n${gray('>>')} ${atHighlighted}`);
+    write(`\n${gray('>>')} ${atHighlighted}\n`);
 }
 export function assistantMsg(text) {
     const content = formatContent(text);
@@ -146,14 +154,14 @@ export function assistantMsg(text) {
         return;
     const head = lines[idx].replace(/^ {2}/, '');
     const tail = lines.slice(idx + 1).join('\n');
-    console.log(`\n${blue('●')} ${head}${tail ? '\n' + tail : ''}`);
+    write(`\n${blue('●')} ${head}${tail ? '\n' + tail : ''}\n`);
 }
 const EDIT_TOOLS = new Set(['edit_file', 'patch_file', 'create_file', 'write_file']);
 const DELETE_TOOLS = new Set(['delete_file', 'remove_file']);
 export function toolCallStart(name, args) {
     const summary = toolArgSummary(args);
     const dot = DELETE_TOOLS.has(name) ? red('●') : EDIT_TOOLS.has(name) ? green('●') : blue('●');
-    process.stdout.write(`  ${dot} ${cyan(name)}${summary ? gray('(' + summary + ')') : ''}\n`);
+    write(`  ${dot} ${cyan(name)}${summary ? gray('(' + summary + ')') : ''}\n`);
 }
 export function toolMsg(name, result) {
     const preview = result.length > 250 ? result.slice(0, 250) + '…' : result;
@@ -161,15 +169,15 @@ export function toolMsg(name, result) {
         ? preview.split('\n').map(l => gray('    ' + l)).join('\n')
         : '';
     if (body)
-        console.log(body);
+        write(body + '\n');
 }
 export function systemMsg(text) {
-    console.log(gray(`─ ${text}`));
+    write(gray(`─ ${text}`) + '\n');
 }
 export function errorMsg(text) {
-    console.log(gray(`error: ${text}`));
+    write(gray(`error: ${text}`) + '\n');
 }
 export function divider() {
     const cols = process.stdout.columns ?? 80;
-    process.stdout.write(`${gray('─'.repeat(cols))}\n`);
+    write(`${gray('─'.repeat(cols))}\n`);
 }