miii-agent 0.1.10 → 0.1.12

package/README.md

@@ -92,6 +92,7 @@ Once inside the TUI, just type naturally:
 | `/models` | Switch active Ollama model |
 | `/clear` | Reset conversation history |
 | `Esc` | Stop current generation or tool run |
+| `Ctrl+O` | Toggle full tool output view |
 | `Ctrl+C` | Quit |
 
 ---
@@ -124,7 +125,7 @@ miii ships with a built-in tool suite the agent can invoke autonomously:
 |------|-------------|
 | `read_file` | Read any file in your workspace |
 | `write_file` | Create new files |
-| `edit_file` | Precise string-level edits (no rewrites) |
+| `edit_file` | Precise string-level edits with whitespace tolerance (no rewrites) |
 | `glob` | Pattern-match files across the project |
 | `grep` | Regex search across files |
 | `run_bash` | Execute shell commands |
@@ -133,6 +134,24 @@ Every sensitive operation is gated by a permission system — you approve what t
 
 ---
 
+## Lossless output spill
+
+Big tool outputs used to get truncated — a 50K-line test log chopped to 32K, the middle gone, the model guessing at what it missed. miii doesn't truncate. It **spills**.
+
+When a tool result exceeds the inline budget (~10K bytes), the full output is written to `~/.miii/output/<id>.txt`. Only a head + tail **preview** is inlined into the conversation, followed by a pointer:
+
+```
+[command output truncated: 5184 lines / 412900 bytes.
+ Full output at ~/.miii/output/9f3a1c.txt — read it with
+ read_file offset/limit to see the elided middle.]
+```
+
+The head shows where output started; the tail catches the errors and summaries that live at the bottom. If the model needs the elided middle, it pages through it with `read_file` ranged reads — nothing is ever lost. The inline budget becomes "how much to show," not "how much exists."
+
+Spill files are confined to the app-owned `~/.miii/output` dir and garbage-collected after 24h. If the spill write fails (e.g. read-only home), miii falls back to a lossy head+tail and says so explicitly, so the context window is never blown.
+
+---
+
 ## Checking your setup
 
 miii is model-agnostic — but not every local model can actually drive an agent. A model that can't emit clean tool calls will chat at you instead of editing files. `miii doctor` tells you which of *your* installed models are up to the job, before you waste time wondering why nothing happens.
@@ -195,6 +214,10 @@ graph TD
         ReadFile -.-> Confine["Path Confinement\n(tools/paths.ts)"]
         WriteFile -.-> Confine
         EditFile -.-> Confine
+        RunBash -->|"large output"| SpillMod["Output Spill\n(tools/spill.ts)"]
+        Grep -->|"large output"| SpillMod
+        Glob -->|"large output"| SpillMod
+        SpillMod -.->|"head+tail preview\n+ read pointer"| ToolRegistry
     end
 
     Adapter -->|"HTTP streaming"| Ollama["Ollama\n(local LLM server)"]
@@ -206,10 +229,13 @@ graph TD
     subgraph Storage ["Local Storage"]
         Config["~/.miii/config.json\n(model, host, effort)"]
         Rules["~/.miii/permissions.json\n(saved allow rules)"]
+        Spill["~/.miii/output/\n(spilled tool output)"]
     end
 
     App -.->|"reads"| Config
     Policy -.->|"reads / persists 'always'"| Rules
+    SpillMod -.->|"writes full output"| Spill
+    ReadFile -.->|"pages elided middle\n(offset/limit)"| Spill
 ```
 
 ---

package/dist/cli.js

@@ -145,57 +145,176 @@ var init_client = __esm({
 });
 
 // src/tools/paths.ts
-import { resolve, relative as relative2, isAbsolute, sep } from "path";
+import { resolve, relative as relative2, isAbsolute, sep, join as join4 } from "path";
+import { homedir as homedir3 } from "os";
+function isUnder(parent, child) {
+  const rel = relative2(parent, child);
+  return rel === "" || !rel.startsWith(".." + sep) && rel !== ".." && !isAbsolute(rel);
+}
 function confinePath(p) {
   if (typeof p !== "string" || p.length === 0) {
     throw new Error("Path is required.");
   }
   const root = process.cwd();
   const abs = resolve(root, p);
-  const rel = relative2(root, abs);
-  if (rel === ".." || rel.startsWith(".." + sep) || isAbsolute(rel)) {
-    throw new Error(`Path "${p}" is outside the working directory (${root}). Access denied.`);
+  if (isUnder(root, abs) || isUnder(SPILL_DIR, abs)) {
+    return abs;
   }
-  return abs;
+  throw new Error(`Path "${p}" is outside the working directory (${root}). Access denied.`);
 }
+var SPILL_DIR;
 var init_paths = __esm({
   "src/tools/paths.ts"() {
     "use strict";
+    SPILL_DIR = resolve(join4(homedir3(), ".miii", "output"));
+  }
+});
+
+// src/tools/verifyHint.ts
+function verifyHint(path) {
+  const ext = path.slice(path.lastIndexOf(".") + 1).toLowerCase();
+  const cmds = {
+    ts: `npx tsc --noEmit`,
+    tsx: `npx tsc --noEmit`,
+    js: `node --check ${path}`,
+    jsx: `node --check ${path}`,
+    mjs: `node --check ${path}`,
+    cjs: `node --check ${path}`,
+    py: `python -m py_compile ${path}`,
+    go: `go build ./...`,
+    rs: `cargo check`,
+    rb: `ruby -c ${path}`,
+    php: `php -l ${path}`,
+    sh: `bash -n ${path}`,
+    bash: `bash -n ${path}`,
+    c: `gcc -fsyntax-only ${path}`,
+    h: `gcc -fsyntax-only ${path}`,
+    cpp: `g++ -fsyntax-only ${path}`,
+    cc: `g++ -fsyntax-only ${path}`,
+    java: `javac -d /tmp ${path}`
+  };
+  const cmd2 = cmds[ext];
+  if (!cmd2) return "";
+  return ` Now verify via run_bash: ${cmd2} \u2014 fix any errors it reports before continuing.`;
+}
+var init_verifyHint = __esm({
+  "src/tools/verifyHint.ts"() {
+    "use strict";
   }
 });
 
 // src/tools/edit_file.ts
 import { readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+function similarity(a, b) {
+  const x = a.trim();
+  const y = b.trim();
+  if (!x && !y) return 1;
+  const len = Math.max(x.length, y.length);
+  if (len === 0) return 0;
+  let same = 0;
+  for (let i = 0; i < Math.min(x.length, y.length); i++) if (x[i] === y[i]) same++;
+  return same / len;
+}
+function fuzzyRange(src, old_str) {
+  const srcLines = src.split("\n");
+  const oldLines = old_str.split("\n");
+  const norm = (l) => l.trim();
+  const oldNorm = oldLines.map(norm);
+  const offsets = new Array(srcLines.length);
+  let acc = 0;
+  for (let i = 0; i < srcLines.length; i++) {
+    offsets[i] = acc;
+    acc += srcLines[i].length + 1;
+  }
+  const matches2 = [];
+  const window = oldLines.length;
+  for (let i = 0; i + window <= srcLines.length; i++) {
+    let ok = true;
+    for (let j = 0; j < window; j++) {
+      if (norm(srcLines[i + j]) !== oldNorm[j]) {
+        ok = false;
+        break;
+      }
+    }
+    if (!ok) continue;
+    const start = offsets[i];
+    const last = i + window - 1;
+    const end = offsets[last] + srcLines[last].length;
+    matches2.push([start, end]);
+  }
+  return matches2.length === 1 ? matches2[0] : null;
+}
+function nearMiss(src, old_str) {
+  const srcLines = src.split("\n");
+  const needle = old_str.split("\n").find((l) => l.trim()) ?? old_str;
+  let bestIdx = -1;
+  let bestScore = 0;
+  for (let i = 0; i < srcLines.length; i++) {
+    const s = similarity(srcLines[i], needle);
+    if (s > bestScore) {
+      bestScore = s;
+      bestIdx = i;
+    }
+  }
+  if (bestIdx === -1 || bestScore < 0.4) return "";
+  const from = Math.max(0, bestIdx - 3);
+  const to = Math.min(srcLines.length, bestIdx + 4);
+  const width = String(to).length;
+  const ctx = srcLines.slice(from, to).map((l, i) => `${String(from + i + 1).padStart(width, " ")}	${l}`).join("\n");
+  return `
+Closest text in file (lines ${from + 1}-${to}):
+${ctx}`;
+}
 var edit_file;
 var init_edit_file = __esm({
   "src/tools/edit_file.ts"() {
     "use strict";
     init_paths();
+    init_verifyHint();
     edit_file = {
       name: "edit_file",
-      description: "Replace an exact string in a file. old_str must be unique.",
+      description: "Replace an exact string in a file. old_str must be unique unless replace_all is set. On no match, returns the closest text in the file.",
       input_schema: {
         type: "object",
         properties: {
           path: { type: "string", description: "File path" },
-          old_str: { type: "string", description: "Exact text to replace" },
-          new_str: { type: "string", description: "Replacement text" }
+          old_str: { type: "string", description: "Exact text to replace (whitespace-sensitive)" },
+          new_str: { type: "string", description: "Replacement text" },
+          replace_all: { type: "boolean", description: "Replace every occurrence instead of requiring uniqueness" }
         },
         required: ["path", "old_str", "new_str"]
       },
-      handler: ({ path, old_str, new_str }) => {
+      handler: ({ path, old_str, new_str, replace_all }) => {
         try {
+          if (old_str === new_str) {
+            return { content: `old_str and new_str are identical \u2014 nothing to change in ${path}.`, is_error: true };
+          }
           const abs = confinePath(path);
           const src = readFileSync3(abs, "utf-8");
           const first = src.indexOf(old_str);
           if (first === -1) {
-            return { content: `old_str not found in ${path}`, is_error: true };
+            if (replace_all !== true) {
+              const fuzzy = fuzzyRange(src, old_str);
+              if (fuzzy) {
+                const [s, e] = fuzzy;
+                const out2 = src.slice(0, s) + new_str + src.slice(e);
+                writeFileSync3(abs, out2, "utf-8");
+                return { content: `Edited ${path} (whitespace-tolerant match).${verifyHint(path)}` };
+              }
+            }
+            return { content: `old_str not found in ${path}.${nearMiss(src, old_str)}`, is_error: true };
           }
-          if (src.indexOf(old_str, first + 1) !== -1) {
-            return { content: `old_str not unique in ${path}`, is_error: true };
+          const all = replace_all === true;
+          if (!all && src.indexOf(old_str, first + 1) !== -1) {
+            return {
+              content: `old_str not unique in ${path}. Add surrounding context to disambiguate, or set replace_all.`,
+              is_error: true
+            };
           }
-          writeFileSync3(abs, src.slice(0, first) + new_str + src.slice(first + old_str.length), "utf-8");
-          return { content: `Edited ${path}` };
+          const out = all ? src.split(old_str).join(new_str) : src.slice(0, first) + new_str + src.slice(first + old_str.length);
+          const n = all ? src.split(old_str).length - 1 : 1;
+          writeFileSync3(abs, out, "utf-8");
+          return { content: `Edited ${path}${all ? ` (${n} occurrences)` : ""}.${verifyHint(path)}` };
         } catch (err) {
           return { content: err instanceof Error ? err.message : String(err), is_error: true };
         }
@@ -206,6 +325,10 @@ var init_edit_file = __esm({
 
 // src/tools/read_file.ts
 import { readFileSync as readFileSync4 } from "fs";
+function numbered(lines, start) {
+  const width = String(start + lines.length - 1).length;
+  return lines.map((l, i) => `${String(start + i).padStart(width, " ")}	${l}`).join("\n");
+}
 var read_file;
 var init_read_file = __esm({
   "src/tools/read_file.ts"() {
@@ -213,21 +336,40 @@ var init_read_file = __esm({
     init_paths();
     read_file = {
       name: "read_file",
-      description: "Read entire file contents as UTF-8 text.",
+      description: "Read file contents as UTF-8 text with line numbers. Use offset/limit to read a range of a large file instead of the whole thing.",
       input_schema: {
         type: "object",
         properties: {
-          path: { type: "string", description: "File path" }
+          path: { type: "string", description: "File path" },
+          offset: { type: "number", description: "1-based line to start from (default 1)" },
+          limit: { type: "number", description: "Max lines to return (default all / capped)" }
         },
         required: ["path"]
       },
-      handler: ({ path }) => {
+      handler: ({ path, offset, limit }) => {
         try {
-          const MAX = 2e5;
-          const raw = readFileSync4(confinePath(path), "utf-8");
-          const truncated = raw.length > MAX;
-          const body = truncated ? raw.slice(0, MAX) + `
-[truncated: ${raw.length - MAX} more chars]` : raw;
+          const MAX_CHARS = 2e5;
+          const buf = readFileSync4(confinePath(path));
+          if (buf.subarray(0, 8e3).includes(0)) {
+            return { content: `${path} looks binary (${buf.length} bytes); not reading as text.`, is_error: true };
+          }
+          const raw = buf.toString("utf-8").replace(/\r\n/g, "\n");
+          const allLines = raw.split("\n");
+          const total = allLines.length;
+          const start = Math.max(1, Math.floor(offset ?? 1));
+          const ranged = offset != null || limit != null;
+          const count = limit != null ? Math.max(0, Math.floor(limit)) : total;
+          const slice = allLines.slice(start - 1, start - 1 + count);
+          let body = numbered(slice, start);
+          if (body.length > MAX_CHARS) {
+            body = body.slice(0, MAX_CHARS) + `
+[truncated: output exceeded ${MAX_CHARS} chars \u2014 use offset/limit]`;
+          }
+          if (ranged) {
+            const end = start - 1 + slice.length;
+            body += `
+[showing lines ${start}-${end} of ${total}]`;
+          }
           return { content: body };
         } catch (err) {
           return { content: err instanceof Error ? err.message : String(err), is_error: true };
@@ -245,6 +387,7 @@ var init_write_file = __esm({
   "src/tools/write_file.ts"() {
     "use strict";
     init_paths();
+    init_verifyHint();
     write_file = {
       name: "write_file",
       description: "Create or overwrite a file with the given content. Parent dirs auto-created.",
@@ -261,7 +404,7 @@ var init_write_file = __esm({
           const abs = confinePath(path);
           mkdirSync3(dirname(abs), { recursive: true });
           writeFileSync4(abs, content, "utf-8");
-          return { content: `Wrote ${path} (${content.length} bytes)` };
+          return { content: `Wrote ${path} (${content.length} bytes).${verifyHint(path)}` };
         } catch (err) {
           return { content: err instanceof Error ? err.message : String(err), is_error: true };
         }
@@ -270,12 +413,63 @@ var init_write_file = __esm({
   }
 });
 
+// src/tools/spill.ts
+import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync4, rmSync as rmSync2, readdirSync as readdirSync3, statSync } from "fs";
+import { join as join5 } from "path";
+import { homedir as homedir4 } from "os";
+import { randomBytes } from "crypto";
+function ensureDir() {
+  mkdirSync4(OUTPUT_DIR, { recursive: true });
+  return OUTPUT_DIR;
+}
+function spillIfLarge(full, label = "output", budget = INLINE_BUDGET) {
+  if (full.length <= budget) return full;
+  const id = randomBytes(6).toString("hex");
+  const file = join5(ensureDir(), `${id}.txt`);
+  let path = file;
+  try {
+    writeFileSync5(file, full, "utf-8");
+  } catch {
+    path = "";
+  }
+  const head = Math.floor(budget * HEAD_FRACTION);
+  const tail = budget - head;
+  const totalLines = full.split("\n").length;
+  const preview = full.slice(0, head) + "\n\u2026\n" + full.slice(-tail);
+  const notice = path ? `[${label} truncated: ${totalLines} lines / ${full.length} bytes. Full output at ${path} \u2014 read it with read_file offset/limit to see the elided middle.]` : `[${label} truncated to ${budget} bytes; spill to disk failed, middle is lost.]`;
+  return `${preview}
+${notice}`;
+}
+function cleanupSpill(maxAgeMs = 24 * 60 * 60 * 1e3) {
+  try {
+    const now = Date.now();
+    for (const name of readdirSync3(OUTPUT_DIR)) {
+      const f = join5(OUTPUT_DIR, name);
+      try {
+        if (now - statSync(f).mtimeMs > maxAgeMs) rmSync2(f, { force: true });
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+var OUTPUT_DIR, INLINE_BUDGET, HEAD_FRACTION;
+var init_spill = __esm({
+  "src/tools/spill.ts"() {
+    "use strict";
+    OUTPUT_DIR = join5(homedir4(), ".miii", "output");
+    INLINE_BUDGET = 1e4;
+    HEAD_FRACTION = 0.3;
+  }
+});
+
 // src/tools/run_bash.ts
 import { execa } from "execa";
 var run_bash;
 var init_run_bash = __esm({
   "src/tools/run_bash.ts"() {
     "use strict";
+    init_spill();
     run_bash = {
       name: "run_bash",
       description: "Execute a shell command (bash on Unix, cmd on Windows). Returns stdout+stderr. Non-interactive only.",
@@ -300,10 +494,10 @@ var init_run_bash = __esm({
           const out = [stdout, stderr].filter(Boolean).join("\n");
           const is_error = exitCode !== 0;
           const body = out || (is_error ? `(no output)` : "");
-          const content = `${body}
+          const content = `${spillIfLarge(body, "command output")}
 [exit ${exitCode}]`;
           return {
-            content: content.slice(0, 32e3),
+            content,
             is_error
           };
         } catch (err) {
@@ -329,7 +523,7 @@ var init_grep = __esm({
           pattern: { type: "string", description: "Regex pattern" },
           path: { type: "string", description: "Root path to search (default cwd)" },
           glob: { type: "string", description: 'File glob filter, e.g. "*.ts"' },
-          case_insensitive: { type: "string", description: 'Set "true" for case-insensitive' },
+          case_insensitive: { type: "boolean", description: "Case-insensitive match" },
           max_results: { type: "number", description: "Max matching lines (default 200)" }
         },
         required: ["pattern"]
@@ -377,8 +571,25 @@ var init_grep = __esm({
 
 // src/tools/glob.ts
 import { execa as execa3 } from "execa";
-function globToFindName(glob2) {
-  return glob2;
+import { statSync as statSync2 } from "fs";
+function byMtimeDesc(paths) {
+  const mtime = /* @__PURE__ */ new Map();
+  for (const p of paths) {
+    try {
+      mtime.set(p, statSync2(p).mtimeMs);
+    } catch {
+      mtime.set(p, 0);
+    }
+  }
+  return [...paths].sort((a, b) => (mtime.get(b) ?? 0) - (mtime.get(a) ?? 0));
+}
+function globToFindArgs(root, glob2) {
+  const stripped = glob2.replace(/^\*\*\//, "");
+  if (!stripped.includes("/")) {
+    return [root, "-type", "f", "-name", stripped];
+  }
+  const pathPat = "*/" + glob2.replace(/\*\*/g, "*");
+  return [root, "-type", "f", "-path", pathPat];
 }
 var glob;
 var init_glob = __esm({
@@ -403,13 +614,10 @@ var init_glob = __esm({
           reject: false,
           timeout: 2e4
         });
-        const tryFind = () => {
-          const name = globToFindName(pattern.replace(/^\*\*\//, ""));
-          return execa3("find", [root, "-type", "f", "-name", name], {
-            reject: false,
-            timeout: 2e4
-          });
-        };
+        const tryFind = () => execa3("find", globToFindArgs(root, pattern), {
+          reject: false,
+          timeout: 2e4
+        });
         try {
           let res;
           try {
@@ -420,8 +628,9 @@ var init_glob = __esm({
           } catch {
             res = await tryFind();
           }
-          const lines = (res.stdout ?? "").split("\n").filter(Boolean).slice(0, limit);
-          if (lines.length === 0) return { content: "No files matched." };
+          const all = (res.stdout ?? "").split("\n").filter(Boolean);
+          if (all.length === 0) return { content: "No files matched." };
+          const lines = byMtimeDesc(all).slice(0, limit);
           return { content: lines.join("\n") };
         } catch (err) {
           return { content: err instanceof Error ? err.message : String(err), is_error: true };
@@ -576,10 +785,14 @@ ${toolLines}
 # Rules
 - Always read a file before updating it. Never edit, overwrite, or create-over a file you have not read first this turn.
 - Prefer editing existing files over creating new ones.
-- For edit_file, ensure old_str is unique within the target file.
+- For edit_file, make old_str unique by including surrounding context, or set replace_all to change every occurrence.
 - Never invent file paths. Read, glob, or grep before editing.
 - No filler, no pleasantries, no apologies.
 
+# Context discipline
+- read_file returns line numbers and accepts offset/limit. For large files, grep or glob to the relevant region first, then read only that range with offset/limit. Do not read a whole large file when you need a few functions \u2014 it wastes the context window.
+- Reference code by the line numbers read_file returns.
+
 # Testing and verification
 - Always test the code after a change. Run the project's tests (e.g. npm test, pytest, go test) or the relevant script via run_bash before declaring a task done.
 - If no test exists for the change, run the affected entry point via run_bash to verify it behaves correctly.
@@ -597,9 +810,9 @@ var init_system = __esm({
 });
 
 // src/permissions/policy.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync5, mkdirSync as mkdirSync4, existsSync as existsSync3, renameSync } from "fs";
-import { join as join4 } from "path";
-import { homedir as homedir3 } from "os";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, existsSync as existsSync3, renameSync } from "fs";
+import { join as join6 } from "path";
+import { homedir as homedir5 } from "os";
 function loadRules() {
   if (!existsSync3(RULES_PATH)) return [];
   try {
@@ -610,9 +823,9 @@ function loadRules() {
   }
 }
 function saveRules(rules) {
-  mkdirSync4(RULES_DIR, { recursive: true });
+  mkdirSync5(RULES_DIR, { recursive: true });
   const tmp = RULES_PATH + ".tmp";
-  writeFileSync5(tmp, JSON.stringify({ rules }, null, 2), "utf-8");
+  writeFileSync6(tmp, JSON.stringify({ rules }, null, 2), "utf-8");
   renameSync(tmp, RULES_PATH);
 }
 function addRule(tool, pattern) {
@@ -654,8 +867,8 @@ var RULES_DIR, RULES_PATH, ALWAYS_ALLOW;
 var init_policy = __esm({
   "src/permissions/policy.ts"() {
     "use strict";
-    RULES_DIR = join4(homedir3(), ".miii");
-    RULES_PATH = join4(RULES_DIR, "permissions.json");
+    RULES_DIR = join6(homedir5(), ".miii");
+    RULES_PATH = join6(RULES_DIR, "permissions.json");
     ALWAYS_ALLOW = /* @__PURE__ */ new Set(["read_file", "grep", "glob"]);
   }
 });
@@ -985,16 +1198,16 @@ var init_loop = __esm({
 });
 
 // eval/runner.ts
-import { mkdtempSync, writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, rmSync as rmSync2 } from "fs";
-import { dirname as dirname2, join as join5 } from "path";
+import { mkdtempSync, writeFileSync as writeFileSync7, mkdirSync as mkdirSync6, rmSync as rmSync3 } from "fs";
+import { dirname as dirname2, join as join7 } from "path";
 import { tmpdir } from "os";
 async function runScenario(model, s) {
-  const dir = mkdtempSync(join5(tmpdir(), "miii-eval-"));
+  const dir = mkdtempSync(join7(tmpdir(), "miii-eval-"));
   const prevCwd = process.cwd();
   for (const [rel, content] of Object.entries(s.files ?? {})) {
-    const abs = join5(dir, rel);
-    mkdirSync5(dirname2(abs), { recursive: true });
-    writeFileSync6(abs, content, "utf-8");
+    const abs = join7(dir, rel);
+    mkdirSync6(dirname2(abs), { recursive: true });
+    writeFileSync7(abs, content, "utf-8");
   }
   const r = {
     name: s.name,
@@ -1032,7 +1245,7 @@ async function runScenario(model, s) {
   r.durationMs = Date.now() - start;
   if (r.error) {
     r.reason = `loop error: ${r.error}`;
-    rmSync2(dir, { recursive: true, force: true });
+    rmSync3(dir, { recursive: true, force: true });
     return r;
   }
   try {
@@ -1042,7 +1255,7 @@ async function runScenario(model, s) {
   } catch (err) {
     r.reason = `check threw: ${err instanceof Error ? err.message : String(err)}`;
   }
-  rmSync2(dir, { recursive: true, force: true });
+  rmSync3(dir, { recursive: true, force: true });
   return r;
 }
 var autoYes;
@@ -1056,12 +1269,12 @@ var init_runner = __esm({
 
 // eval/scenarios.ts
 import { readFileSync as readFileSync6, existsSync as existsSync4 } from "fs";
-import { join as join6 } from "path";
+import { join as join8 } from "path";
 var read, scenarios;
 var init_scenarios = __esm({
   "eval/scenarios.ts"() {
     "use strict";
-    read = (dir, f) => existsSync4(join6(dir, f)) ? readFileSync6(join6(dir, f), "utf-8") : null;
+    read = (dir, f) => existsSync4(join8(dir, f)) ? readFileSync6(join8(dir, f), "utf-8") : null;
     scenarios = [
       {
         name: "edit-exact-string",
@@ -1208,9 +1421,9 @@ import { createElement } from "react";
 
 // src/ui/App.tsx
 init_client();
-import { useState as useState4, useEffect as useEffect3 } from "react";
+import { useState as useState5, useEffect as useEffect4 } from "react";
 import { Box as Box10, Text as Text10, useApp } from "ink";
-import { homedir as homedir4 } from "os";
+import { homedir as homedir6 } from "os";
 import { sep as sep2 } from "path";
 
 // src/config.ts
@@ -1650,6 +1863,7 @@ function FilePicker({ matches: matches2, cursor }) {
 }
 
 // src/ui/ChatView.tsx
+import { useState as useState3, useEffect as useEffect3 } from "react";
 import { Box as Box9, Text as Text9 } from "ink";
 
 // src/ui/ThinkingBlock.tsx
@@ -1710,6 +1924,24 @@ var EMPTY_STATE_TITLE = "Ask anything, or try:";
 
 // src/ui/ChatView.tsx
 import { jsx as jsx9, jsxs as jsxs9 } from "react/jsx-runtime";
+var COLLAPSED_LINES = 3;
+var globalToolExpanded = false;
+var toolExpandListeners = /* @__PURE__ */ new Set();
+function toggleToolExpanded() {
+  globalToolExpanded = !globalToolExpanded;
+  toolExpandListeners.forEach((fn) => fn());
+}
+function useToolExpanded() {
+  const [expanded, setExpanded] = useState3(globalToolExpanded);
+  useEffect3(() => {
+    const handler = () => setExpanded(globalToolExpanded);
+    toolExpandListeners.add(handler);
+    return () => {
+      toolExpandListeners.delete(handler);
+    };
+  }, []);
+  return expanded;
+}
 function formatTokens(n) {
   if (n >= 1e3) return (n / 1e3).toFixed(n >= 1e4 ? 0 : 1) + "k";
   return String(n);
@@ -1732,8 +1964,8 @@ function FileEditBlock({
   removed,
   previewLines
 }) {
-  const MAX = 16;
-  const shown = previewLines.slice(0, MAX);
+  const expanded = useToolExpanded();
+  const shown = expanded ? previewLines : previewLines.slice(0, COLLAPSED_LINES);
   const extra = previewLines.length - shown.length;
   return /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", marginLeft: 2, children: [
     /* @__PURE__ */ jsxs9(Box9, { children: [
@@ -1750,15 +1982,22 @@ function FileEditBlock({
       "\u23BF  ",
       removed > 0 ? `Added ${added} lines, removed ${removed} lines` : `Added ${added} lines`
     ] }) }),
-    shown.map((ln, i) => /* @__PURE__ */ jsx9(Box9, { marginLeft: 4, children: /* @__PURE__ */ jsxs9(Text9, { color: ln.sign === "+" ? "green" : ln.sign === "-" ? "red" : void 0, dimColor: ln.sign === " ", children: [
-      ln.sign,
-      " ",
-      ln.text
-    ] }) }, i)),
+    shown.map((ln, i) => {
+      const width = (process.stdout.columns ?? 80) - 6;
+      const content = `${ln.sign} ${ln.text}`.padEnd(width);
+      return /* @__PURE__ */ jsx9(Box9, { marginLeft: 4, children: /* @__PURE__ */ jsx9(
+        Text9,
+        {
+          backgroundColor: ln.sign === "+" ? "#13351f" : ln.sign === "-" ? "#3b1414" : void 0,
+          dimColor: ln.sign === " ",
+          children: content
+        }
+      ) }, i);
+    }),
     extra > 0 && /* @__PURE__ */ jsx9(Box9, { marginLeft: 4, children: /* @__PURE__ */ jsxs9(Text9, { dimColor: true, children: [
       "\u2026 ",
       extra,
-      " more lines"
+      " more lines \xB7 ctrl+o to expand"
     ] }) })
   ] });
 }
@@ -1824,6 +2063,7 @@ function summarizeResult(res, toolName) {
   return extra > 0 ? `${head} (+${extra} lines)` : head;
 }
 function ToolResultBlock({ result, toolName }) {
+  const expanded = useToolExpanded();
   const content = result.content ?? "";
   const lines = content.split("\n");
   const showMulti = (toolName === "run_bash" || toolName === "grep" || toolName === "glob" || result.is_error) && lines.length > 1;
@@ -1833,9 +2073,9 @@ function ToolResultBlock({ result, toolName }) {
       summarizeResult(result, toolName)
     ] }) });
   }
-  const MAX_LINES = 10;
   const MAX_LINE_WIDTH = 200;
-  const shown = lines.slice(0, MAX_LINES).map((l) => truncate(l, MAX_LINE_WIDTH));
+  const visible = expanded ? lines : lines.slice(0, COLLAPSED_LINES);
+  const shown = visible.map((l) => truncate(l, MAX_LINE_WIDTH));
   const extra = lines.length - shown.length;
   return /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", marginLeft: 2, children: [
     /* @__PURE__ */ jsxs9(Text9, { color: result.is_error ? "red" : void 0, dimColor: !result.is_error, children: [
@@ -1846,7 +2086,7 @@ function ToolResultBlock({ result, toolName }) {
     extra > 0 && /* @__PURE__ */ jsx9(Box9, { marginLeft: 4, children: /* @__PURE__ */ jsxs9(Text9, { dimColor: true, children: [
       "\u2026 ",
       extra,
-      " more lines"
+      " more lines \xB7 ctrl+o to expand"
     ] }) })
   ] });
 }
@@ -1987,22 +2227,22 @@ function ChatView({
 
 // src/ui/hooks/useAgentRunner.ts
 init_loop();
-import { useState as useState3, useRef } from "react";
+import { useState as useState4, useRef } from "react";
 var FLUSH_MS = 100;
 function useAgentRunner(model, activeCtx) {
-  const [messages, setMessages] = useState3([]);
-  const [thinking, setThinking] = useState3(false);
-  const [thinkingContent, setThinkingContent] = useState3("");
-  const [streaming, setStreaming] = useState3(false);
-  const [streamingContent, setStreamingContent] = useState3("");
-  const [error, setError] = useState3(null);
-  const [busy, setBusy] = useState3(false);
-  const [processingLabel, setProcessingLabel] = useState3(void 0);
-  const [agentHistory, setAgentHistory] = useState3([]);
-  const [pendingPermission, setPendingPermission] = useState3(null);
-  const [permissionCursor, setPermissionCursor] = useState3(0);
-  const [activeToolUses, setActiveToolUses] = useState3([]);
-  const [activeToolResults, setActiveToolResults] = useState3([]);
+  const [messages, setMessages] = useState4([]);
+  const [thinking, setThinking] = useState4(false);
+  const [thinkingContent, setThinkingContent] = useState4("");
+  const [streaming, setStreaming] = useState4(false);
+  const [streamingContent, setStreamingContent] = useState4("");
+  const [error, setError] = useState4(null);
+  const [busy, setBusy] = useState4(false);
+  const [processingLabel, setProcessingLabel] = useState4(void 0);
+  const [agentHistory, setAgentHistory] = useState4([]);
+  const [pendingPermission, setPendingPermission] = useState4(null);
+  const [permissionCursor, setPermissionCursor] = useState4(0);
+  const [activeToolUses, setActiveToolUses] = useState4([]);
+  const [activeToolResults, setActiveToolResults] = useState4([]);
   const busyRef = useRef(false);
   const abortRef = useRef(null);
   const pendingPermissionRef = useRef(null);
@@ -2273,6 +2513,10 @@ function useKeyboard(opts) {
       toggleThinkingVisible();
       return;
     }
+    if (key.ctrl && char === "o") {
+      toggleToolExpanded();
+      return;
+    }
     if (key.escape && busyRef.current && abortRef.current) {
       abortRef.current.abort();
       return;
@@ -2497,31 +2741,31 @@ async function checkForUpdate() {
 import { Fragment as Fragment2, jsx as jsx10, jsxs as jsxs10 } from "react/jsx-runtime";
 function App() {
   const { exit } = useApp();
-  const cwd = process.cwd().replace(homedir4(), "~").split(sep2).join("/");
-  const [cfg, setCfg] = useState4(loadConfig());
-  const [models, setModels] = useState4([]);
-  const [contexts, setContexts] = useState4({});
-  const [activeCtx, setActiveCtx] = useState4(null);
-  const [state, setState] = useState4("loading");
-  const [cursor, setCursor] = useState4(0);
-  const [updateAvailable, setUpdateAvailable] = useState4(null);
-  const [ollamaDown, setOllamaDown] = useState4(false);
-  const [sessionId, setSessionId] = useState4(() => newSessionId());
-  const [sessions, setSessions] = useState4([]);
-  const [notice, setNotice] = useState4(null);
-  const [input, setInput] = useState4("");
-  const [paletteCursor, setPaletteCursor] = useState4(0);
-  const [filePickerCursor, setFilePickerCursor] = useState4(0);
+  const cwd = process.cwd().replace(homedir6(), "~").split(sep2).join("/");
+  const [cfg, setCfg] = useState5(loadConfig());
+  const [models, setModels] = useState5([]);
+  const [contexts, setContexts] = useState5({});
+  const [activeCtx, setActiveCtx] = useState5(null);
+  const [state, setState] = useState5("loading");
+  const [cursor, setCursor] = useState5(0);
+  const [updateAvailable, setUpdateAvailable] = useState5(null);
+  const [ollamaDown, setOllamaDown] = useState5(false);
+  const [sessionId, setSessionId] = useState5(() => newSessionId());
+  const [sessions, setSessions] = useState5([]);
+  const [notice, setNotice] = useState5(null);
+  const [input, setInput] = useState5("");
+  const [paletteCursor, setPaletteCursor] = useState5(0);
+  const [filePickerCursor, setFilePickerCursor] = useState5(0);
   const agent = useAgentRunner(cfg.model, activeCtx);
-  useEffect3(() => {
+  useEffect4(() => {
     checkForUpdate().then((v) => {
       if (v) setUpdateAvailable(v);
     });
   }, []);
-  useEffect3(() => {
+  useEffect4(() => {
     if (agent.agentHistory.length) persistSession(sessionId, agent.agentHistory);
   }, [agent.agentHistory, sessionId]);
-  useEffect3(() => {
+  useEffect4(() => {
     listModels().then((m) => {
       setModels(m);
       setState(cfg.model ? "ready" : "select-model");
@@ -2635,6 +2879,8 @@ function App() {
 }
 
 // src/cli.tsx
+init_spill();
+cleanupSpill();
 var [, , cmd, ...rest] = process.argv;
 if (cmd === "update" || cmd === "--update" || cmd === "-u") {
   const { spawnSync } = await import("child_process");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "miii-agent",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "Terminal AI coding agent powered by Ollama",
   "type": "module",
   "bin": {