miii-cli 1.2.3 → 1.3.0

package/dist/init.js

@@ -5,7 +5,7 @@ import { createRequire } from 'module';
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
-import { execSync } from 'child_process';
+import { execSync, spawnSync } from 'child_process';
 import { loadConfig } from './config.js';
 import { SkillLoader } from './skills/loader.js';
 import { InputBar } from './tui/InputBar.js';
@@ -67,6 +67,45 @@ async function checkLatestVersion(current, force = false) {
     catch { }
     return undefined;
 }
+function promptYN(question) {
+    return new Promise(resolve => {
+        process.stdout.write(`  ${question} (y/N) `);
+        const onData = (key) => {
+            const k = key.toString();
+            process.stdin.setRawMode(false);
+            process.stdin.pause();
+            process.stdin.removeListener('data', onData);
+            process.stdout.write('\n');
+            if (k === '') {
+                process.exit(130);
+            } // ctrl+c in raw mode — exit cleanly
+            resolve(k.toLowerCase() === 'y');
+        };
+        try {
+            process.stdin.setRawMode(true);
+            process.stdin.resume();
+            process.stdin.setEncoding('utf-8');
+            process.stdin.on('data', onData);
+        }
+        catch {
+            // stdin not a TTY (piped input) — skip prompt
+            process.stdin.removeListener('data', onData);
+            process.stdout.write('\n');
+            resolve(false);
+        }
+    });
+}
+async function runAutoUpdate(latestVersion) {
+    process.stdout.write(`\n  Updating miii-cli to v${latestVersion}…\n\n`);
+    const result = spawnSync('npm', ['install', '-g', 'miii-cli'], { stdio: 'inherit', shell: true });
+    if (result.status === 0) {
+        process.stdout.write(`\n  Updated to v${latestVersion}. Restart miii.\n`);
+    }
+    else {
+        process.stdout.write(`\n  Update failed (exit ${result.status}). Run manually: npm install -g miii-cli\n`);
+    }
+    process.exit(result.status ?? 1);
+}
 export async function lazyInit() {
     const argv = minimist(process.argv.slice(2), {
         string: ['model', 'url', 'provider', 'session'],
@@ -105,7 +144,13 @@ export async function lazyInit() {
             process.stderr.write(`MCP: loaded ${mcpTools.length} tool(s) from ${mcpClients.length} server(s)\n`);
     }
     // Print welcome banner to scrollback BEFORE Ink starts
-    welcome(config.provider, config.model, process.cwd(), currentVersion, updateAvailable, linked);
+    welcome(process.cwd(), currentVersion, updateAvailable, linked);
+    // If update available and not a linked dev install, offer auto-update
+    if (updateAvailable && !linked && process.stdin.isTTY) {
+        const doUpdate = await promptYN(`Update available: v${updateAvailable}. Auto-update now?`);
+        if (doUpdate)
+            await runAutoUpdate(updateAvailable);
+    }
     const sessionName = argv.session || `s-${Date.now()}`;
     const { waitUntilExit } = render(React.createElement(InputBar, { config, skills, cwd: process.cwd(), session: sessionName, version: currentVersion, mcpTools }), { exitOnCtrlC: false });
     await waitUntilExit();

package/dist/mcp/client.js

@@ -73,6 +73,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/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/tools/index.js

@@ -7,6 +7,12 @@ import { getTavilyKey, tavilySearch, tavilyExtract } from '../tavily/client.js';
 const run = promisify(exec);
 const runFile = promisify(execFile);
 const EXEC_TIMEOUT_MS = 30_000;
+function requireArg(val, name, tool) {
+    if (typeof val !== 'string' || !val.length) {
+        throw new Error(`${tool}: "${name}" argument is required and must be a non-empty string`);
+    }
+    return val;
+}
 export const tools = [
     {
         name: 'read_file',
@@ -14,7 +20,10 @@ export const tools = [
         params: '{"path": "string"}',
         execute: async ({ path }) => {
             try {
-                return readFile(guardPath(path));
+                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}`);
@@ -26,7 +35,7 @@ export const tools = [
         description: 'List directory contents',
         params: '{"path": "string", "recursive": "boolean (optional)"}',
         execute: async ({ path, recursive = false }) => {
-            const entries = listFiles(guardPath(path), recursive);
+            const entries = listFiles(guardPath(requireArg(path, 'path', 'list_files')), recursive);
             if (!entries.length)
                 return '(empty)';
             return entries.map(e => `${e.type === 'dir' ? 'd' : 'f'}  ${e.rel}`).join('\n');
@@ -37,10 +46,10 @@ export const tools = [
         description: 'Create a new file with content — fails if file already exists. Prefer edit_file for new files.',
         params: '{"path": "string", "content": "string"}',
         execute: async ({ path, content }) => {
-            const safe = guardPath(path);
+            const safe = guardPath(requireArg(path, 'path', 'create_file'));
             if (existsSync(safe))
                 throw new Error(`file already exists: ${path}`);
-            writeFile(safe, content);
+            writeFile(safe, requireArg(content, 'content', 'create_file'));
             return `created: ${path}`;
         },
     },
@@ -49,13 +58,13 @@ export const tools = [
         description: 'Write a new file — only for files that do not exist yet. Use update_file to modify existing files.',
         params: '{"path": "string", "content": "string"}',
         execute: async ({ path, content }) => {
-            const safe = guardPath(path);
+            const safe = guardPath(requireArg(path, 'path', 'edit_file'));
             if (existsSync(safe)) {
                 throw new Error(`edit_file cannot overwrite existing file: ${path}\n` +
                     `Use update_file with <old> and <new> blocks to make targeted edits.\n` +
                     `Call read_file first to get the exact current text.`);
             }
-            const text = content;
+            const text = requireArg(content, 'content', 'edit_file');
             writeFile(safe, text);
             const lines = text.split('\n').length;
             return `created: ${path} (${lines} line${lines === 1 ? '' : 's'})`;
@@ -66,14 +75,19 @@ export const tools = [
         description: 'Replace an exact unique string in an existing file. Always call read_file first to get the exact text.',
         params: '{"path": "string", "old": "string", "new": "string"}',
         execute: async ({ path, old: oldStr, new: newStr }) => {
-            const safe = guardPath(path);
-            const current = readFile(safe);
-            if (current === null)
+            const safe = guardPath(requireArg(path, 'path', 'update_file'));
+            if (!existsSync(safe))
                 throw new Error(`file not found: ${path}`);
+            const current = readFile(safe);
             if (current === '')
                 throw new Error(`file empty: ${path}`);
-            const old = oldStr;
-            const count = current.split(old).length - 1;
+            const old = requireArg(oldStr, 'old', 'update_file');
+            if (newStr === undefined || newStr === null)
+                throw new Error('update_file: "new" argument is required');
+            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.`);
@@ -81,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);
@@ -104,7 +118,7 @@ export const tools = [
         description: 'Delete a file',
         params: '{"path": "string"}',
         execute: async ({ path }) => {
-            deleteFile(guardPath(path));
+            deleteFile(guardPath(requireArg(path, 'path', 'delete_file')));
             return `deleted: ${path}`;
         },
     },
@@ -113,7 +127,7 @@ export const tools = [
         description: 'Run a shell command in cwd',
         params: '{"command": "string"}',
         execute: async ({ command }) => {
-            const { stdout, stderr } = await run(command, { cwd: process.cwd(), timeout: EXEC_TIMEOUT_MS });
+            const { stdout, stderr } = await run(requireArg(command, 'command', 'run_command'), { cwd: process.cwd(), timeout: EXEC_TIMEOUT_MS });
             const out = [stdout, stderr ? `stderr: ${stderr}` : ''].filter(Boolean).join('\n').trim();
             return out.length > 8000 ? out.slice(0, 8000) + '\n…[truncated]' : out;
         },
@@ -123,7 +137,7 @@ export const tools = [
         description: 'Create a directory (and any missing parents)',
         params: '{"path": "string"}',
         execute: async ({ path }) => {
-            createDir(guardPath(path));
+            createDir(guardPath(requireArg(path, 'path', 'create_folder')));
             return `created: ${path}`;
         },
     },
@@ -132,7 +146,7 @@ export const tools = [
         description: 'Move or rename a file or directory',
         params: '{"from": "string", "to": "string"}',
         execute: async ({ from, to }) => {
-            moveFile(guardPath(from), guardPath(to));
+            moveFile(guardPath(requireArg(from, 'from', 'move_file')), guardPath(requireArg(to, 'to', 'move_file')));
             return `moved: ${from} → ${to}`;
         },
     },
@@ -279,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>
@@ -297,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

@@ -9,7 +9,7 @@ import { ConfigPicker } from './components/ConfigPicker.js';
 import { Divider } from './components/StatusBar.js';
 import { DesignTeachModal, DESIGN_TEACH_QUESTIONS, buildDesignPrompt } from './components/DesignTeachModal.js';
 import { tools } from '../tools/index.js';
-import { toolArgSummary, formatElapsed } from './printer.js';
+import { toolLabel, permissionDesc, formatElapsed, EDIT_TOOLS, DELETE_TOOLS } from './printer.js';
 import { MacroQueue } from '../tasks/queue.js';
 import { TaskExecutor } from '../tasks/executor.js';
 import { THINKING_PHRASES, SPARKLE } from './thinking.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.',
@@ -165,7 +165,7 @@ export function InputBar({ config: initialConfig, skills, cwd, session, version,
                                 setConfig(c => ({ ...c, ...configPatch }));
                                 saveConfig(configPatch);
                             }
-                        }, onTavilyKey: (key) => { saveTavilyKey(key); setTavilyKey(key); }, onClose: () => { setConfigOpen(false); } }), _jsx(Divider, { cols: cols })] })) : 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 })] })) : designTeachState ? (_jsx(DesignTeachModal, { question: DESIGN_TEACH_QUESTIONS[designTeachState.idx], index: designTeachState.idx, total: DESIGN_TEACH_QUESTIONS.length })) : permissionRequest ? (_jsxs(Box, { paddingX: 1, flexDirection: "column", 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(DiffPreview, { toolName: permissionRequest.toolName, args: permissionRequest.args })] })) : (status === 'thinking' || status === 'tool') ? (_jsx(Box, { paddingX: 1, gap: 1, children: status === 'thinking'
+                        }, onTavilyKey: (key) => { saveTavilyKey(key); setTavilyKey(key); }, onClose: () => { setConfigOpen(false); } }), _jsx(Divider, { cols: cols })] })) : 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 })] })) : designTeachState ? (_jsx(DesignTeachModal, { question: DESIGN_TEACH_QUESTIONS[designTeachState.idx], index: designTeachState.idx, total: DESIGN_TEACH_QUESTIONS.length })) : permissionRequest ? (_jsxs(Box, { paddingX: 1, flexDirection: "column", gap: 0, children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: DELETE_TOOLS.has(permissionRequest.toolName) ? 'red' : EDIT_TOOLS.has(permissionRequest.toolName) ? 'green' : 'blue', children: "\u25CF" }), _jsx(Text, { color: "white", bold: true, children: toolLabel(permissionRequest.toolName, permissionRequest.args) })] }), _jsx(Box, { paddingLeft: 2, children: _jsxs(Text, { color: "gray", dimColor: true, children: ['└ ', permissionDesc(permissionRequest.toolName)] }) }), _jsx(DiffPreview, { toolName: permissionRequest.toolName, args: permissionRequest.args })] })) : (status === 'thinking' || status === 'tool') ? (_jsx(Box, { paddingX: 1, gap: 1, children: status === 'thinking'
                     ? _jsxs(_Fragment, { children: [_jsx(Text, { color: "yellow", children: SPARKLE[tick % SPARKLE.length] }), _jsx(Text, { color: Math.floor(tick / 4) % 6 >= 2 && Math.floor(tick / 4) % 6 <= 4 ? 'white' : 'gray', italic: true, children: THINKING_PHRASES[phraseSeq[Math.floor(tick / 62) % phraseSeq.length]] }), _jsx(Text, { color: "gray", dimColor: true, children: formatElapsed(Date.now() - thinkingStartRef.current) }), taskLabel && _jsx(Text, { color: "cyan", dimColor: true, children: taskLabel })] })
                     : _jsxs(_Fragment, { children: [_jsxs(Text, { color: "yellow", dimColor: true, children: ["\u2699 running ", currentTool ?? 'tool', "\u2026"] }), _jsx(Text, { color: "gray", dimColor: true, children: formatElapsed(Date.now() - thinkingStartRef.current) }), taskLabel && _jsx(Text, { color: "cyan", dimColor: true, children: taskLabel })] }) })) : null, _jsx(InputArea, { status: status, skills: skillList, cwd: cwd, planningMode: planningMode, permissionRequest: permissionRequest, onPermissionResponse: resolvePermission, designTeach: designTeachState ? {
                     question: DESIGN_TEACH_QUESTIONS[designTeachState.idx],

package/dist/tui/components/InputArea.js

@@ -180,19 +180,19 @@ export function InputArea({ status, skills, cwd, planningMode, permissionRequest
         onSubmit(name);
     }
     function selectFile(file) {
+        const r = cursor.row;
+        const line = lines[r];
+        const before = line.slice(0, cursor.col);
+        const atIdx = before.lastIndexOf('@');
+        if (atIdx === -1)
+            return;
+        const newLine = line.slice(0, atIdx) + '@' + file.rel + ' ' + line.slice(cursor.col);
         setLines(prev => {
             const next = [...prev];
-            const r = cursor.row;
-            const line = next[r];
-            const before = line.slice(0, cursor.col);
-            const atIdx = before.lastIndexOf('@');
-            if (atIdx === -1)
-                return prev;
-            const newLine = line.slice(0, atIdx) + '@' + file.rel + ' ' + line.slice(cursor.col);
             next[r] = newLine;
-            setCursor({ row: r, col: atIdx + 1 + file.rel.length + 1 });
             return next;
         });
+        setCursor({ row: r, col: atIdx + 1 + file.rel.length + 1 });
         setOverlay('none');
         setOverlayIdx(0);
     }
@@ -428,17 +428,31 @@ export function InputArea({ status, skills, cwd, planningMode, permissionRequest
             appendChar(input);
             if (prospective.startsWith('/')) {
                 if (prospective.slice(1).includes(' ')) {
-                    setOverlay('none');
+                    if (input === '@') {
+                        filesLoadedRef.current = false;
+                        setOverlay('at');
+                        setOverlayIdx(0);
+                    }
+                    else if (overlay === 'at') {
+                        setOverlay('at');
+                    }
+                    else {
+                        setOverlay('none');
+                    }
                 }
                 else {
                     setOverlay('command');
                     setOverlayIdx(0);
                 }
             }
-            else if (input === '@' || (overlay === 'at' && atQuery !== undefined)) {
+            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; },

package/dist/tui/hooks/useRefactor.js

@@ -20,14 +20,15 @@ export function useRefactor(deps) {
                 content: `Refactor goal: ${goal}\n\nList every file that needs to change. For each file output:\nFILE: <path>\nCHANGE: <one sentence describing the edit>\n\nUse list_files and read_file to discover relevant files first. Only list files that genuinely need changes.`,
             },
         ];
-        abortRef.current = new AbortController();
+        const controller = new AbortController();
+        abortRef.current = controller;
         let planText = '';
         await chat({
             provider: config.provider,
             model: currentModelRef.current,
             baseUrl: config.baseUrl,
             messages: planCtx,
-            signal: abortRef.current.signal,
+            signal: controller.signal,
             async onDone(text) { planText = text; },
             onError(err) { printer.errorMsg(err.message); },
         });
@@ -95,7 +96,7 @@ export function useRefactor(deps) {
                 model: currentModelRef.current,
                 baseUrl: config.baseUrl,
                 messages: editCtx,
-                signal: abortRef.current?.signal,
+                signal: controller.signal,
                 async onDone(text) { editText = text; },
                 onError(err) { printer.errorMsg(`edit LLM error: ${err.message}`); },
             });

package/dist/tui/hooks/useRunLoop.js

@@ -11,7 +11,7 @@ const SHOW_RESULT_TOOLS = new Set(['run_tests', 'git_commit']);
 const PERMISSION_TOOLS = new Set(['edit_file', 'update_file', 'delete_file', 'create_file', 'move_file', 'run_command', 'git_commit']);
 const CHECKPOINT_TOOLS = new Set(['edit_file', 'update_file', 'create_file', 'delete_file']);
 // Tool result messages that are ephemeral — never worth storing in memory or compact summaries
-const EPHEMERAL_PATTERN = /^Tool (read_file|list_files|run_tests) result:|^\[current state of|^\[Context compacted/;
+const EPHEMERAL_PATTERN = /^Tool (read_file|list_files|run_tests) result:|^\[current state of|^\[Context compacted|^\[file updated:/;
 export function stripEphemeral(messages) {
     return messages.filter(m => m.role !== 'user' || !EPHEMERAL_PATTERN.test(m.content));
 }
@@ -134,7 +134,9 @@ export function useRunLoop(config, currentModelRef, pushHistory, extraTools = []
                                 sessionApprovedRef.current.add(sessionKey);
                             if (decision === 'no') {
                                 printer.systemMsg(`denied: ${tc.name}`);
-                                next.push({ role: 'user', content: `Tool ${tc.name} was denied by the user` });
+                                const remaining = pendingTools.slice(pendingTools.indexOf(tc) + 1).map(t => t.name);
+                                const skippedNote = remaining.length ? ` The following tools were also skipped: ${remaining.join(', ')}.` : '';
+                                next.push({ role: 'user', content: `Tool ${tc.name} was denied by the user.${skippedNote} Do not retry these tools unless the user explicitly asks.` });
                                 break;
                             }
                             // Checkpoint: store pre-execution file state
@@ -158,18 +160,19 @@ export function useRunLoop(config, currentModelRef, pushHistory, extraTools = []
                                     const filePath = tc.args.path;
                                     const oldText = tc.args.old;
                                     if (filePath && oldText && existsSync(filePath)) {
+                                        const norm = (s) => s.replace(/\r\n/g, '\n');
                                         const current = readFileSync(filePath, 'utf-8');
-                                        const occurrences = current.split(oldText).length - 1;
+                                        const occurrences = norm(current).split(norm(oldText)).length - 1;
                                         if (occurrences === 0) {
                                             printer.errorMsg(`patch stale: old text not found in ${filePath} — injecting fresh content`);
                                             next.push({ role: 'user', content: `Tool read_file result:\n${current}` });
-                                            next.push({ role: 'user', content: `update_file failed: old text not found in ${filePath}. The file content above is the current state. Retry update_file with the correct exact text.` });
+                                            next.push({ role: 'user', content: `update_file failed: the <old> text you used does not exist in ${filePath}. The CURRENT file content is shown above. Re-read it carefully, find the exact text you want to replace, and retry update_file using text that exactly matches what is in the file now.` });
                                             continue;
                                         }
                                         if (occurrences > 1) {
                                             printer.errorMsg(`patch ambiguous: old text matches ${occurrences} locations in ${filePath} — injecting fresh content`);
                                             next.push({ role: 'user', content: `Tool read_file result:\n${current}` });
-                                            next.push({ role: 'user', content: `update_file failed: old text matches ${occurrences} locations in ${filePath}. Use more surrounding context to make old text unique, then retry.` });
+                                            next.push({ role: 'user', content: `update_file failed: the <old> text matches ${occurrences} locations in ${filePath}. Add more surrounding lines to the <old> block to make it unique, then retry.` });
                                             continue;
                                         }
                                     }
@@ -208,8 +211,9 @@ export function useRunLoop(config, currentModelRef, pushHistory, extraTools = []
                 const didEditFiles = pendingTools.some(tc => FILE_EDIT_TOOLS.has(tc.name));
                 if (didEditFiles) {
                     const systemMsg = msgs.find(m => m.role === 'system');
-                    const goalMsg = msgs.find(m => m.role === 'user' && !m.content.startsWith('[') && !m.content.startsWith('Tool '));
-                    const batchStart = msgs.length + 1; // index in next where this batch's messages start
+                    const goalMsg = msgs.find(m => m.role === 'user' && !m.content.startsWith('[') && !m.content.startsWith('Tool '))
+                        ?? (goal ? { role: 'user', content: goal } : undefined);
+                    const batchStart = msgs.length; // include assistant message so model sees its own tool call on retry
                     const batchMsgs = next.slice(batchStart);
                     const slimCtx = [
                         ...(systemMsg ? [systemMsg] : []),

package/dist/tui/hooks/useSession.js

@@ -9,7 +9,7 @@ const SHORT_MEMORY_SIZE = 50;
 function buildSystemPrompt(cwd, facts, extraTools = []) {
     return getSystemPrompt(`\n- CWD: ${cwd}`, extraTools) + formatMemoryBlock(facts);
 }
-export function useSession(initialSession, cwd, config, extraTools = []) {
+export function useSession(initialSession, cwd, config, extraTools = [], currentModelRef) {
     const projectDir = getProjectDir(cwd);
     const [sessionName, setSessionName] = useState(initialSession);
     const sessionNameRef = useRef(initialSession);
@@ -49,7 +49,7 @@ export function useSession(initialSession, cwd, config, extraTools = []) {
         if (historyRef.current.length > SHORT_MEMORY_SIZE && !extractingRef.current) {
             const dropped = historyRef.current.splice(0, historyRef.current.length - SHORT_MEMORY_SIZE);
             extractingRef.current = true;
-            extractFacts(dropped, config, config.model).then(newFacts => {
+            extractFacts(dropped, config, currentModelRef?.current ?? config.model).then(newFacts => {
                 if (newFacts.length) {
                     const updated = mergeFacts(longMemoryRef.current, newFacts);
                     longMemoryRef.current = updated;

package/dist/tui/hooks/useSubmit.js

@@ -244,6 +244,9 @@ export function useSubmit(deps) {
                 printer.systemMsg('usage: /refactor <goal>');
                 return;
             }
+            const atRefactorContext = buildAtContext(text);
+            if (atRefactorContext)
+                pushHistory({ role: 'user', content: atRefactorContext });
             await runRefactor(goal);
             return;
         }
@@ -254,6 +257,7 @@ export function useSubmit(deps) {
                 return;
             }
             // Design task phase: use DESIGN.md context + impeccable principles
+            const atDesignContext = buildAtContext(text);
             let designContext = '';
             try {
                 const designFile = readFile(guardPath('DESIGN.md', cwd));
@@ -273,13 +277,14 @@ Impeccable design rules — follow strictly:
 - Anti-patterns to eliminate: nested card shadows, purple-to-blue gradients, disabled gray without reason, centered walls of text, auto-playing anything.
 - Write distinctive, crafted UI — not generic SaaS templates.
 - Write all code to files using tools. No code blocks in responses.`;
+            const taskDesc = sub.replace(/@[\w./\-]+/g, '').trim();
             const taskPrompt = `${designContext}${impeccableRules}
 
-Design task: ${sub}
+Design task: ${taskDesc}
 
 Analyze what exists, then implement the design. Use the design system above if available. Make it distinctive and well-crafted.`;
-            printer.userMsg(`/design ${sub}`);
-            pushHistory({ role: 'user', content: taskPrompt });
+            printer.userMsg(text);
+            pushHistory({ role: 'user', content: atDesignContext + taskPrompt });
             await runLoop(buildContext(), 0, sub);
             return;
         }
@@ -289,7 +294,10 @@ Analyze what exists, then implement the design. Use the design system above if a
                 printer.systemMsg('usage: /think <query>');
                 return;
             }
-            printer.userMsg(`/think ${query}`);
+            const atThinkContext = buildAtContext(text);
+            if (atThinkContext)
+                pushHistory({ role: 'user', content: atThinkContext });
+            printer.userMsg(text);
             setStatus('thinking');
             setTaskLabel(`gathering: ${query}`);
             abortRef.current = new AbortController();
@@ -512,6 +520,9 @@ Analyze what exists, then implement the design. Use the design system above if a
                     return;
                 }
                 if (skill.execute) {
+                    const atContext = buildAtContext(text);
+                    if (atContext)
+                        pushHistory({ role: 'user', content: atContext });
                     const ctx = {
                         messages: historyRef.current.map(m => ({ role: m.role, content: m.content })),
                         appendMessage: (_role, content) => printer.systemMsg(content),
@@ -524,8 +535,9 @@ Analyze what exists, then implement the design. Use the design system above if a
                     return;
                 }
                 if (skill.prompt) {
-                    printer.userMsg(skill.prompt);
-                    pushHistory({ role: 'user', content: skill.prompt });
+                    const atContext = buildAtContext(text);
+                    printer.userMsg(text);
+                    pushHistory({ role: 'user', content: atContext + skill.prompt });
                     await runLoop(buildContext());
                     return;
                 }

package/dist/tui/printer.js

@@ -25,6 +25,8 @@ const gray = (s) => col(90, s);
 const yellow = (s) => col(93, s);
 const purple = (s) => col(95, s);
 const red = (s) => col(91, s);
+function bgRed(s) { return `\x1b[48;2;65;18;18m\x1b[91m${s}${R}`; }
+function bgGreen(s) { return `\x1b[48;2;14;46;14m\x1b[92m${s}${R}`; }
 function stripMarkdown(s) {
     return s
         .replace(/\*\*\*(.+?)\*\*\*/g, '$1')
@@ -79,7 +81,7 @@ export function toolArgSummary(args) {
     const first = Object.values(args)[0];
     return first ? truncate(String(first), 60) : '';
 }
-export function welcome(provider, model, cwd, version, updateAvailable, linked) {
+export function welcome(cwd, version, updateAvailable, linked) {
     const cols = Math.min(process.stdout.columns ?? 80, 100);
     const innerW = cols - 2;
     const leftW = Math.floor(innerW * 0.44);
@@ -112,7 +114,6 @@ export function welcome(provider, model, cwd, version, updateAvailable, linked)
         '',
         ...miniArt,
         '',
-        `  ${gray(model + ' · ' + provider)}`,
         `  ${gray(shortCwd)}`,
         '',
     ];
@@ -121,6 +122,7 @@ export function welcome(provider, model, cwd, version, updateAvailable, linked)
         `  ${bold(yellow('Tips for getting started'))}`,
         `  Type ${cyan('@filename')} to inject file into context`,
         `  Use ${cyan('/skill')} to run a skill or command`,
+        `  Use ${cyan('/design teach')} to generate a design system`,
         `  Use ${cyan('/config')} to switch provider, model, or API key`,
         '',
     ];
@@ -159,30 +161,42 @@ export function assistantMsg(text) {
     const tail = lines.slice(idx + 1).join('\n');
     write(`\n${blue('●')} ${head}${tail ? '\n' + tail : ''}\n`);
 }
-const EDIT_TOOLS = new Set(['edit_file', 'update_file', 'create_file', 'write_file']);
-const DELETE_TOOLS = new Set(['delete_file', 'remove_file']);
-function toolLabel(name, args) {
+export const EDIT_TOOLS = new Set(['edit_file', 'update_file', 'create_file', 'write_file']);
+export const DELETE_TOOLS = new Set(['delete_file', 'remove_file']);
+const PERM_DESC = {
+    delete_file: 'delete this file',
+    update_file: 'edit this file',
+    create_file: 'create this file',
+    edit_file: 'create this file',
+    move_file: 'move this file',
+    run_command: 'run in shell',
+    git_commit: 'commit to git',
+};
+export function permissionDesc(toolName) {
+    return PERM_DESC[toolName] ?? 'allow this action';
+}
+export function toolLabel(name, args) {
     const a = args;
     const short = (s, n = 55) => s.length > n ? s.slice(0, n) + '…' : s;
     switch (name) {
-        case 'read_file': return `Reading ${a.path ?? ''}`;
-        case 'list_files': return `Listing ${a.path || '.'}`;
-        case 'create_file': return `Creating ${a.path ?? ''}`;
-        case 'edit_file': return `Writing ${a.path ?? ''}`;
-        case 'update_file': return `Updating ${a.path ?? ''}`;
-        case 'delete_file': return `Deleting ${a.path ?? ''}`;
-        case 'move_file': return `Moving ${a.from} → ${a.to}`;
-        case 'create_folder': return `Creating folder ${a.path ?? ''}`;
-        case 'run_command': return `Running ${short(a.command ?? '')}`;
-        case 'git_status': return 'Checking git status';
-        case 'git_diff': return 'Reading diff';
-        case 'git_log': return 'Reading commits';
-        case 'git_commit': return `Committing: ${short(a.message ?? '')}`;
-        case 'run_tests': return a.path ? `Running tests › ${a.path}` : 'Running tests';
-        case 'web_search': return `Searching: ${short(a.query ?? '')}`;
-        case 'web_extract': return `Extracting page`;
-        case 'deep_think': return `Researching: ${short(a.query ?? '')}`;
-        case 'search_codebase': return `Searching codebase: ${short(a.query ?? '')}`;
+        case 'read_file': return `Read(${a.path ?? ''})`;
+        case 'list_files': return `List(${a.path || '.'})`;
+        case 'create_file': return `Create(${a.path ?? ''})`;
+        case 'edit_file': return `Create(${a.path ?? ''})`;
+        case 'update_file': return `Update(${a.path ?? ''})`;
+        case 'delete_file': return `Delete(${a.path ?? ''})`;
+        case 'move_file': return `Move(${a.from} → ${a.to})`;
+        case 'create_folder': return `Mkdir(${a.path ?? ''})`;
+        case 'run_command': return `Run(${short(a.command ?? '')})`;
+        case 'git_status': return 'Git(status)';
+        case 'git_diff': return 'Git(diff)';
+        case 'git_log': return 'Git(log)';
+        case 'git_commit': return `Git(commit: ${short(a.message ?? '')})`;
+        case 'run_tests': return a.path ? `Test(${a.path})` : 'Test(suite)';
+        case 'web_search': return `Search(${short(a.query ?? '')})`;
+        case 'web_extract': return `Extract(${Array.isArray(a.urls) ? String(a.urls[0] ?? '') : String(a.urls ?? 'url')})`;
+        case 'deep_think': return `Think(${short(a.query ?? '')})`;
+        case 'search_codebase': return `Index(${short(a.query ?? '')})`;
         default: {
             const s = toolArgSummary(args);
             return s ? `${name} ${s}` : name;
@@ -192,20 +206,31 @@ function toolLabel(name, args) {
 export function planSummary(tools) {
     if (!tools.length)
         return;
-    const header = gray(`─ plan (${tools.length} action${tools.length === 1 ? '' : 's'})`);
-    write(header + '\n');
+    const lines = [gray(`─ plan (${tools.length} action${tools.length === 1 ? '' : 's'})`)];
     for (const t of tools) {
         const dot = DELETE_TOOLS.has(t.name) ? red('◦') : EDIT_TOOLS.has(t.name) ? green('◦') : blue('◦');
-        const label = toolLabel(t.name, t.args);
-        write(`  ${dot} ${gray(label)}\n`);
+        lines.push(`  ${dot} ${gray(toolLabel(t.name, t.args))}`);
     }
+    write(lines.join('\n') + '\n');
 }
 const DIFF_CTX = 2;
 const DIFF_MAX = 40;
 function printUpdateDiff(filePath, oldText, newText) {
     const oldLines = oldText.split('\n');
     const newLines = newText.split('\n');
-    write(gray(`  └ Added ${newLines.length} line${newLines.length !== 1 ? 's' : ''}, removed ${oldLines.length} line${oldLines.length !== 1 ? 's' : ''}\n`));
+    const addedCount = newLines.length;
+    const removedCount = oldLines.length;
+    const parts = [];
+    if (addedCount > 0 && removedCount > 0) {
+        parts.push(green(`+${addedCount}`), gray(' / '), red(`-${removedCount}`));
+    }
+    else if (addedCount > 0) {
+        parts.push(green(`+${addedCount} line${addedCount !== 1 ? 's' : ''}`));
+    }
+    else {
+        parts.push(red(`-${removedCount} line${removedCount !== 1 ? 's' : ''}`));
+    }
+    const out = [`  ${gray('└')} ${parts.join('')}\n`];
     let fileLines = [];
     let lineOffset = 0;
     try {
@@ -216,47 +241,50 @@ function printUpdateDiff(filePath, oldText, newText) {
             if (idx >= 0)
                 lineOffset = content.slice(0, idx).split('\n').length - 1;
             else
-                fileLines = []; // old text not in file — skip context lines
+                fileLines = [];
         }
     }
     catch { }
     let shown = 0;
     const ctxStart = Math.max(0, lineOffset - DIFF_CTX);
     for (let i = ctxStart; i < lineOffset && shown < DIFF_MAX; i++, shown++) {
-        write(gray(`  ${String(i + 1).padStart(4)}    ${fileLines[i] ?? ''}\n`));
+        out.push(`  ${gray(String(i + 1).padStart(4))}  ${gray(fileLines[i] ?? '')}\n`);
     }
     for (let i = 0; i < oldLines.length && shown < DIFF_MAX; i++, shown++) {
-        write(`  ${gray(String(lineOffset + i + 1).padStart(4))} ${red('- ')}${red(oldLines[i])}\n`);
+        out.push(`  ${gray(String(lineOffset + i + 1).padStart(4))} ${bgRed(`- ${oldLines[i]}`)}\n`);
     }
     for (let i = 0; i < newLines.length && shown < DIFF_MAX; i++, shown++) {
-        write(`  ${gray(String(lineOffset + i + 1).padStart(4))} ${green('+ ')}${green(newLines[i])}\n`);
+        out.push(`  ${gray(String(lineOffset + i + 1).padStart(4))} ${bgGreen(`+ ${newLines[i]}`)}\n`);
     }
     const ctxEnd = Math.min(fileLines.length, lineOffset + oldLines.length + DIFF_CTX);
     for (let i = lineOffset + oldLines.length; i < ctxEnd && shown < DIFF_MAX; i++, shown++) {
-        write(gray(`  ${String(i + 1).padStart(4)}    ${fileLines[i] ?? ''}\n`));
+        out.push(`  ${gray(String(i + 1).padStart(4))}  ${gray(fileLines[i] ?? '')}\n`);
     }
+    return out.join('');
 }
 function printEditPreview(content) {
     const lines = content.split('\n');
     const visible = lines.slice(0, DIFF_MAX);
     const hidden = lines.length - visible.length;
-    write(gray(`  └ ${lines.length} line${lines.length !== 1 ? 's' : ''}\n`));
+    const out = [`  ${gray('└')} ${green(`+${lines.length} line${lines.length !== 1 ? 's' : ''}`)}\n`];
     visible.forEach((line, i) => {
-        write(`  ${gray(String(i + 1).padStart(4))} ${green('+ ')}${green(line)}\n`);
+        out.push(`  ${gray(String(i + 1).padStart(4))} ${bgGreen(`+ ${line}`)}\n`);
     });
     if (hidden > 0)
-        write(gray(`  …${hidden} more line${hidden !== 1 ? 's' : ''}\n`));
+        out.push(gray(`  …${hidden} more line${hidden !== 1 ? 's' : ''}\n`));
+    return out.join('');
 }
 export function toolCallStart(name, args) {
     const dot = DELETE_TOOLS.has(name) ? red('●') : EDIT_TOOLS.has(name) ? green('●') : blue('●');
-    write(`\n${dot} ${bold(toolLabel(name, args))}\n`);
+    let out = `\n${dot} ${bold(toolLabel(name, args))}\n`;
     const a = args;
     if (name === 'update_file' && a.old && a.new && a.path) {
-        printUpdateDiff(a.path, a.old, a.new);
+        out += printUpdateDiff(a.path, a.old, a.new);
     }
-    else if (name === 'edit_file' && a.content && a.path) {
-        printEditPreview(a.content);
+    else if ((name === 'edit_file' || name === 'create_file') && a.content && a.path) {
+        out += printEditPreview(a.content);
     }
+    write(out);
 }
 export function toolResultSummary(name, args, result) {
     const a = args;

package/package.json

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