miii-cli 0.2.9 → 0.3.0

package/README.md

@@ -9,19 +9,23 @@
 [![license](https://img.shields.io/npm/l/miii-cli)](LICENSE)
 [![node](https://img.shields.io/node/v/miii-cli)](https://nodejs.org)
 
-```
-╭──────────────────────────────────────────────────────────────────────╮
-│  miii  v0.2.8                                                        │
-│  model: qwen2.5-coder:7b                                             │
-├──────────────────────────────────────────────────────────────────────┤
-│  ✦ cross-referencing vibes…                              12s         │
-│  ⚙ running patch_file…                                               │
-│  ⚙ running run_tests…                                                │
-├──────────────────────────────────────────────────────────────────────┤
-│  ❯ ⎘ pasted 84 lines                                                 │
-│  backspace removes paste  enter to send                              │
-╰──────────────────────────────────────────────────────────────────────╯
-```
+## 📊 How Miii Stacks Up
+
+| Feature | **Miii** | Claude Code | Codex CLI | Aider |
+|---|---|---|---|---|
+| **Runs locally** | ✅ Ollama / any API | ❌ Cloud only | ❌ Cloud only | ✅ Local + cloud |
+| **Code stays private** | ✅ Never leaves machine | ❌ Sent to Anthropic | ❌ Sent to OpenAI | ⚠️ Depends on model |
+| **Cost** | 🆓 Free (your compute) | 💳 Pay per token | 💳 Pay per token | 🆓 Free (local) |
+| **Runtime** | ⚡ TypeScript — instant start | 🐍 Node (fast) | 🐍 Node | 🐢 Python |
+| **Deep Think mode** | ✅ Gather + synthesize | ❌ | ❌ | ❌ |
+| **Auto-test loop** | ✅ Jest / Vitest / Mocha | ⚠️ Manual | ❌ | ⚠️ Manual |
+| **Web search built-in** | ✅ Tavily | ❌ | ❌ | ❌ |
+| **Surgical patch edits** | ✅ `patch_file` | ✅ | ⚠️ | ✅ |
+| **Session memory** | ✅ Named, persistent | ✅ | ❌ | ⚠️ Basic |
+| **Skill / plugin system** | ✅ npm + `.md` skills | ⚠️ MCP only | ❌ | ❌ |
+| **Open source** | ✅ MIT | ❌ | ❌ | ✅ Apache 2.0 |
+
+> ✅ = supported  |  ⚠️ = partial  |  ❌ = not supported
 
 ## ⚡️ Quick Start
 
@@ -47,14 +51,35 @@ Most AI coding tools are either heavy Python wrappers or expensive monthly subsc
 - **🛠 Precision Editing**: Using `patch_file`, miii makes surgical changes without rewriting entire files.
 - **🔄 Auto-Test Loop**: Miii runs your Jest/Vitest/Mocha tests after every edit. If it breaks, it fixes itself.
 - **🌐 Web Intelligence**: Integrated `web_search` and `web_extract` via Tavily for real-time documentation.
+- **🧠 Deep Think**: Two-phase research mode — gathers from files, git, and web first, then synthesizes a complete answer. Available as `/think <query>` or as a tool the LLM calls autonomously.
 - **📐 Planning Mode**: Use `/plan` to architect a solution before a single line of code is written.
 - **📂 Session Memory**: Every conversation is auto-named and persisted. Resume your work instantly with `miii --session feature-auth`.
 - **📦 Skill System**: Extend miii with npm skill plugins or custom `.md` files.
 
+## 🧠 Deep Think
+
+Deep think is a two-phase research engine built into miii:
+
+1. **Gather phase** — runs a constrained inner loop with read-only tools: `read_file`, `list_files`, `git_status`, `git_log`, `git_diff`, `web_search`, `web_extract`. Guardrails enforce a hard cap of 6 tool calls and 4 web calls. No file writes, no shell mutations.
+2. **Synthesize phase** — gathered findings feed into the main run loop for a complete, grounded answer.
+
+**Two ways to trigger:**
+
+```
+/think how does the auth middleware handle token expiry?
+/think what does this codebase do and how is it structured?
+/think latest breaking changes in react 19
+```
+
+The LLM can also call `deep_think` autonomously mid-conversation when it decides a question needs multi-source research before answering.
+
+> Requires a Tavily key (`/tavily-key tvly-...`) for web calls. File/git research works without it.
+
 ## ⌨️ Command Cheat Sheet
 
 | Command | What it does |
 |---|---|
+| `/think <query>` | Deep research: gather from files + web, then synthesize answer |
 | `/refactor <goal>` | The powerhouse: plans, edits, and tests across your whole codebase |
 | `/git <sub>` | Instant git status, diffs, and automated commit messages |
 | `/plan` | Stop coding, start thinking (Structured Planning Mode) |

package/dist/__tests__/integration.test.js

@@ -0,0 +1,50 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { writeFileSync, unlinkSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { looksCodeRelated } from '../tui/git-context.js';
+import { tools } from '../tools/index.js';
+// patch_file uses guardPath which restricts to CWD — use a local scratch file
+const SCRATCH = join(process.cwd(), '.miii-test-scratch.txt');
+// ─── looksCodeRelated ─────────────────────────────────────────────────────────
+describe('looksCodeRelated', () => {
+    it('true: file extension in message', () => {
+        expect(looksCodeRelated('fix the bug in auth.ts')).toBe(true);
+    });
+    it('true: code keyword present', () => {
+        expect(looksCodeRelated('refactor the user login function')).toBe(true);
+    });
+    it('true: backtick token', () => {
+        expect(looksCodeRelated('what does `useEffect` do')).toBe(true);
+    });
+    it('false: too short', () => {
+        expect(looksCodeRelated('hi')).toBe(false);
+    });
+    it('false: plain prose, no code signal', () => {
+        expect(looksCodeRelated('what is the weather like in london today')).toBe(false);
+    });
+});
+// ─── patch_file ───────────────────────────────────────────────────────────────
+describe('patch_file', () => {
+    const patchTool = tools.find(t => t.name === 'patch_file');
+    afterEach(() => {
+        try {
+            unlinkSync(SCRATCH);
+        }
+        catch { }
+    });
+    it('applies a unique patch correctly', async () => {
+        writeFileSync(SCRATCH, 'hello world\ngoodbye world\n');
+        await patchTool.execute({ path: SCRATCH, old: 'hello world', new: 'hello earth' });
+        expect(readFileSync(SCRATCH, 'utf-8')).toBe('hello earth\ngoodbye world\n');
+    });
+    it('throws when old text not found', async () => {
+        writeFileSync(SCRATCH, 'hello world\n');
+        await expect(patchTool.execute({ path: SCRATCH, old: 'no such text', new: 'x' }))
+            .rejects.toThrow('old text not found');
+    });
+    it('throws on ambiguous match (2+ occurrences)', async () => {
+        writeFileSync(SCRATCH, 'hello world\nhello world\n');
+        await expect(patchTool.execute({ path: SCRATCH, old: 'hello world', new: 'hi' }))
+            .rejects.toThrow('ambiguous');
+    });
+});

package/dist/init.js

@@ -9,7 +9,7 @@ import { execSync } from 'child_process';
 import { loadConfig } from './config.js';
 import { SkillLoader } from './skills/loader.js';
 import { InputBar } from './tui/InputBar.js';
-import { welcome } from './tui/printer.js';
+import { welcome, setInkInstance } from './tui/printer.js';
 import { ensureOllama } from './llm/ollama.js';
 const require = createRequire(import.meta.url);
 const UPDATE_CACHE = join(homedir(), '.config', 'miii', 'update-check.json');
@@ -89,7 +89,8 @@ export async function lazyInit() {
     ]);
     // Print welcome banner to scrollback BEFORE Ink starts
     welcome(config.provider, config.model, process.cwd(), currentVersion, updateAvailable, linked);
-    const sessionName = argv.session || 'default';
-    const { waitUntilExit } = render(React.createElement(InputBar, { config, skills, cwd: process.cwd(), session: sessionName, version: currentVersion }), { exitOnCtrlC: false });
+    const sessionName = argv.session || `s-${Date.now()}`;
+    const { waitUntilExit, clear } = render(React.createElement(InputBar, { config, skills, cwd: process.cwd(), session: sessionName, version: currentVersion }), { exitOnCtrlC: false });
+    setInkInstance(clear);
     await waitUntilExit();
 }

package/dist/llm/stream.js

@@ -4,21 +4,57 @@ export async function chat(cfg) {
     return chatOllama(cfg);
 }
 async function chatOllama(cfg) {
-    const { model, messages, baseUrl, signal, onDone, onError, onUsage } = cfg;
+    const { model, messages, baseUrl, signal, onDone, onError, onUsage, onChunk } = cfg;
     try {
         const res = await fetch(`${baseUrl}/api/chat`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ model, messages, stream: false }),
+            body: JSON.stringify({ model, messages, stream: !!onChunk }),
             signal,
         });
         if (!res.ok) {
             onError(new Error(`Ollama ${res.status}: ${await res.text()}`));
             return;
         }
-        const obj = await res.json();
-        onUsage?.(obj?.prompt_eval_count ?? 0, obj?.eval_count ?? 0);
-        await onDone(obj?.message?.content ?? '');
+        if (!onChunk) {
+            const obj = await res.json();
+            onUsage?.(obj?.prompt_eval_count ?? 0, obj?.eval_count ?? 0);
+            await onDone(obj?.message?.content ?? '');
+            return;
+        }
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let full = '';
+        let promptTokens = 0;
+        let completionTokens = 0;
+        let buf = '';
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buf += decoder.decode(value, { stream: true });
+            const lines = buf.split('\n');
+            buf = lines.pop() ?? '';
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const obj = JSON.parse(line);
+                    const chunk = obj?.message?.content ?? '';
+                    if (chunk) {
+                        full += chunk;
+                        onChunk(chunk);
+                    }
+                    if (obj?.done) {
+                        promptTokens = obj.prompt_eval_count ?? 0;
+                        completionTokens = obj.eval_count ?? 0;
+                    }
+                }
+                catch { }
+            }
+        }
+        onUsage?.(promptTokens, completionTokens);
+        await onDone(full);
     }
     catch (err) {
         if (err?.name !== 'AbortError')
@@ -26,21 +62,53 @@ async function chatOllama(cfg) {
     }
 }
 async function chatOpenAI(cfg) {
-    const { model, messages, baseUrl, apiKey, signal, onDone, onError, onUsage } = cfg;
+    const { model, messages, baseUrl, apiKey, signal, onDone, onError, onUsage, onChunk } = cfg;
     try {
         const res = await fetch(`${baseUrl}/v1/chat/completions`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${apiKey ?? 'local'}` },
-            body: JSON.stringify({ model, messages }),
+            body: JSON.stringify({ model, messages, stream: !!onChunk }),
             signal,
         });
         if (!res.ok) {
             onError(new Error(`LLM ${res.status}: ${await res.text()}`));
             return;
         }
-        const obj = await res.json();
-        onUsage?.(obj?.usage?.prompt_tokens ?? 0, obj?.usage?.completion_tokens ?? 0);
-        await onDone(obj?.choices?.[0]?.message?.content ?? '');
+        if (!onChunk) {
+            const obj = await res.json();
+            onUsage?.(obj?.usage?.prompt_tokens ?? 0, obj?.usage?.completion_tokens ?? 0);
+            await onDone(obj?.choices?.[0]?.message?.content ?? '');
+            return;
+        }
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let full = '';
+        let buf = '';
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buf += decoder.decode(value, { stream: true });
+            const lines = buf.split('\n');
+            buf = lines.pop() ?? '';
+            for (const line of lines) {
+                if (!line.startsWith('data: '))
+                    continue;
+                const data = line.slice(6).trim();
+                if (data === '[DONE]')
+                    continue;
+                try {
+                    const obj = JSON.parse(data);
+                    const chunk = obj?.choices?.[0]?.delta?.content ?? '';
+                    if (chunk) {
+                        full += chunk;
+                        onChunk(chunk);
+                    }
+                }
+                catch { }
+            }
+        }
+        await onDone(full);
     }
     catch (err) {
         if (err?.name !== 'AbortError')

package/dist/memory/extractor.js

@@ -0,0 +1,44 @@
+import { chat } from '../llm/stream.js';
+const SYSTEM = `You extract memorable facts from conversations for long-term memory. Output ONLY a valid JSON array of concise fact strings.
+
+Extract: user preferences, decisions made, key file paths, functions or variables, code patterns established, constraints, goals.
+Skip: trivial exchanges, transient state, tool output noise.
+Max 8 facts. Be specific and concrete.
+
+Example output:
+["User prefers patch_file over full rewrites","entry point is src/index.ts","decided to use Zod for validation"]`;
+export function extractFacts(messages, config, model) {
+    const lines = messages
+        .filter(m => m.role !== 'system')
+        .map(m => `${m.role}: ${m.content.slice(0, 400)}`)
+        .join('\n');
+    if (!lines.trim())
+        return Promise.resolve([]);
+    return new Promise(resolve => {
+        chat({
+            provider: config.provider,
+            model,
+            baseUrl: config.baseUrl,
+            apiKey: config.apiKey,
+            messages: [
+                { role: 'system', content: SYSTEM },
+                { role: 'user', content: lines },
+            ],
+            onDone(text) {
+                try {
+                    const m = text.match(/\[[\s\S]*?\]/);
+                    if (!m) {
+                        resolve([]);
+                        return;
+                    }
+                    const arr = JSON.parse(m[0]);
+                    resolve(Array.isArray(arr) ? arr.filter((f) => typeof f === 'string') : []);
+                }
+                catch {
+                    resolve([]);
+                }
+            },
+            onError() { resolve([]); },
+        });
+    });
+}

package/dist/memory/store.js

@@ -0,0 +1,41 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+const MEMORY_DIR = join(homedir(), '.config', 'miii', 'memory');
+const MAX_FACTS = 200;
+function ensureDir() {
+    mkdirSync(MEMORY_DIR, { recursive: true });
+}
+export function loadLongMemory(sessionName) {
+    ensureDir();
+    const p = join(MEMORY_DIR, `${sessionName}.json`);
+    if (!existsSync(p))
+        return [];
+    try {
+        const parsed = JSON.parse(readFileSync(p, 'utf-8'));
+        return Array.isArray(parsed) ? parsed : [];
+    }
+    catch {
+        return [];
+    }
+}
+export function saveLongMemory(sessionName, facts) {
+    ensureDir();
+    writeFileSync(join(MEMORY_DIR, `${sessionName}.json`), JSON.stringify(facts));
+}
+export function mergeFacts(existing, newTexts) {
+    const existingSet = new Set(existing.map(f => f.text.toLowerCase()));
+    const ts = Date.now();
+    const added = newTexts
+        .filter(t => t.trim() && !existingSet.has(t.toLowerCase()))
+        .map(text => ({ text, ts }));
+    const merged = [...existing, ...added];
+    if (merged.length > MAX_FACTS)
+        merged.splice(0, merged.length - MAX_FACTS);
+    return merged;
+}
+export function formatMemoryBlock(facts) {
+    if (!facts.length)
+        return '';
+    return `\n\n[Long-term memory — recalled from prior conversation]\n${facts.map(f => `- ${f.text}`).join('\n')}`;
+}

package/dist/tavily/client.js

@@ -0,0 +1,64 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+const KEY_FILE = join(homedir(), '.config', 'miii', 'tavily.key');
+export function getTavilyKey() {
+    if (existsSync(KEY_FILE)) {
+        const k = readFileSync(KEY_FILE, 'utf-8').trim();
+        if (k)
+            return k;
+    }
+    return undefined;
+}
+export function saveTavilyKey(key) {
+    mkdirSync(join(homedir(), '.config', 'miii'), { recursive: true });
+    writeFileSync(KEY_FILE, key.trim(), { encoding: 'utf-8', mode: 0o600 });
+}
+async function post(path, body) {
+    const res = await fetch(`https://api.tavily.com${path}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        const text = await res.text().catch(() => '');
+        throw new Error(`Tavily API ${res.status}: ${text}`);
+    }
+    return res.json();
+}
+export async function tavilySearch(opts) {
+    const data = await post('/search', {
+        api_key: opts.apiKey,
+        query: opts.query,
+        search_depth: opts.searchDepth ?? 'basic',
+        max_results: Math.min(opts.maxResults ?? 5, 10),
+        include_answer: opts.includeAnswer ?? true,
+        include_raw_content: false,
+        include_domains: opts.includeDomains ?? [],
+        exclude_domains: opts.excludeDomains ?? [],
+    });
+    const parts = [];
+    if (data.answer)
+        parts.push(`Answer: ${data.answer}\n`);
+    for (const r of data.results) {
+        parts.push(`[${r.title}] ${r.url}\n${r.content}`);
+    }
+    return parts.join('\n\n').trim() || '(no results)';
+}
+export async function tavilyExtract(opts) {
+    const data = await post('/extract', {
+        api_key: opts.apiKey,
+        urls: opts.urls.slice(0, 20),
+    });
+    const parts = [];
+    for (const r of data.results) {
+        const truncated = r.raw_content.length > 8000
+            ? r.raw_content.slice(0, 8000) + '\n…[truncated at 8k]'
+            : r.raw_content;
+        parts.push(`[${r.url}]\n${truncated}`);
+    }
+    if (data.failed_results?.length) {
+        parts.push(`Failed URLs: ${data.failed_results.map(r => r.url).join(', ')}`);
+    }
+    return parts.join('\n\n---\n\n').trim() || '(no content extracted)';
+}

package/dist/tools/index.js

@@ -235,6 +235,7 @@ export const tools = [
 ];
 export function getSystemPrompt(extra = '') {
     const toolDocs = tools.map(t => `- ${t.name}(${t.params}): ${t.description}`).join('\n');
+    const deepThinkDoc = `- deep_think({"query": "string", "needs_web": "boolean (optional)"}): Research tool — gathers information from files, git, and optionally the web before answering. Returns a compiled research summary. Guardrails: read-only tools only, max 6 tool calls, max 4 web calls inside. Use when a question requires reading multiple files or searching the web first.`;
     return `You are Miii — a fast, local AI coding assistant.
 
 Use tools by emitting:
@@ -265,6 +266,7 @@ replacement text
 
 Tools:
 ${toolDocs}
+${deepThinkDoc}
 
 Rules:
 - To modify an existing file: use patch_file with the exact old text and new replacement — do NOT rewrite the whole file
@@ -284,5 +286,7 @@ Rules:
 - After editing files that have tests, call run_tests to verify nothing broke
 - If run_tests fails, read the failing test output and fix the code, then run_tests again (max 3 retries)
 - You have web_search and web_extract tools — use them whenever the user asks about anything requiring internet access, current information, documentation, library versions, news, or external URLs
-- NEVER say you cannot search the web — always call web_search instead${extra}`;
+- NEVER say you cannot search the web — always call web_search instead
+- Use deep_think when the question requires gathering from multiple files or sources before you can answer well — it runs a safe read-only research phase and returns a summary you can reason over
+- deep_think cannot edit files or run shell commands — it is purely for information gathering${extra}`;
 }

package/dist/tui/InputBar.js

@@ -8,7 +8,7 @@ import { tools } from '../tools/index.js';
 import { readFile } from '../files/ops.js';
 import { generateId } from '../types.js';
 import * as printer from './printer.js';
-import { loadSession, saveSession, listSessions } from '../sessions.js';
+import { loadSession, saveSession, listSessions, deleteSession } from '../sessions.js';
 import { MacroQueue, MicroQueue } from '../tasks/queue.js';
 import { TaskExecutor } from '../tasks/executor.js';
 import { fileEditContext } from '../tasks/compactor.js';
@@ -23,6 +23,7 @@ import { buildGitContext, looksCodeRelated } from './git-context.js';
 import { useSession } from './hooks/useSession.js';
 import { useModelPicker } from './hooks/useModelPicker.js';
 import { useRunLoop } from './hooks/useRunLoop.js';
+import { runDeepThink } from './deepThink.js';
 const gitRun = promisify(exec);
 function buildAtContext(text) {
     const refs = [...text.matchAll(/@([\w./\-]+)/g)];
@@ -47,9 +48,20 @@ export function InputBar({ config, skills, cwd, session, version }) {
     const macroQueueRef = useRef(new MacroQueue());
     const executorRef = useRef(new TaskExecutor(tools));
     const lastGitStatusRef = useRef('');
-    const { setSessionName, sessionNameRef, historyRef, saveTimerRef, systemPromptRef, pushHistory, buildContext, } = useSession(session, cwd, config);
+    const abortRef = useRef(null);
+    const { setSessionName, sessionNameRef, historyRef, saveTimerRef, systemPromptRef, pushHistory, buildContext, renameFromMessage, } = useSession(session, cwd, config);
     const { currentModel, setCurrentModel, currentModelRef, pickerOpen, setPickerOpen, pickerModels, pickerLoading, pickerError, pullState, openPicker, handleModelSelect, handleModelPull, } = useModelPicker(config);
-    const { status, setStatus, tick, currentTool, setCurrentTool, taskLabel, setTaskLabel, thinkingStartRef, abortRef, runLoop, handleAbort, } = useRunLoop(config, currentModelRef, pushHistory);
+    const deepThinkTool = useMemo(() => ({
+        name: 'deep_think',
+        description: 'Research tool: gather info from files and web before answering.',
+        params: '{"query": "string", "needs_web": "boolean (optional)"}',
+        execute: async ({ query }) => {
+            const result = await runDeepThink(String(query), config, currentModelRef.current, abortRef.current?.signal);
+            return `Research complete (${result.toolCalls} tool calls, ${result.webCalls} web):\n\n${result.findings}`;
+        },
+    }), [config]);
+    const allTools = useMemo(() => [...tools, deepThinkTool], [deepThinkTool]);
+    const { status, setStatus, tick, currentTool, setCurrentTool, taskLabel, setTaskLabel, thinkingStartRef, runLoop, handleAbort, } = useRunLoop(config, currentModelRef, pushHistory, allTools, abortRef);
     // ─── refactor ─────────────────────────────────────────────────────────────
     const runRefactor = useCallback(async (goal) => {
         printer.systemMsg(`refactor: ${goal}`);
@@ -348,6 +360,41 @@ export function InputBar({ config, skills, cwd, session, version }) {
             await runRefactor(goal);
             return;
         }
+        if (cmd.startsWith('/think ') || cmd === '/think') {
+            const query = cmd.slice(6).trim();
+            if (!query) {
+                printer.systemMsg('usage: /think <query>');
+                return;
+            }
+            printer.userMsg(`/think ${query}`);
+            setStatus('thinking');
+            setTaskLabel(`gathering: ${query}`);
+            abortRef.current = new AbortController();
+            try {
+                const result = await runDeepThink(query, config, currentModelRef.current, abortRef.current.signal, (toolName) => setCurrentTool(`gather:${toolName}`));
+                setCurrentTool(undefined);
+                printer.systemMsg(`gathered: ${result.toolCalls} tool call(s), ${result.webCalls} web call(s)`);
+                if (result.findings) {
+                    pushHistory({ role: 'user', content: `/think ${query}` });
+                    pushHistory({ role: 'assistant', content: result.findings });
+                    pushHistory({ role: 'user', content: `Based on your research above, give a complete answer to: ${query}` });
+                    await runLoop(buildContext(), 0, query);
+                }
+                else {
+                    printer.systemMsg('nothing gathered — try rephrasing');
+                    setStatus('idle');
+                }
+            }
+            catch (e) {
+                printer.errorMsg(`deep think failed: ${e}`);
+                setStatus('idle');
+            }
+            finally {
+                setCurrentTool(undefined);
+                setTaskLabel(undefined);
+            }
+            return;
+        }
         if (cmd === '/plan' || cmd.startsWith('/plan ')) {
             const topic = cmd.slice(5).trim();
             setPlanningMode(true);
@@ -394,6 +441,25 @@ export function InputBar({ config, skills, cwd, session, version }) {
                 printer.systemMsg(`current: ${sessionNameRef.current}`);
                 return;
             }
+            if (arg.startsWith('delete ')) {
+                const target = arg.slice(7).trim();
+                if (!target) {
+                    printer.systemMsg('usage: /session delete <name>');
+                    return;
+                }
+                if (target === sessionNameRef.current) {
+                    printer.systemMsg('cannot delete active session — switch first');
+                    return;
+                }
+                try {
+                    deleteSession(target);
+                    printer.systemMsg(`deleted: ${target}`);
+                }
+                catch (e) {
+                    printer.errorMsg(`delete failed: ${String(e)}`);
+                }
+                return;
+            }
             if (saveTimerRef.current) {
                 clearTimeout(saveTimerRef.current);
                 saveTimerRef.current = null;
@@ -434,6 +500,7 @@ export function InputBar({ config, skills, cwd, session, version }) {
             printer.systemMsg(`unknown command: /${slashCmd}  —  try /list`);
             return;
         }
+        renameFromMessage(text);
         const contextPrefix = buildAtContext(text);
         const shouldInjectGit = config.gitContext !== false && looksCodeRelated(text);
         const { prefix: gitPrefix, label: gitLabel } = shouldInjectGit

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' },
 ];
+const PASTE_MIN_LINES = 3;
+const PASTE_MIN_CHARS = 200;
 export function InputArea({ status, skills, cwd, planningMode, 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 => {
@@ -200,7 +206,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 +218,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 +260,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;
@@ -277,14 +299,16 @@ export function InputArea({ status, skills, cwd, planningMode, onSubmit, onAbort
     const borderColor = isProcessing ? 'yellow' : 'cyan';
     const hint = isProcessing
         ? 'esc to abort'
-        : overlay === 'command' && !commandQuery.includes(' ')
-            ? '↑↓ navigate  enter select  esc close'
-            : overlay === 'at'
+        : pasteLines > 0
+            ? 'backspace removes paste  enter to send'
+            : overlay === 'command' && !commandQuery.includes(' ')
                 ? '↑↓ 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
+                : 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: 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,148 @@
+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']);
+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 thinkingStartRef = useRef(0);
+    const extraToolsRef = useRef(extraTools);
+    extraToolsRef.current = extraTools;
+    const pushHistoryRef = useRef(pushHistory);
+    useEffect(() => { pushHistoryRef.current = pushHistory; }, [pushHistory]);
+    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 (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();
+        setStatus('idle');
+    }, []);
+    return {
+        status, setStatus, tick,
+        currentTool, setCurrentTool,
+        taskLabel, setTaskLabel,
+        thinkingStartRef,
+        runLoop, handleAbort,
+    };
+}

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';
@@ -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`);
 }

package/dist/tui/thinking.js

@@ -0,0 +1,53 @@
+export const THINKING_PHRASES = [
+    'oh wow, a question. let me pretend to care…',
+    'consulting the void…',
+    'making something up, just a sec…',
+    'definitely not hallucinating right now…',
+    'running 47 mental tabs…',
+    'staring into the abyss (it blinked)…',
+    'calculating your fate, no pressure…',
+    'doing the thinking you pay me for…',
+    'processing your questionable life choices…',
+    'summoning coherent thoughts, rarely works…',
+    'asking my imaginary friend for help…',
+    'pretending this is a hard problem…',
+    'yes, yes, very interesting. anyway…',
+    'googling it (not really, I can\'t)…',
+    'simulating intelligence… please wait…',
+    'having a brief existential crisis…',
+    'cross-referencing vibes…',
+    'totally not making this up…',
+    'the answer is 42. now finding the question…',
+    'my other tab is loading…',
+    'channelling the spirit of stack overflow…',
+    'trying not to confidently be wrong…',
+    'applying artificial to the intelligence…',
+    'phoning a friend who also doesn\'t know…',
+    'checking if this is even my problem to solve…',
+    'rebooting common sense… this may take a while…',
+    'performing a very convincing impression of thinking…',
+    'searching for wisdom in all the wrong places…',
+    'warming up the neurons (both of them)…',
+    'confidently striding toward the wrong answer…',
+    'consulting my gut. it says maybe…',
+    'loading… just kidding, still loading…',
+    'asking the universe. universe has not replied…',
+    'vigorously nodding while understanding nothing…',
+    'doing math on my fingers (ran out of fingers)…',
+    'the confidence is fake. the effort is real. probably…',
+    'entering a fugue state. for your benefit…',
+    'mining the depths of mediocrity…',
+    'compiling a list of plausible nonsense…',
+    'this would be faster if I knew what I was doing…',
+    'buffering at the speed of thought…',
+    'holding three contradictory opinions simultaneously…',
+    'interpolating between guesses…',
+    'rewinding the context window with a pencil…',
+    'waiting for a sign. any sign…',
+    'tracing the error back to its origin: me…',
+    'the logic checks out if you squint…',
+    'reasoning from first principles I just invented…',
+    'generating tokens and praying for coherence…',
+    'one sec — dropped all my thoughts, picking them up…',
+];
+export const SPARKLE = ['✦', '✧', '✶', '✷', '✸', '✹'];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "miii-cli",
-  "version": "0.2.9",
+  "version": "0.3.0",
   "type": "module",
   "description": "The high-performance local AI coding agent for your terminal. Automate complex workflows with local LLMs.",
   "license": "MIT",