miii-cli 1.2.4 → 1.3.1

package/dist/llm/stream.js

@@ -1,9 +1,7 @@
-// Transient errors worth retrying: rate limits + server-side faults
 const RETRYABLE_STATUS = new Set([429, 500, 502, 503, 529]);
 const MAX_RETRIES = 4;
 const MAX_DELAY_MS = 30_000;
 function retryDelay(attempt) {
-    // Exponential backoff: 1s → 2s → 4s → 8s, capped at 30s, ±20% jitter
     const base = 1_000 * Math.pow(2, attempt);
     const capped = Math.min(base, MAX_DELAY_MS);
     return Math.round(capped * (0.8 + Math.random() * 0.4));
@@ -43,6 +41,37 @@ async function fetchWithRetry(url, init, signal, onRetry) {
     }
     throw new Error('fetchWithRetry: exhausted retries without returning');
 }
+// Convert Tool params string to JSON Schema for native tool_calls APIs
+function paramsToSchema(paramsStr) {
+    try {
+        const obj = JSON.parse(paramsStr);
+        const properties = {};
+        const required = [];
+        for (const [key, typeStr] of Object.entries(obj)) {
+            const isOptional = typeStr.toLowerCase().includes('optional');
+            const isArray = typeStr.toLowerCase().includes('[]') || typeStr.toLowerCase().startsWith('array');
+            const base = typeStr.split(' ')[0].toLowerCase().replace('[]', '');
+            if (isArray) {
+                properties[key] = { type: 'array', items: { type: 'string' } };
+            }
+            else if (base === 'boolean') {
+                properties[key] = { type: 'boolean' };
+            }
+            else if (base === 'number') {
+                properties[key] = { type: 'number' };
+            }
+            else {
+                properties[key] = { type: 'string' };
+            }
+            if (!isOptional)
+                required.push(key);
+        }
+        return { type: 'object', properties, required };
+    }
+    catch {
+        return { type: 'object', properties: {}, required: [] };
+    }
+}
 export async function warmup(provider, baseUrl, model) {
     if (provider !== 'ollama')
         return;
@@ -121,12 +150,21 @@ async function chatOllama(cfg) {
     }
 }
 async function chatOpenAI(cfg) {
-    const { model, messages, baseUrl, apiKey, signal, onDone, onError, onUsage, onChunk, onRetry } = cfg;
+    const { model, messages, baseUrl, apiKey, signal, onDone, onError, onUsage, onChunk, onRetry, tools, toolChoice } = cfg;
+    const body = { model, messages, stream: !!onChunk };
+    if (tools?.length) {
+        body.tools = tools.map(t => ({
+            type: 'function',
+            function: { name: t.name, description: t.description, parameters: paramsToSchema(t.params) },
+        }));
+        if (toolChoice === 'none')
+            body.tool_choice = 'none';
+    }
     try {
         const res = await fetchWithRetry(`${baseUrl}/v1/chat/completions`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${apiKey ?? 'local'}` },
-            body: JSON.stringify({ model, messages, stream: !!onChunk }),
+            body: JSON.stringify(body),
         }, signal, onRetry);
         if (!res.ok) {
             onError(new Error(`LLM ${res.status}: ${await res.text()}`));
@@ -135,13 +173,26 @@ async function chatOpenAI(cfg) {
         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 ?? '');
+            const message = obj?.choices?.[0]?.message;
+            let text = message?.content ?? '';
+            if (message?.tool_calls?.length) {
+                for (const tc of message.tool_calls) {
+                    let args = {};
+                    try {
+                        args = JSON.parse(tc.function?.arguments ?? '{}');
+                    }
+                    catch { }
+                    text += `\n<tool_call>\n{"name": ${JSON.stringify(tc.function?.name)}, "args": ${JSON.stringify(args)}}\n</tool_call>`;
+                }
+            }
+            await onDone(text);
             return;
         }
         const reader = res.body.getReader();
         const decoder = new TextDecoder();
         let full = '';
         let buf = '';
+        const tcAccum = {};
         while (true) {
             const { done, value } = await reader.read();
             if (done)
@@ -157,15 +208,41 @@ async function chatOpenAI(cfg) {
                     continue;
                 try {
                     const obj = JSON.parse(data);
-                    const chunk = obj?.choices?.[0]?.delta?.content ?? '';
+                    const delta = obj?.choices?.[0]?.delta;
+                    if (!delta)
+                        continue;
+                    const chunk = delta.content ?? '';
                     if (chunk) {
                         full += chunk;
                         onChunk(chunk);
                     }
+                    if (delta.tool_calls) {
+                        for (const tc of delta.tool_calls) {
+                            const idx = tc.index ?? 0;
+                            if (!tcAccum[idx])
+                                tcAccum[idx] = { id: '', name: '', args: '' };
+                            if (tc.id)
+                                tcAccum[idx].id = tc.id;
+                            if (tc.function?.name)
+                                tcAccum[idx].name += tc.function.name;
+                            if (tc.function?.arguments)
+                                tcAccum[idx].args += tc.function.arguments;
+                        }
+                    }
                 }
                 catch { }
             }
         }
+        // Serialize accumulated tool_calls to XML for run loop compatibility
+        for (const idx of Object.keys(tcAccum).map(Number).sort((a, b) => a - b)) {
+            const tc = tcAccum[idx];
+            let args = {};
+            try {
+                args = JSON.parse(tc.args);
+            }
+            catch { }
+            full += `\n<tool_call>\n{"name": ${JSON.stringify(tc.name)}, "args": ${JSON.stringify(args)}}\n</tool_call>`;
+        }
         await onDone(full);
     }
     catch (err) {
@@ -174,20 +251,30 @@ async function chatOpenAI(cfg) {
     }
 }
 async function chatAnthropic(cfg) {
-    const { model, messages, baseUrl, apiKey, signal, onDone, onError, onUsage, onRetry } = cfg;
+    const { model, messages, baseUrl, apiKey, signal, onDone, onError, onUsage, onChunk, onRetry, tools, toolChoice } = cfg;
     const url = baseUrl && baseUrl !== 'http://localhost:11434'
         ? `${baseUrl}/v1/messages`
         : 'https://api.anthropic.com/v1/messages';
     const systemParts = messages.filter(m => m.role === 'system').map(m => m.content);
     const filtered = messages.filter(m => m.role !== 'system');
+    const body = {
+        model,
+        max_tokens: 8192,
+        stream: !!onChunk,
+        messages: filtered,
+    };
+    if (systemParts.length)
+        body.system = systemParts.join('\n\n');
+    if (tools?.length) {
+        body.tools = tools.map(t => ({
+            name: t.name,
+            description: t.description,
+            input_schema: paramsToSchema(t.params),
+        }));
+        if (toolChoice === 'none')
+            body.tool_choice = { type: 'none' };
+    }
     try {
-        const body = {
-            model,
-            max_tokens: 8192,
-            messages: filtered,
-        };
-        if (systemParts.length)
-            body.system = systemParts.join('\n\n');
         const res = await fetchWithRetry(url, {
             method: 'POST',
             headers: {
@@ -201,10 +288,86 @@ async function chatAnthropic(cfg) {
             onError(new Error(`Anthropic ${res.status}: ${await res.text()}`));
             return;
         }
-        const obj = await res.json();
-        const text = (obj.content ?? []).filter(c => c.type === 'text').map(c => c.text).join('');
-        onUsage?.(obj.usage?.input_tokens ?? 0, obj.usage?.output_tokens ?? 0);
-        await onDone(text);
+        if (!onChunk) {
+            const obj = await res.json();
+            let fullText = '';
+            for (const block of obj?.content ?? []) {
+                if (block.type === 'text')
+                    fullText += block.text ?? '';
+                else if (block.type === 'tool_use') {
+                    const args = block.input ?? {};
+                    fullText += `\n<tool_call>\n{"name": ${JSON.stringify(block.name ?? '')}, "args": ${JSON.stringify(args)}}\n</tool_call>`;
+                }
+            }
+            onUsage?.(obj?.usage?.input_tokens ?? 0, obj?.usage?.output_tokens ?? 0);
+            await onDone(fullText);
+            return;
+        }
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buf = '';
+        let fullText = '';
+        let promptTokens = 0;
+        let completionTokens = 0;
+        // Track native tool_use content blocks
+        const toolBlocks = [];
+        let activeToolIdx = -1;
+        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 || data === '[DONE]')
+                    continue;
+                try {
+                    const evt = JSON.parse(data);
+                    if (evt.type === 'message_start') {
+                        promptTokens = (evt.message?.usage?.input_tokens) ?? 0;
+                    }
+                    else if (evt.type === 'content_block_start') {
+                        const block = evt.content_block;
+                        if (block.type === 'tool_use') {
+                            activeToolIdx = toolBlocks.length;
+                            toolBlocks.push({ id: block.id ?? '', name: block.name ?? '', inputJson: '' });
+                        }
+                    }
+                    else if (evt.type === 'content_block_delta') {
+                        const delta = evt.delta;
+                        if (delta.type === 'text_delta' && delta.text) {
+                            fullText += delta.text;
+                            onChunk?.(delta.text);
+                        }
+                        else if (delta.type === 'input_json_delta' && activeToolIdx >= 0) {
+                            toolBlocks[activeToolIdx].inputJson += delta.partial_json ?? '';
+                        }
+                    }
+                    else if (evt.type === 'content_block_stop') {
+                        activeToolIdx = -1;
+                    }
+                    else if (evt.type === 'message_delta') {
+                        completionTokens = (evt.usage?.output_tokens) ?? 0;
+                    }
+                }
+                catch { }
+            }
+        }
+        // Serialize native tool_use blocks to XML for run loop compatibility
+        for (const block of toolBlocks) {
+            let args = {};
+            try {
+                args = JSON.parse(block.inputJson);
+            }
+            catch { }
+            fullText += `\n<tool_call>\n{"name": ${JSON.stringify(block.name)}, "args": ${JSON.stringify(args)}}\n</tool_call>`;
+        }
+        onUsage?.(promptTokens, completionTokens);
+        await onDone(fullText);
     }
     catch (err) {
         if (err?.name !== 'AbortError')

package/dist/mcp/client.js

@@ -22,7 +22,9 @@ export class MCPClient {
             stdio: ['pipe', 'pipe', 'pipe'],
             env: { ...process.env, ...cfg.env },
         });
-        this.proc.stderr?.on('data', () => { });
+        this.proc.stderr?.on('data', (d) => {
+            d.toString().split('\n').filter(Boolean).forEach(line => process.stderr.write(`[MCP:${this.name}] ${line}\n`));
+        });
         const rl = createInterface({ input: this.proc.stdout });
         rl.on('line', (line) => {
             if (!line.trim())
@@ -73,6 +75,11 @@ export class MCPClient {
                 resolve: (v) => { clearTimeout(timer); resolve(v); },
                 reject: (e) => { clearTimeout(timer); reject(e); },
             });
+            if (!this.proc?.stdin?.writable) {
+                this.pending.delete(id);
+                reject(new Error('MCP process stdin not writable'));
+                return;
+            }
             this.proc.stdin.write(JSON.stringify({ jsonrpc: '2.0', id, method, params }) + '\n');
             timer = setTimeout(() => {
                 if (this.pending.has(id)) {

package/dist/memory/extractor.js

@@ -26,12 +26,43 @@ export function extractFacts(messages, config, model) {
             ],
             onDone(text) {
                 try {
-                    const m = text.match(/\[[\s\S]*?\]/);
-                    if (!m) {
+                    const start = text.indexOf('[');
+                    if (start === -1) {
                         resolve([]);
                         return;
                     }
-                    const arr = JSON.parse(m[0]);
+                    let depth = 0, inStr = false, esc = false, end = -1;
+                    for (let i = start; i < text.length; i++) {
+                        const ch = text[i];
+                        if (esc) {
+                            esc = false;
+                            continue;
+                        }
+                        if (ch === '\\' && inStr) {
+                            esc = true;
+                            continue;
+                        }
+                        if (ch === '"') {
+                            inStr = !inStr;
+                            continue;
+                        }
+                        if (inStr)
+                            continue;
+                        if (ch === '[')
+                            depth++;
+                        else if (ch === ']') {
+                            depth--;
+                            if (depth === 0) {
+                                end = i;
+                                break;
+                            }
+                        }
+                    }
+                    if (end === -1) {
+                        resolve([]);
+                        return;
+                    }
+                    const arr = JSON.parse(text.slice(start, end + 1));
                     resolve(Array.isArray(arr) ? arr.filter((f) => typeof f === 'string') : []);
                 }
                 catch {

package/dist/skills/loader.js

@@ -167,8 +167,10 @@ export class SkillLoader {
         const pkg = nameOrPkg.includes('/') || nameOrPkg.startsWith('miii-skill-')
             ? nameOrPkg
             : `miii-skill-${nameOrPkg}`;
+        if (!/^[a-zA-Z0-9@/._-]+$/.test(pkg))
+            throw new Error(`invalid package name: ${pkg}`);
         createDir(NPM_SKILLS_DIR);
-        const { stdout, stderr } = await run(`npm install --prefix ${JSON.stringify(NPM_SKILLS_DIR)} ${pkg}`);
+        const { stdout, stderr } = await run(`npm install --prefix ${JSON.stringify(NPM_SKILLS_DIR)} ${JSON.stringify(pkg)}`);
         const out = (stdout + stderr).trim();
         // Reload newly installed skill
         await this.loadAll();
@@ -178,7 +180,9 @@ export class SkillLoader {
         const pkg = nameOrPkg.includes('/') || nameOrPkg.startsWith('miii-skill-')
             ? nameOrPkg
             : `miii-skill-${nameOrPkg}`;
-        const { stdout, stderr } = await run(`npm uninstall --prefix ${JSON.stringify(NPM_SKILLS_DIR)} ${pkg}`);
+        if (!/^[a-zA-Z0-9@/._-]+$/.test(pkg))
+            throw new Error(`invalid package name: ${pkg}`);
+        const { stdout, stderr } = await run(`npm uninstall --prefix ${JSON.stringify(NPM_SKILLS_DIR)} ${JSON.stringify(pkg)}`);
         const out = (stdout + stderr).trim();
         // Remove from map
         const shortName = pkg.replace(/^miii-skill-/, '');

package/dist/tasks/compactor.js

@@ -30,7 +30,7 @@ What still needs to be done, if anything.
 Any constraints, errors encountered, important facts the agent must remember to continue correctly.
 
 Be factual. No padding. Include file paths, error messages, and command outputs verbatim when relevant.`;
-export async function compactContext(messages, cfg, goal) {
+export async function compactContext(messages, cfg, goal, signal) {
     if (contextSize(messages) <= COMPACT_CHAR_THRESHOLD)
         return messages;
     const system = messages[0]?.role === 'system' ? messages[0] : null;
@@ -50,6 +50,7 @@ export async function compactContext(messages, cfg, goal) {
     let compactErr = '';
     await chat({
         ...cfg,
+        signal,
         messages: [
             { role: 'system', content: COMPACT_SYSTEM },
             { role: 'user', content: userPrompt },
@@ -59,6 +60,8 @@ export async function compactContext(messages, cfg, goal) {
     });
     if (compactErr)
         console.error(`[compactor] LLM error: ${compactErr}`);
+    if (signal?.aborted)
+        return messages;
     // Fallback to dumb compaction if LLM fails
     if (!summary)
         return dumbCompact(messages, goal);

package/dist/tools/index.js

@@ -20,7 +20,10 @@ export const tools = [
         params: '{"path": "string"}',
         execute: async ({ path }) => {
             try {
-                return readFile(guardPath(requireArg(path, 'path', 'read_file')));
+                const safe = guardPath(requireArg(path, 'path', 'read_file'));
+                if (!existsSync(safe))
+                    throw new Error(`file not found: ${path}`);
+                return readFile(safe);
             }
             catch (e) {
                 throw new Error(`read_file: ${e}`);
@@ -73,15 +76,18 @@ export const tools = [
         params: '{"path": "string", "old": "string", "new": "string"}',
         execute: async ({ path, old: oldStr, new: newStr }) => {
             const safe = guardPath(requireArg(path, 'path', 'update_file'));
-            const current = readFile(safe);
-            if (current === null)
+            if (!existsSync(safe))
                 throw new Error(`file not found: ${path}`);
+            const current = readFile(safe);
             if (current === '')
                 throw new Error(`file empty: ${path}`);
             const old = requireArg(oldStr, 'old', 'update_file');
             if (newStr === undefined || newStr === null)
                 throw new Error('update_file: "new" argument is required');
-            const count = current.split(old).length - 1;
+            const norm = (s) => s.replace(/\r\n/g, '\n');
+            const currentNorm = norm(current);
+            const oldNorm = norm(old);
+            const count = currentNorm.split(oldNorm).length - 1;
             if (count === 0) {
                 throw new Error(`old text not found in ${path} — file may have changed since last read.\n` +
                     `Call read_file again to get current content, then retry with exact matching text.`);
@@ -89,11 +95,11 @@ export const tools = [
             if (count > 1) {
                 throw new Error(`ambiguous: ${count} matches found in ${path} — extend <old> block with more surrounding lines to make it unique`);
             }
-            const updated = current.replace(old, String(newStr));
+            const updated = currentNorm.replace(oldNorm, norm(String(newStr)));
             writeFile(safe, updated);
             // Compute affected line range for the snippet
-            const startLine = current.slice(0, current.indexOf(old)).split('\n').length;
-            const oldLines = old.split('\n').length;
+            const startLine = currentNorm.slice(0, currentNorm.indexOf(oldNorm)).split('\n').length;
+            const oldLines = oldNorm.split('\n').length;
             const newLines = newStr.split('\n').length;
             const updatedArr = updated.split('\n');
             const snippetStart = Math.max(0, startLine - 3);
@@ -287,14 +293,16 @@ export function getSystemPrompt(extra = '', extraTools = []) {
     const toolDocs = allTools.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.
 - search_codebase({"query": "string", "k": "number (optional)"}): Semantic vector search over the indexed codebase. Returns top-k relevant code snippets by meaning. Requires the user to have run /index build. Use this when you need to find code by concept rather than exact string — e.g. "authentication logic", "error handling patterns", "database queries".`;
-    return `You are Miii — AI coding assistant.
+    return `You are Miii — a precise, disciplined AI coding assistant. You implement exactly what is asked. Nothing more.
+
+## Tool format
 
-Tools via:
 <tool_call>
 {"name": "tool_name", "args": {...}}
 </tool_call>
 
-File content in named blocks (not inside JSON):
+File content goes in named blocks outside the JSON — never inside it:
+
 <tool_call>
 {"name": "edit_file", "args": {"path": "src/foo.ts"}}
 <content>
@@ -305,23 +313,68 @@ full file content here
 <tool_call>
 {"name": "update_file", "args": {"path": "src/foo.ts"}}
 <old>
-exact text to replace
+exact text to replace (copy verbatim from read_file output)
 </old>
 <new>
 replacement text
 </new>
 </tool_call>
 
-Tools:
+## Tools
 ${toolDocs}
 ${deepThinkDoc}
 
-Rules:
-- edit_file: new files only (errors if exists). For existing files: read_file then update_file with exact <old> text
-- Never guess old text — always re-read immediately before patching. If "old text not found": read_file again and retry
-- Plain text responses only. No markdown (#/*/\`), no code blocks — write code with tools, not in responses
-- git_status/git_diff before refactors. git_status before git_commit
-- run_tests after edits. Fix failures, retry up to 3 times
-- web_search requires "query" key exactly. Never say you can't search — always call web_search
-- deep_think: read-only research only, cannot edit files${extra}`;
+## Execution protocol
+
+For every task, follow this sequence:
+1. Read relevant files first — never assume file contents. When reading multiple independent files, emit all read_file calls in a single batch — do not wait for one before requesting the next.
+2. Make the minimal targeted change that satisfies the request
+3. Run run_tests after any edit. If tests fail, fix and retry up to 3 times before reporting
+4. For refactors or commits: git_status → git_diff first, always
+
+Parallel tool calls: when multiple tool calls have no dependency between them, issue them together in one batch. Sequential only when a later call depends on an earlier result.
+
+For exploratory questions ("how should we approach X?", "what could we do about Y?"):
+- Respond in 2-3 sentences: recommendation + main tradeoff
+- Do not implement until the user agrees
+
+For UI or frontend changes: verify the change works in a browser before reporting done. If browser testing is not possible, say so explicitly rather than claiming success.
+
+## Code discipline
+
+- Implement exactly what is asked. A bug fix is not a refactor opportunity. A one-shot task does not need a helper abstraction.
+- Three similar lines of code is better than a premature abstraction.
+- Write no comments by default. Add one only when the WHY is non-obvious: a hidden constraint, a subtle invariant, a specific bug workaround. Never explain what the code does — names do that.
+- Add no error handling for scenarios that cannot occur. Trust framework and internal code guarantees. Validate only at system boundaries: user input, external APIs, file I/O.
+- Add no backwards-compatibility shims, feature flags, or dead code for hypothetical future requirements.
+
+## File editing rules
+
+- edit_file: new files only — throws if file exists. For existing files: read_file → update_file.
+- update_file: copy the <old> text verbatim from read_file output. Never guess or paraphrase it.
+- If "old text not found": read_file again immediately and retry with exact current text.
+- Prefer update_file (surgical patch) over edit_file (full rewrite) for existing files.
+- Read a file immediately before patching it — not from earlier in the conversation.
+
+## Safety and reversibility
+
+- Before any destructive action (delete_file, overwriting content, git_commit with -A), verify the blast radius.
+- Never introduce security vulnerabilities: no command injection, no path traversal, no hardcoded secrets, no XSS, no SQL injection. If you wrote insecure code, fix it immediately.
+- run_command executes in a shell — validate any user-supplied values before interpolating into commands.
+
+## Git discipline
+
+- git_status before every commit. Never commit if working tree is unexpected.
+- Stage specific files. Use -A only when all changes are intentional and reviewed.
+- Never amend a commit unless explicitly asked.
+- Never force-push unless explicitly asked and confirmed.
+- Never skip hooks (--no-verify) unless explicitly asked. If a hook fails, diagnose and fix the root cause.
+- Never use interactive git flags (-i) — they require terminal input that is not available.
+
+## Communication
+
+- Plain text only. No markdown (no #, *, \`, ---). No code blocks in responses — write code with tools.
+- No filler: no "sure", "certainly", "happy to", "great question". State results and next steps directly.
+- web_search requires "query" key exactly. Never say you can't search — always call web_search.
+- deep_think: read-only research only. Cannot edit files.${extra}`;
 }

package/dist/tui/InputBar.js

@@ -101,7 +101,8 @@ export function InputBar({ config: initialConfig, skills, cwd, session, version,
     const abortRef = useRef(null);
     const [designTeachState, setDesignTeachState] = useState(null);
     const [designReadyPrompt, setDesignReadyPrompt] = useState(null);
-    const { projectDir, setSessionName, sessionNameRef, historyRef, saveTimerRef, systemPromptRef, pushHistory, setHistory, buildContext, renameFromMessage, updateMemory, } = useSession(session, cwd, config, mcpTools);
+    const { currentModel, setCurrentModel, currentModelRef, pickerOpen, setPickerOpen, pickerModels, pickerLoading, pickerError, pullState, handleModelSelect, handleModelPull, } = useModelPicker(config);
+    const { projectDir, setSessionName, sessionNameRef, historyRef, saveTimerRef, systemPromptRef, pushHistory, setHistory, buildContext, renameFromMessage, updateMemory, } = useSession(session, cwd, config, mcpTools, currentModelRef);
     const startDesignTeach = useCallback(() => {
         setDesignTeachState({ answers: [], idx: 0 });
     }, []);
@@ -119,7 +120,6 @@ export function InputBar({ config: initialConfig, skills, cwd, session, version,
             return { answers, idx: nextIdx };
         });
     }, []);
-    const { currentModel, setCurrentModel, currentModelRef, pickerOpen, setPickerOpen, pickerModels, pickerLoading, pickerError, pullState, handleModelSelect, handleModelPull, } = useModelPicker(config);
     const deepThinkTool = useMemo(() => ({
         name: 'deep_think',
         description: 'Research tool: gather info from files and web before answering.',

package/dist/tui/components/ConfigPicker.js

@@ -12,6 +12,7 @@ const MENU_ITEMS = [
     { key: 'key', label: 'API Key' },
     { key: 'url', label: 'Base URL' },
     { key: 'tavily', label: 'Tavily Key' },
+    { key: 'streaming', label: 'Streaming' },
 ];
 function truncate(s, n) {
     return s.length > n ? s.slice(0, n) + '…' : s;
@@ -76,7 +77,12 @@ export function ConfigPicker({ config, currentModel, tavilyKey, onUpdate, onTavi
                 return;
             }
             if (key.return) {
-                openScreen(MENU_ITEMS[menuIdx].key);
+                const item = MENU_ITEMS[menuIdx];
+                if (item.key === 'streaming') {
+                    onUpdate({ streaming: !config.streaming });
+                    return;
+                }
+                openScreen(item.key);
                 return;
             }
             return;
@@ -161,7 +167,11 @@ export function ConfigPicker({ config, currentModel, tavilyKey, onUpdate, onTavi
                     val = truncate(config.baseUrl, 36);
                 if (item.key === 'tavily')
                     val = tavilyDisplay;
-                return (_jsxs(Box, { children: [_jsxs(Text, { color: active ? 'cyan' : 'white', bold: active, children: [active ? '▶ ' : '  ', item.label.padEnd(12)] }), _jsx(Text, { color: active ? 'white' : 'gray', children: val })] }, item.key));
+                const isStreaming = item.key === 'streaming';
+                const streamingOn = config.streaming === true;
+                return (_jsxs(Box, { children: [_jsxs(Text, { color: active ? 'cyan' : 'white', bold: active, children: [active ? '▶ ' : '  ', item.label.padEnd(12)] }), isStreaming
+                            ? _jsx(Text, { color: streamingOn ? 'green' : 'gray', children: streamingOn ? 'on' : 'off' })
+                            : _jsx(Text, { color: active ? 'white' : 'gray', children: val })] }, item.key));
             }), screen === 'provider' && PROVIDERS.map((p, i) => {
                 const active = i === provIdx;
                 const current = p.key === config.provider;

package/dist/tui/components/InputArea.js

@@ -21,6 +21,7 @@ const BUILTIN_COMMANDS = [
     { ns: 'builtin', name: 'list', description: 'list all loaded skills and their descriptions' },
     // ── AI modes ─────────────────────────────────────────────────────────────
     { ns: 'builtin', name: 'plan', description: 'enter planning mode — AI helps think through a goal step-by-step' },
+    { ns: 'builtin', name: 'plan exec', description: 'two-phase: AI outputs plan first (no tools), say "go" to execute — /plan exec <task>' },
     { ns: 'builtin', name: 'refactor', description: 'multi-file AI refactor — plans, reads, then edits — /refactor <goal>' },
     { ns: 'builtin', name: 'think', description: 'deep research before answering — reads files + optional web — /think <query>' },
     { ns: 'builtin', name: 'watch', description: 'watch for file changes, run tests, auto-fix failures — /watch stop to cancel' },
@@ -176,8 +177,10 @@ export function InputArea({ status, skills, cwd, planningMode, permissionRequest
             : skill.ns === 'git'
                 ? `/git ${skill.name}`
                 : `/${skill.ns}:${skill.name}`;
-        clearInput();
-        onSubmit(name);
+        setLines([name]);
+        setCursor({ row: 0, col: name.length });
+        setOverlay('none');
+        setOverlayIdx(0);
     }
     function selectFile(file) {
         const r = cursor.row;
@@ -428,10 +431,14 @@ export function InputArea({ status, skills, cwd, planningMode, permissionRequest
             appendChar(input);
             if (prospective.startsWith('/')) {
                 if (prospective.slice(1).includes(' ')) {
-                    if (input === '@' || overlay === 'at') {
+                    if (input === '@') {
+                        filesLoadedRef.current = false;
                         setOverlay('at');
                         setOverlayIdx(0);
                     }
+                    else if (overlay === 'at') {
+                        setOverlay('at');
+                    }
                     else {
                         setOverlay('none');
                     }
@@ -441,10 +448,14 @@ export function InputArea({ status, skills, cwd, planningMode, permissionRequest
                     setOverlayIdx(0);
                 }
             }
-            else if (input === '@' || (overlay === 'at' && atQuery !== '')) {
+            else if (input === '@') {
+                filesLoadedRef.current = false;
                 setOverlay('at');
                 setOverlayIdx(0);
             }
+            else if (overlay === 'at' && atQuery !== '') {
+                setOverlay('at');
+            }
             else if (overlay === 'command') {
                 setOverlay('none');
             }

package/dist/tui/deepThink.js

@@ -42,7 +42,6 @@ Guardrails:
             apiKey: config.apiKey,
             messages: msgs,
             signal,
-            onChunk() { },
             async onDone(text) { fullText = text; },
             onError(err) { if (err.name !== 'AbortError')
                 chatError = err; },