miii-cli 0.2.9 → 0.3.1

package/README.md

@@ -9,62 +9,90 @@
 [![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                              │
-╰──────────────────────────────────────────────────────────────────────╯
-```
+## 📊 The Competitive Edge
+
+| Feature | **Miii** | Claude Code | Codex CLI | Aider |
+|---|---|---|---|---|
+| **Execution Environment** | ✅ Local / Hybrid | ❌ Cloud only | ❌ Cloud only | ✅ Local + cloud |
+| **Data Privacy** | ✅ Air-gapped possible | ❌ Cloud-streamed | ❌ Cloud-streamed | ⚠️ Model-dependent |
+| **Cost Structure** | 🆓 Free (Your Compute) | 💳 Token-based | 💳 Token-based | 🆓 Free (local) |
+| **Runtime Efficiency** | ⚡ TS (Instant Start) | 🐍 Node (Fast) | 🐍 Node | 🐢 Python (Heavy) |
+| **Research Engine** | ✅ Deep Think Mode | ❌ | ❌ | ❌ |
+| **Validation Loop** | ✅ Auto-test (Jest/Vitest) | ⚠️ Manual | ❌ | ⚠️ Manual |
+| **Live Web Access** | ✅ Tavily Integrated | ❌ | ❌ | ❌ |
+| **Edit Precision** | ✅ Surgical `patch_file` | ✅ | ⚠️ | ✅ |
+| **State Persistence** | ✅ Named Sessions | ✅ | ❌ | ⚠️ Basic |
+| **Extensibility** | ✅ npm + `.md` Skills | ⚠️ MCP only | ❌ | ❌ |
+| **License** | ✅ MIT | ❌ | ❌ | ✅ Apache 2.0 |
+
+> ✅ = Native  |  ⚠️ = Partial  |  ❌ = Unsupported
 
 ## ⚡️ Quick Start
 
-Get up and running in 30 seconds:
+Deploy Miii in your environment in 30 seconds:
 
 ```bash
+# 1. Pull a capable local model
 ollama pull qwen2.5-coder:7b
+
+# 2. Install the CLI globally
 npm install -g miii-cli
+
+# 3. Start engineering
 miii
 ```
 
 ## 🧠 Why Miii?
 
-Most AI coding tools are either heavy Python wrappers or expensive monthly subscriptions that send your code to the cloud. **miii is different.**
+The industry is saturated with heavy Python wrappers and expensive monthly subscriptions that trade your intellectual property for convenience. **Miii breaks this cycle.**
 
-- **Local-First & Private**: Runs on Ollama or any OpenAI-compatible API. Your code never leaves your machine, ensuring 100% privacy and security.
-- **Blazing Fast**: Built with TypeScript for near-instant startup. No heavy Python runtime overhead. Tiny footprint, massive power.
-- **Fully Autonomous**: Miii doesn't just suggest code; it acts as a junior engineer—editing files, running your test suite, and iterating until the bugs are gone.
-- **Deep Context Awareness**: Automatically analyzes git diffs and project architecture, eliminating the need for manual copy-pasting.
+- **Privacy by Default**: Your codebase never leaves your machine. Period.
+- **Zero Latency**: Built with TypeScript for near-instant startup. No virtual environments, no dependency hell, just raw performance.
+- **True Autonomy**: Miii isn't a chatbot; it's a junior engineer. It plans, edits, runs tests, and iterates until the PR is ready.
+- **Architectural Intelligence**: By analyzing git diffs and project structure, Miii understands context without requiring manual copy-pasting.
 
 ## 🔥 Killer Features
 
-- **🛠 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.
-- **📐 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.
+- **🛠 Surgical Precision**: Instead of overwriting files, Miii uses `patch_file` to inject changes, preserving your formatting and reducing token waste.
+- **🔄 The Self-Healing Loop**: Miii executes your test suite (Jest, Vitest, Mocha) after every change. If a test fails, it analyzes the trace and fixes the code autonomously.
+- **🌐 Real-time Intelligence**: Integrated `web_search` and `web_extract` via Tavily allow Miii to reference the latest documentation and API changes.
+- **🧠 Deep Think Engine**: A sophisticated two-phase research mode that gathers data before synthesizing a solution.
+- **📐 Strategic Planning**: Use `/plan` to map out complex refactors before a single character is typed.
+- **📂 Persistent Context**: Workflows are saved as named sessions. Jump back into a specific feature branch with `miii --session feature-auth`.
+- **📦 Modular Skill System**: Extend Miii's capabilities using npm plugins or simple Markdown-based skill files.
+
+## 🔬 Deep Think Explained
+
+Deep Think is a recursive research engine designed to eliminate "hallucinations" by grounding the AI in facts:
+
+1. **Gather Phase**: A constrained, read-only loop utilizing `read_file`, `list_files`, `git_status`, `git_log`, `git_diff`, and web tools. 
+   - **Guardrails**: Strict limit of 6 tool calls and 4 web calls to prevent infinite loops.
+   - **Safety**: Zero write permissions. No mutations.
+2. **Synthesize Phase**: All gathered intelligence is aggregated and fed into the main execution loop for a grounded, verified response.
+
+**Trigger Research:**
+```bash
+/think "How does the auth middleware handle token expiry?"
+/think "Analyze the project structure and explain the data flow."
+/think "What are the breaking changes in React 19 for this project?"
+```
+*The LLM also triggers `deep_think` autonomously when it detects a high-complexity query.*
 
 ## ⌨️ Command Cheat Sheet
 
-| Command | What it does |
-|---|---|
-| `/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) |
-| `/model <name>` | Swap LLMs on the fly |
-| `/tavily-key <key>` | Enable real-time web browsing |
-| `/sessions` | Travel back in time to previous coding sessions |
+| Command | Purpose | Impact |
+|---|---|---|
+| `/think <query>` | Deep Research | High-fidelity synthesis of files + web |
+| `/refactor <goal>` | Full-scale Engineering | Plan $\rightarrow$ Edit $\rightarrow$ Test loop |
+| `/git <sub>` | Git Automation | Instant status, diffs, and AI commit messages |
+| `/plan` | Architecture Mode | Structured blueprinting before coding |
+| `/model <name>` | LLM Hot-swap | Switch models instantly based on task |
+| `/tavily-key <key>` | Enable Web Access | Unlocks real-time internet browsing |
+| `/sessions` | Context Recovery | Resume previous engineering sessions |
 
 ## ⚙️ Configuration
 
-Customise your experience in `.miii.json` or `~/.config/miii/config.json`:
+Fine-tune your agent in `.miii.json` or `~/.config/miii/config.json`:
 
 ```json
 {
@@ -85,13 +113,12 @@ cd miii-cli && npm install && npm run build && npm link
 
 ## 🌟 Community & Philosophy
 
-**Own your AI stack. Stop renting your intelligence. The future of coding is local.**
+**Stop renting your intelligence. Own your AI stack.**
 
-miii is built for the community. If this tool saves you hours of coding, help us grow:
+Miii is built for engineers who value privacy, speed, and total control. If this tool has accelerated your workflow, support the project:
 - 🌟 **Star the repo** on GitHub
-- 🐦 **Share on X**
-- 🤖 **Post on Reddit**
-- 💬 **Tell a fellow developer**
+- 🐦 **Share your wins** on X
+- 🤖 **Discuss the future** on Reddit
 
 ## 📜 License
 MIT

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,8 @@ 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 { toolArgSummary } from './printer.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 +24,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 +49,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, permissionRequest, resolvePermission, } = useRunLoop(config, currentModelRef, pushHistory, allTools, abortRef);
     // ─── refactor ─────────────────────────────────────────────────────────────
     const runRefactor = useCallback(async (goal) => {
         printer.systemMsg(`refactor: ${goal}`);
@@ -348,6 +361,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 +442,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 +501,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
@@ -447,7 +515,7 @@ export function InputBar({ config, skills, cwd, session, version }) {
     }, [skills, runLoop, openPicker]);
     const skillList = skills.list();
     // ─── render ────────────────────────────────────────────────────────────────
-    return (_jsxs(Box, { flexDirection: "column", children: [pickerOpen ? (_jsxs(_Fragment, { children: [_jsx(ModelPicker, { models: pickerModels, current: currentModel, loading: pickerLoading, error: pickerError, pull: pullState, onSelect: handleModelSelect, onPull: handleModelPull, onClose: () => { setPickerOpen(false); } }), _jsx(Divider, { cols: cols })] })) : (status === 'thinking' || status === 'tool') ? (_jsxs(_Fragment, { children: [_jsx(Box, { flexDirection: "column", paddingX: 1, children: _jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { children: status === 'thinking'
+    return (_jsxs(Box, { flexDirection: "column", children: [pickerOpen ? (_jsxs(_Fragment, { children: [_jsx(ModelPicker, { models: pickerModels, current: currentModel, loading: pickerLoading, error: pickerError, pull: pullState, onSelect: handleModelSelect, onPull: handleModelPull, onClose: () => { setPickerOpen(false); } }), _jsx(Divider, { cols: cols })] })) : permissionRequest ? (_jsxs(_Fragment, { children: [_jsx(Box, { flexDirection: "column", paddingX: 1, paddingY: 0, children: _jsxs(Box, { gap: 1, children: [_jsx(Text, { color: "yellow", children: "\u26A0" }), _jsx(Text, { color: "white", bold: true, children: permissionRequest.toolName }), _jsx(Text, { color: "gray", children: toolArgSummary(permissionRequest.args) })] }) }), _jsx(Divider, { cols: cols })] })) : (status === 'thinking' || status === 'tool') ? (_jsxs(_Fragment, { children: [_jsx(Box, { flexDirection: "column", paddingX: 1, children: _jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { children: status === 'thinking'
                                         ? _jsxs(_Fragment, { children: [_jsxs(Text, { color: "yellow", children: [SPARKLE[tick % SPARKLE.length], " "] }), _jsx(Text, { color: "gray", dimColor: true, italic: true, children: THINKING_PHRASES[phraseSeq[Math.floor(tick / 62) % phraseSeq.length]] })] })
-                                        : _jsxs(Text, { color: "yellow", dimColor: true, children: ["\u2699 running ", currentTool ?? 'tool', "\u2026"] }) }), _jsxs(Box, { gap: 2, children: [_jsxs(Text, { color: "gray", dimColor: true, children: [Math.floor((Date.now() - thinkingStartRef.current) / 1000), "s"] }), taskLabel && _jsx(Text, { color: "cyan", dimColor: true, children: taskLabel })] })] }) }), _jsx(Divider, { cols: cols })] })) : null, _jsx(InputArea, { status: status, skills: skillList, cwd: cwd, planningMode: planningMode, onSubmit: handleSubmit, onAbort: handleAbort })] }));
+                                        : _jsxs(Text, { color: "yellow", dimColor: true, children: ["\u2699 running ", currentTool ?? 'tool', "\u2026"] }) }), _jsxs(Box, { gap: 2, children: [_jsxs(Text, { color: "gray", dimColor: true, children: [Math.floor((Date.now() - thinkingStartRef.current) / 1000), "s"] }), taskLabel && _jsx(Text, { color: "cyan", dimColor: true, children: taskLabel })] })] }) }), _jsx(Divider, { cols: cols })] })) : null, _jsx(InputArea, { status: status, skills: skillList, cwd: cwd, planningMode: planningMode, permissionRequest: permissionRequest, onPermissionResponse: resolvePermission, onSubmit: handleSubmit, onAbort: handleAbort })] }));
 }