miii-cli 1.0.2 → 1.1.1

package/README.md

@@ -72,20 +72,25 @@ This isn't autocomplete. Miii is a **full autonomous agent loop:**
 
   ● Researching: refactor auth module to use JWT
   ● Reading src/auth/session.ts
+    Read 42 lines
   ● Reading src/middleware/auth.ts
-  ● Reading src/routes/login.ts
+    Read 28 lines
 
-  Planning: 3 file(s) to change
+  ─ plan (2 actions)
+    ◦ edit_file src/auth/session.ts
+    ◦ edit_file src/middleware/auth.ts
 
   ⚠ edit_file  src/auth/session.ts   y approve  n deny
   > y
 
-  ● Editing src/auth/session.ts
-  ● Editing src/middleware/auth.ts
-  ● Editing src/routes/login.ts
-  ● Running tests
+  ● edit_file src/auth/session.ts
+    Wrote 12 lines
+  ● edit_file src/middleware/auth.ts
+    Wrote 8 lines
+  ● run_tests
+    ✅ Tests passed
 
-  ─ refactor done — 3 file(s) processed
+  ─ refactor done — 2 file(s) processed
 ```
 
 ---

package/dist/tasks/compactor.js

@@ -1,52 +1,91 @@
-const COMPACT_THRESHOLD = 18; // compact when context exceeds this many messages
-const KEEP_RECENT = 6; // always keep last N messages verbatim
+import { chat } from '../llm/stream.js';
+const COMPACT_THRESHOLD = 18;
+const KEEP_RECENT = 6;
 export function shouldCompact(messages) {
     return messages.length > COMPACT_THRESHOLD;
 }
-/**
- * Compact context to keep local models on track during long refactors.
- *
- * Strategy:
- *   1. Keep system prompt (index 0)
- *   2. Keep first user message (original goal)
- *   3. Summarise completed tool results in the middle into one message
- *   4. Keep last KEEP_RECENT messages verbatim (model's working memory)
- */
-export function compactContext(messages, goal) {
+const COMPACT_SYSTEM = `You are a context summarizer for an AI coding agent session.
+Your job: produce a dense, structured summary of the conversation so the agent can continue the task without losing context.
+
+Output format (use exactly these headers):
+
+## Task
+One sentence: what the user asked for.
+
+## Completed
+Bullet list of actions taken (files edited, commands run, decisions made). Be specific — include file paths and outcomes.
+
+## Current State
+What is true right now: which files were changed, what tests showed, what is working or broken.
+
+## Remaining
+What still needs to be done, if anything.
+
+## Key Context
+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) {
     if (messages.length <= COMPACT_THRESHOLD)
         return messages;
     const system = messages[0]?.role === 'system' ? messages[0] : null;
+    const recent = messages.slice(messages.length - KEEP_RECENT);
+    const toSummarize = messages.slice(system ? 1 : 0, messages.length - KEEP_RECENT);
+    // Build conversation transcript for the summarizer
+    const transcript = toSummarize.map(m => {
+        const role = m.role === 'assistant' ? 'Assistant' : 'User';
+        const body = m.content.length > 2000 ? m.content.slice(0, 2000) + '\n[truncated]' : m.content;
+        return `### ${role}\n${body}`;
+    }).join('\n\n');
+    const userPrompt = [
+        goal ? `The user's goal: ${goal}\n` : '',
+        `Conversation to summarize:\n\n${transcript}`,
+    ].join('');
+    let summary = '';
+    await chat({
+        ...cfg,
+        messages: [
+            { role: 'system', content: COMPACT_SYSTEM },
+            { role: 'user', content: userPrompt },
+        ],
+        onDone: (text) => { summary = text.trim(); },
+        onError: () => { },
+    });
+    // Fallback to dumb compaction if LLM fails
+    if (!summary)
+        return dumbCompact(messages, goal);
+    const summaryMsg = {
+        role: 'user',
+        content: `[Context compacted — ${toSummarize.length} messages summarised]\n\n${summary}`,
+    };
+    return [
+        ...(system ? [system] : []),
+        summaryMsg,
+        ...recent,
+    ];
+}
+function dumbCompact(messages, goal) {
+    const system = messages[0]?.role === 'system' ? messages[0] : null;
     const userGoal = messages.find(m => m.role === 'user' && !m.content.startsWith('['));
-    const anchorCount = (system ? 1 : 0) + (userGoal ? 1 : 0);
-    const middle = messages.slice(anchorCount, messages.length - KEEP_RECENT);
     const recent = messages.slice(messages.length - KEEP_RECENT);
+    const middle = messages.slice((system ? 1 : 0) + (userGoal ? 1 : 0), messages.length - KEEP_RECENT);
     const toolResults = middle
         .filter(m => m.role === 'user' && m.content.startsWith('Tool '))
-        .map(m => {
-        const lines = m.content.split('\n');
-        return `• ${lines[0]}`; // just the "Tool X result:" line
-    });
-    const assistantSummaries = middle
-        .filter(m => m.role === 'assistant' && m.content.trim().length > 0)
-        .map(m => m.content.slice(0, 120).replace(/\n/g, ' '));
+        .map(m => `• ${m.content.split('\n')[0]}`);
     const parts = [`[context compacted — ${middle.length} messages summarised]`];
     if (goal)
         parts.push(`Goal: ${goal}`);
     if (toolResults.length)
         parts.push(`Completed:\n${toolResults.join('\n')}`);
-    if (assistantSummaries.length)
-        parts.push(`Last reasoning: ${assistantSummaries.at(-1)}`);
-    const summary = { role: 'user', content: parts.join('\n\n') };
     return [
         ...(system ? [system] : []),
         ...(userGoal ? [userGoal] : []),
-        summary,
+        { role: 'user', content: parts.join('\n\n') },
         ...recent,
     ];
 }
 /**
  * Build a fresh isolated context for a single-file edit step.
- * Keeps context tiny — avoids cross-file noise polluting the model.
  */
 export function fileEditContext(systemPrompt, goal, filePath, fileContent, instruction) {
     return [

package/dist/tools/index.js

@@ -34,7 +34,7 @@ export const tools = [
     },
     {
         name: 'create_file',
-        description: 'Create a new file — fails if file already exists',
+        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);
@@ -46,16 +46,24 @@ export const tools = [
     },
     {
         name: 'edit_file',
-        description: 'Overwrite entire file — use only for new files or full rewrites',
+        description: 'Write a new file — only for files that do not exist yet. Use patch_file to modify existing files.',
         params: '{"path": "string", "content": "string"}',
         execute: async ({ path, content }) => {
-            writeFile(guardPath(path), content);
-            return `written: ${path}`;
+            const safe = guardPath(path);
+            if (existsSync(safe)) {
+                throw new Error(`edit_file cannot overwrite existing file: ${path}\n` +
+                    `Use patch_file with <old> and <new> blocks to make targeted edits.\n` +
+                    `Call read_file first to get the exact current text.`);
+            }
+            const text = content;
+            writeFile(safe, text);
+            const lines = text.split('\n').length;
+            return `created: ${path} (${lines} line${lines === 1 ? '' : 's'})`;
         },
     },
     {
         name: 'patch_file',
-        description: 'Replace an exact string in a file — use for targeted edits to existing files',
+        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);
@@ -64,12 +72,29 @@ export const tools = [
                 throw new Error(`file not found or empty: ${path}`);
             const old = oldStr;
             const count = current.split(old).length - 1;
-            if (count === 0)
-                throw new Error(`old text not found in ${path}`);
-            if (count > 1)
-                throw new Error(`ambiguous: ${count} matches found in ${path} — add more surrounding context to make unique`);
-            writeFile(safe, current.replace(old, newStr));
-            return `patched: ${path}`;
+            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.`);
+            }
+            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, 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 newLines = newStr.split('\n').length;
+            const updatedArr = updated.split('\n');
+            const snippetStart = Math.max(0, startLine - 3);
+            const snippetEnd = Math.min(updatedArr.length, startLine + newLines + 2);
+            const snippet = updatedArr
+                .slice(snippetStart, snippetEnd)
+                .map((l, i) => `${String(snippetStart + i + 1).padStart(4)} │ ${l}`)
+                .join('\n');
+            const delta = newLines - oldLines;
+            const deltaStr = delta === 0 ? '' : delta > 0 ? ` (+${delta} line${delta === 1 ? '' : 's'})` : ` (${delta} line${Math.abs(delta) === 1 ? '' : 's'})`;
+            return `patched: ${path}${deltaStr}\n\nLines ${snippetStart + 1}–${snippetEnd}:\n${snippet}`;
         },
     },
     {
@@ -284,9 +309,10 @@ ${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
-- To create a new file: use edit_file with full content in the <content> block
-- read_file before patch_file so you know the exact text to match
+- edit_file only works on NEW files — it throws an error if the file exists. Never call it on existing files
+- To modify any existing file: call read_file first, then patch_file with the exact text from that read as the <old> block
+- Never guess or reuse old text from earlier in the conversation — always re-read immediately before patching
+- If patch_file reports "old text not found", call read_file again and retry with the exact current text
 - Never delete without confirming
 - Use git_status and git_diff before any refactor to understand what has already changed
 - Use git_log to understand recent history before suggesting changes

package/dist/tui/components/InputArea.js

@@ -7,6 +7,7 @@ import { AtPicker } from './AtPicker.js';
 const BUILTIN_COMMANDS = [
     // ── Session ──────────────────────────────────────────────────────────────
     { ns: 'builtin', name: 'new', description: 'start a fresh session with a new auto-named history' },
+    { ns: 'builtin', name: 'compact', description: 'summarise conversation history now using the LLM — frees context before miii asks' },
     { ns: 'builtin', name: 'clear', description: 'wipe chat history for the current session' },
     { ns: 'builtin', name: 'sessions', description: 'list all saved sessions with message counts' },
     { ns: 'builtin', name: 'session', description: 'switch to a saved session — /session <name>' },
@@ -197,11 +198,15 @@ export function InputArea({ status, skills, cwd, planningMode, permissionRequest
     useInput((input, key) => {
         if (permissionRequest && onPermissionResponse) {
             if (input === 'y' || input === 'Y') {
-                onPermissionResponse(true);
+                onPermissionResponse('yes');
+                return;
+            }
+            if (input === 'a' || input === 'A') {
+                onPermissionResponse('session');
                 return;
             }
             if (input === 'n' || input === 'N' || key.escape) {
-                onPermissionResponse(false);
+                onPermissionResponse('no');
                 return;
             }
             return;
@@ -445,13 +450,14 @@ export function InputArea({ status, skills, cwd, planningMode, permissionRequest
     });
     const { stdout } = useStdout();
     const cols = stdout.columns ?? 80;
+    const availWidth = Math.max(20, cols - 4); // paddingX(2) + "> "(2)
     const isProcessing = status !== 'idle';
     const promptColor = (permissionRequest || compactRequest) ? 'yellow' : isProcessing ? 'yellow' : 'green';
     const inHistory = historyIdx !== -1;
     const hint = compactRequest
         ? 'y  compact   n  keep full context'
         : permissionRequest
-            ? 'y  approve   n  deny'
+            ? 'y  approve once   a  approve for session   n  deny'
             : isProcessing
                 ? 'esc  interrupt'
                 : pasteLines > 0
@@ -466,10 +472,28 @@ export function InputArea({ status, skills, cwd, planningMode, permissionRequest
     const pastePreview = pasteRef.current
         ? pasteRef.current.split('\n')[0].slice(0, cols - 6)
         : '';
-    return (_jsxs(Box, { flexDirection: "column", children: [overlay === 'command' && (_jsx(CommandPalette, { skills: allCommands, query: commandQuery, idx: overlayIdx })), overlay === 'at' && (_jsx(AtPicker, { files: filteredFiles, query: atQuery, idx: overlayIdx })), _jsx(Text, { color: "gray", dimColor: true, children: '─'.repeat(Math.max(cols, 10)) }), _jsxs(Box, { paddingX: 1, children: [_jsx(Text, { color: promptColor, bold: true, children: '> ' }), _jsx(Box, { flexDirection: "column", flexGrow: 1, children: (permissionRequest || compactRequest) ? (_jsxs(Box, { gap: 2, children: [_jsx(Text, { color: "green", bold: true, children: "y  yes" }), _jsx(Text, { color: "red", bold: true, children: "n  no" })] })) : pasteLines > 0 ? (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: "cyan", children: "\u2398" }), _jsxs(Text, { color: "cyan", children: ["pasted ", pasteLines, " line", pasteLines !== 1 ? 's' : ''] }), (lines.length > 1 || lines[0]) && (_jsx(Text, { color: "gray", dimColor: true, children: "+ typed text" }))] }), pastePreview && (_jsxs(Text, { color: "gray", dimColor: true, children: ["  ", pastePreview, pasteRef.current.split('\n')[0].length > cols - 6 ? '…' : ''] }))] })) : lines.length === 1 && !lines[0] ? (_jsx(Text, { children: isActive ? '█' : ' ' })) : (lines.map((line, i) => (_jsx(Text, { wrap: "wrap", children: i === cursor.row
-                                ? renderLineWithCursor(line, cursor.col, isActive)
-                                : line }, i)))) })] }), _jsx(Text, { color: "gray", dimColor: true, children: '─'.repeat(Math.max(cols, 10)) }), _jsxs(Text, { color: "gray", dimColor: true, children: ["  ", hint] })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [overlay === 'command' && (_jsx(CommandPalette, { skills: allCommands, query: commandQuery, idx: overlayIdx })), overlay === 'at' && (_jsx(AtPicker, { files: filteredFiles, query: atQuery, idx: overlayIdx })), _jsx(Text, { color: "gray", dimColor: true, children: '─'.repeat(Math.max(cols, 10)) }), _jsxs(Box, { paddingX: 1, children: [_jsx(Text, { color: promptColor, bold: true, children: '> ' }), _jsx(Box, { flexDirection: "column", flexGrow: 1, children: permissionRequest ? (_jsxs(Box, { gap: 3, children: [_jsx(Text, { color: "green", bold: true, children: "y  once" }), _jsx(Text, { color: "cyan", bold: true, children: "a  session" }), _jsx(Text, { color: "red", bold: true, children: "n  deny" })] })) : compactRequest ? (_jsxs(Box, { gap: 2, children: [_jsx(Text, { color: "green", bold: true, children: "y  yes" }), _jsx(Text, { color: "red", bold: true, children: "n  no" })] })) : pasteLines > 0 ? (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: "cyan", children: "\u2398" }), _jsxs(Text, { color: "cyan", children: ["pasted ", pasteLines, " line", pasteLines !== 1 ? 's' : ''] }), (lines.length > 1 || lines[0]) && (_jsx(Text, { color: "gray", dimColor: true, children: "+ typed text" }))] }), pastePreview && (_jsxs(Text, { color: "gray", dimColor: true, children: ["  ", pastePreview, pasteRef.current.split('\n')[0].length > cols - 6 ? '…' : ''] }))] })) : lines.length === 1 && !lines[0] ? (_jsx(Text, { children: isActive ? '█' : ' ' })) : (lines.map((line, i) => (_jsx(Text, { children: i === cursor.row
+                                ? viewportLine(line, cursor.col, availWidth, isActive)
+                                : line.length > availWidth ? '…' + line.slice(line.length - availWidth + 1) : line }, i)))) })] }), _jsx(Text, { color: "gray", dimColor: true, children: '─'.repeat(Math.max(cols, 10)) }), _jsxs(Text, { color: "gray", dimColor: true, children: ["  ", hint] })] }));
 }
 function renderLineWithCursor(line, col, showCursor) {
     return line.slice(0, col) + (showCursor ? '█' : '') + line.slice(col);
 }
+function viewportLine(line, col, width, active) {
+    // If line fits, render normally
+    if (line.length < width)
+        return renderLineWithCursor(line, col, active);
+    // Slide window so cursor stays in view, roughly centered
+    let start = Math.max(0, col - Math.floor(width / 2));
+    if (start + width > line.length + 1) {
+        start = Math.max(0, line.length + 1 - width);
+    }
+    const hasLeft = start > 0;
+    const sliceW = width - (hasLeft ? 1 : 0) - 1; // -1 for right indicator space
+    const slice = line.slice(start, start + sliceW);
+    const hasRight = start + sliceW < line.length;
+    const adjCol = col - start;
+    return (hasLeft ? '…' : '') +
+        renderLineWithCursor(slice, Math.max(0, Math.min(adjCol, slice.length)), active) +
+        (hasRight ? '…' : '');
+}

package/dist/tui/hooks/useRunLoop.js

@@ -20,13 +20,14 @@ export function useRunLoop(config, currentModelRef, pushHistory, extraTools = []
     const [compactRequest, setCompactRequest] = useState(null);
     const compactResolveRef = useRef(null);
     const checkpointRef = useRef(new Map());
+    const sessionApprovedRef = useRef(new Set());
     const thinkingStartRef = useRef(0);
     const extraToolsRef = useRef(extraTools);
     extraToolsRef.current = extraTools;
     const pushHistoryRef = useRef(pushHistory);
     useEffect(() => { pushHistoryRef.current = pushHistory; }, [pushHistory]);
-    const resolvePermission = useCallback((approved) => {
-        permissionResolveRef.current?.(approved);
+    const resolvePermission = useCallback((result) => {
+        permissionResolveRef.current?.(result);
         permissionResolveRef.current = null;
         setPermissionRequest(null);
     }, []);
@@ -58,9 +59,19 @@ export function useRunLoop(config, currentModelRef, pushHistory, extraTools = []
                 compactResolveRef.current = resolve;
                 setCompactRequest({ messageCount: contextMsgs.length });
             });
-            msgs = approved ? compactContext(contextMsgs, goal) : contextMsgs;
-            if (!approved)
+            if (approved) {
+                printer.systemMsg('compacting context…');
+                msgs = await compactContext(contextMsgs, {
+                    provider: config.provider,
+                    model: currentModelRef.current,
+                    baseUrl: config.baseUrl,
+                    apiKey: config.apiKey,
+                }, goal);
+                printer.systemMsg(`compacted: ${contextMsgs.length} → ${msgs.length} messages`);
+            }
+            else {
                 printer.systemMsg('keeping full context — responses may be slower');
+            }
         }
         abortRef.current = new AbortController();
         await chat({
@@ -88,6 +99,8 @@ export function useRunLoop(config, currentModelRef, pushHistory, extraTools = []
                 if (displayText)
                     printer.assistantMsg(displayText);
                 pushHistoryRef.current({ role: 'assistant', content: fullText });
+                if (pendingTools.length)
+                    printer.planSummary(pendingTools);
                 if (!pendingTools.length) {
                     const hasFencedCode = /```[\w]*\n[\s\S]{50,}?\n```/.test(fullText);
                     if (hasFencedCode && depth < MAX_TOOL_DEPTH - 1) {
@@ -109,11 +122,20 @@ export function useRunLoop(config, currentModelRef, pushHistory, extraTools = []
                         const tool = allTools.find(t => t.name === tc.name);
                         setCurrentTool(tc.name);
                         if (PERMISSION_TOOLS.has(tc.name)) {
-                            const approved = await new Promise(resolve => {
-                                permissionResolveRef.current = resolve;
-                                setPermissionRequest({ toolName: tc.name, args: tc.args });
-                            });
-                            if (!approved) {
+                            const sessionKey = tc.name;
+                            let decision;
+                            if (sessionApprovedRef.current.has(sessionKey)) {
+                                decision = 'yes';
+                            }
+                            else {
+                                decision = await new Promise(resolve => {
+                                    permissionResolveRef.current = resolve;
+                                    setPermissionRequest({ toolName: tc.name, args: tc.args });
+                                });
+                            }
+                            if (decision === 'session')
+                                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` });
                                 break;
@@ -133,11 +155,35 @@ export function useRunLoop(config, currentModelRef, pushHistory, extraTools = []
                         }
                         if (tool) {
                             try {
+                                // Guard: for patch_file, verify old text still matches before executing.
+                                // If stale, inject fresh file content and skip — model will retry.
+                                if (tc.name === 'patch_file') {
+                                    const filePath = tc.args.path;
+                                    const oldText = tc.args.old;
+                                    if (filePath && oldText && existsSync(filePath)) {
+                                        const current = readFileSync(filePath, 'utf-8');
+                                        if (!current.includes(oldText)) {
+                                            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: `patch_file failed: old text not found in ${filePath}. The file content above is the current state. Retry patch_file with the correct exact text.` });
+                                            continue;
+                                        }
+                                    }
+                                }
                                 printer.toolCallStart(tc.name, tc.args);
                                 const result = await tool.execute(tc.args);
+                                printer.toolResultSummary(tc.name, tc.args, result);
                                 if (SHOW_RESULT_TOOLS.has(tc.name))
                                     printer.toolMsg(tc.name, result);
                                 next.push({ role: 'user', content: `Tool ${tc.name} result:\n${result}` });
+                                // After any file edit, inject fresh file state so next tool sees actual content
+                                if (FILE_EDIT_TOOLS.has(tc.name)) {
+                                    const filePath = tc.args.path;
+                                    if (filePath && existsSync(filePath)) {
+                                        const fresh = readFileSync(filePath, 'utf-8');
+                                        next.push({ role: 'user', content: `[current state of ${filePath} after edit]\n${fresh}` });
+                                    }
+                                }
                             }
                             catch (e) {
                                 const err = `Tool ${tc.name} error: ${e}`;
@@ -164,6 +210,7 @@ export function useRunLoop(config, currentModelRef, pushHistory, extraTools = []
                             printer.toolCallStart('run_tests', {});
                             const testResult = await testTool.execute({});
                             if (testResult && !testResult.startsWith('(no test script') && !testResult.startsWith('(no package.json')) {
+                                printer.toolResultSummary('run_tests', {}, testResult);
                                 printer.toolMsg('run_tests', testResult);
                                 next.push({ role: 'user', content: `Test results after edits:\n${testResult}` });
                             }
@@ -178,7 +225,23 @@ export function useRunLoop(config, currentModelRef, pushHistory, extraTools = []
                         }
                     }
                 }
-                await runLoop(next, depth + 1, goal);
+                // For file-edit turns: slim context (system + goal + fresh file states + recent results)
+                // For non-edit turns: full next (model needs full conversational context)
+                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 batchMsgs = next.slice(batchStart);
+                    const slimCtx = [
+                        ...(systemMsg ? [systemMsg] : []),
+                        ...(goalMsg ? [goalMsg] : []),
+                        ...batchMsgs,
+                    ];
+                    await runLoop(slimCtx, depth + 1, goal);
+                }
+                else {
+                    await runLoop(next, depth + 1, goal);
+                }
             },
             onError(err) {
                 if (err.name !== 'AbortError')
@@ -189,8 +252,9 @@ export function useRunLoop(config, currentModelRef, pushHistory, extraTools = []
     }, [config]);
     const handleAbort = useCallback(() => {
         abortRef.current?.abort();
+        sessionApprovedRef.current.clear();
         if (permissionResolveRef.current) {
-            permissionResolveRef.current(false);
+            permissionResolveRef.current('no');
             permissionResolveRef.current = null;
             setPermissionRequest(null);
         }

package/dist/tui/hooks/useSubmit.js

@@ -3,6 +3,7 @@ import { readFile, guardPath } from '../../files/ops.js';
 import { getSystemPrompt } from '../../tools/index.js';
 import { saveConfig } from '../../config.js';
 import { loadSession, saveSession, listSessions, deleteSession, deleteAllSessions } from '../../sessions.js';
+import { compactContext } from '../../tasks/compactor.js';
 import { runDeepThink } from '../deepThink.js';
 import { buildGitContext, looksCodeRelated } from '../git-context.js';
 import { buildIndex } from '../../index/indexer.js';
@@ -162,6 +163,33 @@ export function useSubmit(deps) {
             printer.systemMsg(`model → ${name}`);
             return;
         }
+        if (cmd === '/compact') {
+            const full = buildContext();
+            if (full.length <= 2) {
+                printer.systemMsg('nothing to compact');
+                return;
+            }
+            printer.systemMsg(`compacting ${full.length} messages…`);
+            setStatus('thinking');
+            try {
+                const compacted = await compactContext(full, {
+                    provider: config.provider,
+                    model: currentModelRef.current,
+                    baseUrl: config.baseUrl,
+                    apiKey: config.apiKey,
+                }, undefined);
+                historyRef.current = compacted.filter(m => m.role !== 'system');
+                saveSession(sessionNameRef.current, historyRef.current);
+                printer.systemMsg(`compacted: ${full.length} → ${compacted.length} messages`);
+            }
+            catch (e) {
+                printer.errorMsg(`compact failed: ${e}`);
+            }
+            finally {
+                setStatus('idle');
+            }
+            return;
+        }
         if (cmd === '/new') {
             if (saveTimerRef.current) {
                 clearTimeout(saveTimerRef.current);

package/dist/tui/printer.js

@@ -192,12 +192,82 @@ 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');
+    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`);
+    }
+}
 export function toolCallStart(name, args) {
     const dot = DELETE_TOOLS.has(name) ? red('●') : EDIT_TOOLS.has(name) ? green('●') : blue('●');
-    write(`  ${dot} ${toolLabel(name, args)}\n`);
+    write(`\n${dot} ${bold(toolLabel(name, args))}\n`);
+}
+export function toolResultSummary(name, args, result) {
+    const a = args;
+    const lines = result.trim().split('\n').filter(Boolean);
+    let summary = '';
+    switch (name) {
+        case 'edit_file':
+        case 'write_file': {
+            const n = (a.content ?? '').split('\n').length;
+            summary = `Wrote ${n} line${n === 1 ? '' : 's'}`;
+            break;
+        }
+        case 'create_file': {
+            const n = (a.content ?? '').split('\n').length;
+            summary = `Created file · ${n} line${n === 1 ? '' : 's'}`;
+            break;
+        }
+        case 'patch_file':
+            summary = lines[0] ?? 'Applied patch';
+            break;
+        case 'delete_file':
+            summary = 'Deleted';
+            break;
+        case 'move_file':
+            summary = `Moved → ${a.to ?? ''}`;
+            break;
+        case 'read_file': {
+            const n = lines.length;
+            summary = `Read ${n} line${n === 1 ? '' : 's'}`;
+            break;
+        }
+        case 'list_files':
+            summary = `Found ${lines.length} file${lines.length === 1 ? '' : 's'}`;
+            break;
+        case 'run_command':
+        case 'run_tests':
+        case 'git_commit':
+        case 'git_status':
+        case 'git_diff':
+        case 'git_log': {
+            const first = lines[0]?.slice(0, 80) ?? '';
+            const more = lines.length > 1 ? ` (+${lines.length - 1} more)` : '';
+            summary = first + more;
+            break;
+        }
+        case 'web_search':
+            summary = `Found ${lines.length} result${lines.length === 1 ? '' : 's'}`;
+            break;
+        case 'web_extract':
+            summary = `Extracted ${lines.length} line${lines.length === 1 ? '' : 's'}`;
+            break;
+        case 'search_codebase':
+            summary = lines[0]?.slice(0, 80) ?? 'Done';
+            break;
+        default:
+            summary = lines[0]?.slice(0, 80) ?? 'Done';
+    }
+    if (summary)
+        write(gray(`  ${summary}`) + '\n');
 }
 export function toolMsg(name, result) {
-    const preview = result.length > 250 ? result.slice(0, 250) + '…' : result;
+    const preview = result.length > 600 ? result.slice(0, 600) + '…' : result;
     const body = preview.trim()
         ? preview.split('\n').map(l => gray('    ' + l)).join('\n')
         : '';

package/package.json

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