miii-agent 0.1.31 → 0.1.33

package/dist/cli.js

@@ -184,7 +184,7 @@ async function modelContext(entry, model) {
     }
     const msg = err instanceof Error ? err.message : String(err);
     if (msg.toLowerCase().includes("not found") || msg.toLowerCase().includes("unknown model")) {
-      throw new Error(`Model "${model}" not found. Run: ollama pull ${model}`);
+      throw new Error(`I don't see a model called "${model}" on Ollama. Pull it first with: ollama pull ${model}`);
     }
     throw err;
   }
@@ -240,7 +240,7 @@ async function* chat(entry, model, messages, tools, opts) {
     }
     const msg = err instanceof Error ? err.message : String(err);
     if (msg.toLowerCase().includes("not found") || msg.toLowerCase().includes("unknown model")) {
-      throw new Error(`Model "${model}" not found. Run: ollama pull ${model}`);
+      throw new Error(`I don't see a model called "${model}" on Ollama. Pull it first with: ollama pull ${model}`);
     }
     throw err;
   }
@@ -278,8 +278,8 @@ var NOT_INSTALLED, NOT_RUNNING, LOCAL_HOST_RE, HARMONY_RE, CHANNEL_LABEL_RE;
 var init_ollama = __esm({
   "src/llm/ollama.ts"() {
     "use strict";
-    NOT_INSTALLED = "Ollama is not installed. Install it with: npm i -g ollama\nOr download from https://ollama.com/download";
-    NOT_RUNNING = "Ollama is not running. Start it with: ollama serve";
+    NOT_INSTALLED = "I can't find Ollama on this machine. Install it with: npm i -g ollama\nOr download it from https://ollama.com/download";
+    NOT_RUNNING = "Ollama isn't running, so I can't reach it. Start it with: ollama serve";
     LOCAL_HOST_RE = /localhost|127\.0\.0\.1|0\.0\.0\.0|\[::1\]/;
     HARMONY_RE = /<\|?\/?(?:channel|message|start|end|return|constrain|assistant|user|system|developer|tool|tool_call|tool_response|final|analysis|commentary)\|?>/gi;
     CHANNEL_LABEL_RE = /^(?:analysis|commentary|final)\s*(?=\w)/i;
@@ -288,7 +288,7 @@ var init_ollama = __esm({
 
 // src/llm/openai.ts
 function notAvailable(entry) {
-  return `Cannot reach OpenAI-compatible provider at ${entry.baseUrl}. Make sure the server is running and the baseUrl is correct.`;
+  return `I couldn't reach the provider at ${entry.baseUrl}. Check that the server is running and the baseUrl is correct.`;
 }
 function headers(entry) {
   const h = { "Content-Type": "application/json" };
@@ -314,7 +314,7 @@ async function listModels2(entry) {
         detail = await res.text();
       } catch {
       }
-      throw new Error(`Provider error (HTTP ${res.status}): ${detail || res.statusText}`);
+      throw new Error(`The provider came back with an error (HTTP ${res.status}): ${detail || res.statusText}`);
     }
     const body = await res.json();
     return body.data.map((m) => m.id);
@@ -406,12 +406,12 @@ async function* chat2(entry, model, messages, tools, opts) {
       } catch {
       }
       if (res.status === 404) {
-        throw new Error(`Model "${model}" not found at ${entry.baseUrl}. Make sure it's available.`);
+        throw new Error(`The provider at ${entry.baseUrl} has no model called "${model}". Double-check the name, or pick another with /models.`);
       }
-      throw new Error(`Provider error (HTTP ${res.status}): ${detail || res.statusText}`);
+      throw new Error(`The provider came back with an error (HTTP ${res.status}): ${detail || res.statusText}`);
     }
     const reader = res.body?.getReader();
-    if (!reader) throw new Error("No response body");
+    if (!reader) throw new Error("The provider answered but sent no body to read.");
     const decoder = new TextDecoder();
     let buffer = "";
     try {
@@ -470,7 +470,7 @@ async function* chat2(entry, model, messages, tools, opts) {
       throw new Error(notAvailable(entry));
     }
     if (timeoutSignal.aborted && !opts?.signal?.aborted) {
-      throw new Error(`Provider request timed out after ${TIMEOUT_MS / 1e3}s. The model may still be loading or thinking.`);
+      throw new Error(`The provider didn't respond within ${TIMEOUT_MS / 1e3}s, so I stopped waiting. The model may still be loading or thinking \u2014 give it another try.`);
     }
     throw err;
   }
@@ -678,14 +678,14 @@ function isUnder(parent, child) {
 }
 function confinePath(p) {
   if (typeof p !== "string" || p.length === 0) {
-    throw new Error("Path is required.");
+    throw new Error("I need a file path here, but none was given.");
   }
   const root = process.cwd();
   const abs = resolve(root, p);
   if (isUnder(root, abs) || isUnder(SPILL_DIR, abs)) {
     return abs;
   }
-  throw new Error(`Path "${p}" is outside the working directory (${root}). Access denied.`);
+  throw new Error(`"${p}" sits outside the working directory (${root}), so I can't touch it. Stay within the project folder.`);
 }
 var SPILL_DIR;
 var init_paths = __esm({
@@ -787,9 +787,46 @@ function nearMiss(src, old_str) {
   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}):
+Here's the closest text I could find (lines ${from + 1}-${to}) \u2014 copy it exactly:
 ${ctx}`;
 }
+function locate(src, old_str) {
+  const first = src.indexOf(old_str);
+  if (first !== -1) {
+    if (src.indexOf(old_str, first + 1) !== -1) {
+      return { error: `That text shows up in more than one place, so I can't tell which one you mean. Add a line or two around it to make it unique.` };
+    }
+    return [first, first + old_str.length];
+  }
+  const fuzzy = fuzzyRange(src, old_str);
+  if (fuzzy) return fuzzy;
+  return { error: `I couldn't find that text \u2014 it may differ by whitespace or a stray character.${nearMiss(src, old_str)}` };
+}
+function applyBatch(src, edits) {
+  const ranges = [];
+  for (let i = 0; i < edits.length; i++) {
+    const { old_str, new_str } = edits[i];
+    if (typeof old_str !== "string" || typeof new_str !== "string") {
+      return { error: `Edit #${i + 1} is missing text \u2014 each edit needs both an old_str and a new_str string.` };
+    }
+    if (old_str === "") return { error: `Edit #${i + 1} has an empty old_str, so there's nothing to look for. Give it the exact text you want to replace.` };
+    if (old_str === new_str) return { error: `Edit #${i + 1} has the same old_str and new_str, so it wouldn't change anything.` };
+    const r = locate(src, old_str);
+    if (!Array.isArray(r)) return { error: `Edit #${i + 1}: ${r.error}` };
+    ranges.push({ start: r[0], end: r[1], new_str });
+  }
+  const sorted = [...ranges].sort((a, b) => a.start - b.start);
+  for (let i = 1; i < sorted.length; i++) {
+    if (sorted[i].start < sorted[i - 1].end) {
+      return { error: `Two of these edits touch the same spot, so I can't apply them together. Split them into separate calls, or widen each old_str so they don't overlap.` };
+    }
+  }
+  let out = src;
+  for (const r of [...ranges].sort((a, b) => b.start - a.start)) {
+    out = out.slice(0, r.start) + r.new_str + out.slice(r.end);
+  }
+  return { out, count: ranges.length };
+}
 var edit_file;
 var init_edit_file = __esm({
   "src/tools/edit_file.ts"() {
@@ -798,22 +835,45 @@ var init_edit_file = __esm({
     init_verifyHint();
     edit_file = {
       name: "edit_file",
-      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.",
+      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. To make several edits to one file at once, pass an `edits` array of {old_str,new_str} \u2014 they apply atomically (all or nothing).",
       input_schema: {
         type: "object",
         properties: {
           path: { type: "string", description: "File path" },
-          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" }
+          old_str: { type: "string", description: "Exact text to replace (whitespace-sensitive). Omit when using edits[]." },
+          new_str: { type: "string", description: "Replacement text. Omit when using edits[]." },
+          replace_all: { type: "boolean", description: "Replace every occurrence instead of requiring uniqueness" },
+          edits: {
+            type: "array",
+            description: "Batch mode: several edits applied atomically. Each old_str must be unique in the file. Alternative to old_str/new_str.",
+            items: {
+              type: "object",
+              properties: {
+                old_str: { type: "string", description: "Exact text to replace (whitespace-sensitive)" },
+                new_str: { type: "string", description: "Replacement text" }
+              },
+              required: ["old_str", "new_str"]
+            }
+          }
         },
-        required: ["path", "old_str", "new_str"]
+        required: ["path"]
       },
-      handler: ({ path, old_str, new_str, replace_all }) => {
+      handler: ({ path, old_str, new_str, replace_all, edits }) => {
         try {
+          if (Array.isArray(edits) && edits.length > 0) {
+            const abs2 = confinePath(path);
+            const src2 = readFileSync4(abs2, "utf-8");
+            const res = applyBatch(src2, edits);
+            if ("error" in res) return { content: `${res.error} (in ${path})`, is_error: true };
+            writeFileSync4(abs2, res.out, "utf-8");
+            return { content: `Edited ${path} (${res.count} edits).${verifyHint(path)}` };
+          }
+          if (typeof old_str !== "string" || typeof new_str !== "string") {
+            return { content: `To edit ${path} I need either an old_str/new_str pair or an edits[] array \u2014 neither came through.`, is_error: true };
+          }
           if (old_str === new_str) {
             return {
-              content: `old_str and new_str are identical \u2014 nothing to change in ${path}. If the file is already correct, do NOT edit again: finish with the respond action and tell the user it is done.`,
+              content: `old_str and new_str are the same, so there's nothing to change in ${path}. If the file is already correct, don't edit it again \u2014 finish with the respond action and tell the user it's done.`,
               is_error: true
             };
           }
@@ -830,12 +890,12 @@ var init_edit_file = __esm({
                 return { content: `Edited ${path} (whitespace-tolerant match).${verifyHint(path)}` };
               }
             }
-            return { content: `old_str not found in ${path}.${nearMiss(src, old_str)}`, is_error: true };
+            return { content: `I couldn't find that text in ${path} \u2014 it may differ by whitespace or a stray character.${nearMiss(src, old_str)}`, 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.`,
+              content: `That text appears more than once in ${path}, so I don't know which one to change. Add a line or two around it to single it out, or set replace_all to change them all.`,
               is_error: true
             };
           }
@@ -857,11 +917,22 @@ 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;
+function looksImage(buf) {
+  if (buf.length < 4) return false;
+  if (buf[0] === 137 && buf[1] === 80) return true;
+  if (buf[0] === 255 && buf[1] === 216) return true;
+  if (buf[0] === 71 && buf[1] === 73) return true;
+  if (buf[0] === 66 && buf[1] === 77) return true;
+  if (buf.length >= 12 && buf.toString("ascii", 0, 4) === "RIFF" && buf.toString("ascii", 8, 12) === "WEBP") return true;
+  return false;
+}
+var IMAGE_EXT, MAX_IMAGE_BYTES, read_file;
 var init_read_file = __esm({
   "src/tools/read_file.ts"() {
     "use strict";
     init_paths();
+    IMAGE_EXT = /* @__PURE__ */ new Set(["png", "jpg", "jpeg", "gif", "webp", "bmp"]);
+    MAX_IMAGE_BYTES = 8 * 1024 * 1024;
     read_file = {
       name: "read_file",
       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.",
@@ -878,8 +949,21 @@ var init_read_file = __esm({
         try {
           const MAX_CHARS = 2e5;
           const buf = readFileSync5(confinePath(path));
+          const ext = path.slice(path.lastIndexOf(".") + 1).toLowerCase();
+          if (IMAGE_EXT.has(ext) || looksImage(buf)) {
+            if (buf.length > MAX_IMAGE_BYTES) {
+              return {
+                content: `${path} is an image, but at ${buf.length} bytes it's too big to attach (limit is ${MAX_IMAGE_BYTES}). Resize it and try again.`,
+                is_error: true
+              };
+            }
+            return {
+              content: `[image ${path} \u2014 ${buf.length} bytes, attached for viewing]`,
+              images: [buf.toString("base64")]
+            };
+          }
           if (buf.subarray(0, 8e3).includes(0)) {
-            return { content: `${path} looks binary (${buf.length} bytes); not reading as text.`, is_error: true };
+            return { content: `${path} looks like a binary file (${buf.length} bytes), so I'm not reading it as text.`, is_error: true };
           }
           const raw = buf.toString("utf-8").replace(/\r\n/g, "\n");
           const allLines = raw.split("\n");
@@ -891,7 +975,7 @@ var init_read_file = __esm({
           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]`;
+[There's more \u2014 this hit the ${MAX_CHARS}-char limit. Use offset/limit to read the rest.]`;
           }
           if (ranged) {
             const end = start - 1 + slice.length;
@@ -963,7 +1047,7 @@ function spillIfLarge(full, label = "output", budget = INLINE_BUDGET) {
   const head = Math.floor(budget * HEAD_FRACTION);
   const tail = budget - head;
   const preview = full.slice(0, head) + "\n\u2026\n" + full.slice(-tail);
-  const notice = path ? `[${label} truncated: ${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.]`;
+  const notice = path ? `[This ${label} was long (${full.length} bytes), so I'm showing the start and end. The full text is saved at ${path} \u2014 read it with read_file offset/limit to see the middle.]` : `[This ${label} was too long to show in full, and I couldn't save the rest to disk, so the middle is missing.]`;
   return `${preview}
 ${notice}`;
 }
@@ -992,6 +1076,17 @@ var init_spill = __esm({
 
 // src/tools/run_bash.ts
 import { execa } from "execa";
+function killTree(pid, isWin) {
+  if (!pid) return;
+  try {
+    if (isWin) {
+      execa("taskkill", ["/pid", String(pid), "/T", "/F"], { reject: false });
+    } else {
+      process.kill(-pid, "SIGKILL");
+    }
+  } catch {
+  }
+}
 var run_bash;
 var init_run_bash = __esm({
   "src/tools/run_bash.ts"() {
@@ -1008,27 +1103,44 @@ var init_run_bash = __esm({
         },
         required: ["command"]
       },
-      handler: async ({ command, timeout_ms }) => {
+      handler: async ({ command, timeout_ms }, ctx) => {
+        const isWin = process.platform === "win32";
+        const shell = isWin ? "cmd" : "bash";
+        const shellArgs = isWin ? ["/c", command] : ["-c", command];
+        const timeout = timeout_ms ?? 12e4;
+        const child = execa(shell, shellArgs, {
+          reject: false,
+          all: true,
+          detached: !isWin
+          // POSIX: new process group so killTree(-pid) hits the whole tree
+        });
+        let timedOut = false;
+        let aborted = false;
+        const timer = setTimeout(() => {
+          timedOut = true;
+          killTree(child.pid, isWin);
+        }, timeout);
+        const onAbort = () => {
+          aborted = true;
+          killTree(child.pid, isWin);
+        };
+        ctx?.signal?.addEventListener("abort", onAbort, { once: true });
         try {
-          const isWin = process.platform === "win32";
-          const shell = isWin ? "cmd" : "bash";
-          const shellArgs = isWin ? ["/c", command] : ["-c", command];
-          const { stdout, stderr, exitCode } = await execa(shell, shellArgs, {
-            timeout: timeout_ms ?? 12e4,
-            reject: false,
-            all: false
-          });
-          const out = [stdout, stderr].filter(Boolean).join("\n");
-          const is_error = exitCode !== 0;
+          const { all, exitCode } = await child;
+          const out = all ?? "";
+          const is_error = aborted || timedOut || exitCode !== 0;
+          const note = timedOut ? `
+[Timed out after ${timeout}ms, so I stopped the command and everything it started. Raise timeout_ms for long builds or test suites.]` : aborted ? `
+[Cancelled \u2014 I stopped the command and everything it started.]` : "";
           const body = out || (is_error ? `(no output)` : "");
           const content = `${spillIfLarge(body, "command output")}
-[exit ${exitCode}]`;
-          return {
-            content,
-            is_error
-          };
+[exit ${exitCode ?? "killed"}]${note}`;
+          return { content, is_error };
         } catch (err) {
           return { content: err instanceof Error ? err.message : String(err), is_error: true };
+        } finally {
+          clearTimeout(timer);
+          ctx?.signal?.removeEventListener("abort", onAbort);
         }
       }
     };
@@ -1128,8 +1240,9 @@ var init_grep = __esm({
           const lines = (res.stdout ?? "").split("\n").slice(0, limit);
           const out = lines.join("\n");
           const code = res.exitCode ?? 0;
-          if (!out && code === 1) return { content: "No matches." };
-          return { content: out || res.stderr || "No matches.", is_error: code > 1 };
+          const noMatch = `Nothing matched "${pattern}". Try a looser pattern, case_insensitive, or a wider path.`;
+          if (!out && code === 1) return { content: noMatch };
+          return { content: out || res.stderr || noMatch, is_error: code > 1 };
         } catch (err) {
           return { content: err instanceof Error ? err.message : String(err), is_error: true };
         }
@@ -1204,7 +1317,7 @@ var init_glob = __esm({
             res = await tryFind();
           }
           const all = (res.stdout ?? "").split("\n").filter(Boolean);
-          if (all.length === 0) return { content: "No files matched." };
+          if (all.length === 0) return { content: `Nothing matched "${pattern}". Try a broader pattern or a different path.` };
           const lines = byMtimeDesc(all).slice(0, limit);
           return { content: lines.join("\n") };
         } catch (err) {
@@ -1215,6 +1328,70 @@ var init_glob = __esm({
   }
 });
 
+// src/tools/write_todos.ts
+function render(todos) {
+  const done = todos.filter((t) => t.status === "completed").length;
+  const header = `Todos (${done}/${todos.length} done):`;
+  const lines = todos.map((t) => `${MARK[t.status]} ${t.content}`);
+  return [header, ...lines].join("\n");
+}
+var STATUSES, MARK, write_todos;
+var init_write_todos = __esm({
+  "src/tools/write_todos.ts"() {
+    "use strict";
+    STATUSES = ["pending", "in_progress", "completed"];
+    MARK = {
+      completed: "[x]",
+      in_progress: "[~]",
+      pending: "[ ]"
+    };
+    write_todos = {
+      name: "write_todos",
+      description: "Create and maintain a task list for the current session, shown to the user as a live checklist. Pass the FULL list every call \u2014 it replaces the previous one (all or nothing), so include finished items too. Each todo is {content, status} where status is pending | in_progress | completed. Keep exactly one item in_progress at a time and mark it completed before starting the next. Use for multi-step work (features, refactors, multi-file changes) so the user can see what is done, in progress, and left. Skip it for single trivial actions.",
+      input_schema: {
+        type: "object",
+        properties: {
+          todos: {
+            type: "array",
+            description: "The full, ordered task list. Replaces the prior list entirely.",
+            items: {
+              type: "object",
+              properties: {
+                content: { type: "string", description: 'Short task description (imperative, e.g. "Add webfetch tool").' },
+                status: { type: "string", enum: STATUSES, description: "pending | in_progress | completed" }
+              },
+              required: ["content", "status"]
+            }
+          }
+        },
+        required: ["todos"]
+      },
+      handler: ({ todos }) => {
+        if (!Array.isArray(todos)) {
+          return { content: "I need a todos array here \u2014 pass the full list of tasks.", is_error: true };
+        }
+        if (todos.length === 0) {
+          return { content: "The todo list is empty \u2014 give me at least one task.", is_error: true };
+        }
+        for (let i = 0; i < todos.length; i++) {
+          const t = todos[i];
+          if (!t || typeof t.content !== "string" || t.content.trim() === "") {
+            return { content: `Task #${i + 1} needs some text \u2014 its content can't be empty.`, is_error: true };
+          }
+          if (!STATUSES.includes(t.status)) {
+            return { content: `Task #${i + 1} has an unknown status. Use one of: ${STATUSES.join(", ")}.`, is_error: true };
+          }
+        }
+        const active2 = todos.filter((t) => t.status === "in_progress").length;
+        if (active2 > 1) {
+          return { content: `Keep just one task in progress at a time \u2014 I see ${active2}. Finish one before starting the next.`, is_error: true };
+        }
+        return { content: render(todos) };
+      }
+    };
+  }
+});
+
 // src/tools/registry.ts
 function getTool(name) {
   return TOOLS.find((t) => t.name === name);
@@ -1243,13 +1420,15 @@ var init_registry = __esm({
     init_run_bash();
     init_grep();
     init_glob();
+    init_write_todos();
     TOOLS = [
       edit_file,
       read_file,
       write_file,
       run_bash,
       grep,
-      glob
+      glob,
+      write_todos
     ];
   }
 });
@@ -1312,7 +1491,7 @@ function validateInput(schema, input) {
   const result = toZod(schema).safeParse(input ?? {});
   if (result.success) return null;
   const issues = result.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ");
-  return `Invalid arguments: ${issues}`;
+  return `Some arguments didn't look right: ${issues}`;
 }
 var init_validate = __esm({
   "src/tools/validate.ts"() {
@@ -1451,6 +1630,14 @@ Ask in a numbered list. One round of questions per turn. Then wait.
 You have access to the following tools. Call them via the function-calling interface.
 ${toolLines}
 
+# Task list (write_todos)
+For multi-step work \u2014 a feature, a refactor, anything touching multiple files or more than ~3 steps \u2014 track it with write_todos so the user sees a live checklist of what is done, in progress, and left.
+- Create the list right after your plan, before the first real action. Each item is {content, status}: short imperative content, status pending | in_progress | completed.
+- Pass the FULL list every call; it replaces the previous one. Include already-finished items so nothing disappears.
+- Mark exactly ONE item in_progress at a time. Set it in_progress when you start it, completed the moment it is done, then move the next to in_progress. Never leave a finished task pending or two tasks in_progress.
+- Keep items outcome-sized, not tool-sized \u2014 "Add webfetch tool and wire it in", not "call edit_file". Aim for a handful, not twenty.
+- Do NOT use write_todos for trivial single-step work \u2014 a lone read, one edit, a quick search. It is overhead there.
+
 # Loop semantics
 - When you need to act on the filesystem or run a command, emit a tool call.
 - After each tool result, decide: more tool calls, or a final plain-text answer.
@@ -1535,6 +1722,9 @@ function toOllamaMessages(history, system) {
       const texts = msg.content.filter((b) => b.type === "text");
       for (const tr of tool_results) {
         out.push({ role: "tool", content: tr.content, tool_call_id: tr.tool_use_id });
+        if (tr.images && tr.images.length > 0) {
+          out.push({ role: "user", content: "Image content from the previous tool result:", images: tr.images });
+        }
       }
       if (texts.length > 0) {
         out.push({ role: "user", content: texts.map((t) => t.text).join("") });
@@ -1743,7 +1933,7 @@ function readGuard(name, input, seen) {
   if (seen.has(abs)) return null;
   if (name === "write_file" && !existsSync5(abs)) return null;
   const verb = name === "edit_file" ? "edit" : "overwrite";
-  return `Refusing to ${verb} ${p}: you have not read it this turn. Call read_file on ${p} first, then retry the ${name}.`;
+  return `I won't ${verb} ${p} without seeing it first \u2014 I don't want to clobber something. Read it with read_file, then retry the ${name}.`;
 }
 function unwrapEnvelope(name, input) {
   if (!("arguments" in input)) return input;
@@ -1925,7 +2115,7 @@ async function* runAgent(opts) {
         const r2 = {
           type: "tool_result",
           tool_use_id: use.id,
-          content: `Unknown tool: ${use.name}`,
+          content: `Unknown tool: ${use.name}. There's no tool by that name \u2014 check the spelling against the tools you were given.`,
           is_error: true
         };
         results.push(r2);
@@ -1951,7 +2141,7 @@ async function* runAgent(opts) {
         const r2 = {
           type: "tool_result",
           tool_use_id: use.id,
-          content: `Permission denied for ${use.name}.`,
+          content: `Permission denied \u2014 the user chose not to run ${use.name}. Try a different approach, or ask them what they'd prefer.`,
           is_error: true
         };
         results.push(r2);
@@ -1977,12 +2167,13 @@ async function* runAgent(opts) {
       }
       let r;
       try {
-        const out = await tool.handler(use.input);
+        const out = await tool.handler(use.input, { signal });
         r = {
           type: "tool_result",
           tool_use_id: use.id,
           content: out.content,
-          is_error: out.is_error
+          is_error: out.is_error,
+          ...out.images && out.images.length > 0 ? { images: out.images } : {}
         };
       } catch (err) {
         r = {
@@ -2252,7 +2443,7 @@ var init_run = __esm({
 });
 
 // src/cli.tsx
-import { render } from "ink";
+import { render as render2 } from "ink";
 import { createElement } from "react";
 
 // src/ui/App.tsx
@@ -3542,7 +3733,8 @@ var TOOL_LABEL = {
   read_file: "Read",
   run_bash: "Bash",
   glob: "Glob",
-  grep: "Grep"
+  grep: "Grep",
+  write_todos: "Todos"
 };
 var EXT_LANG = {
   ts: "typescript",
@@ -3644,6 +3836,43 @@ function FileEditBlock({
     ] }) })
   ] });
 }
+function TodoBlock({ todos }) {
+  const done = todos.filter((t) => t.status === "completed").length;
+  const doing = todos.filter((t) => t.status === "in_progress").length;
+  const glyph = { completed: "\u2714", in_progress: "\u25B6", pending: "\u25CB" };
+  const color = { completed: "green", in_progress: "yellow", pending: "gray" };
+  return /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", marginLeft: 2, children: [
+    /* @__PURE__ */ jsxs9(Box9, { children: [
+      /* @__PURE__ */ jsx9(Text9, { color: "green", children: "\u25CF " }),
+      /* @__PURE__ */ jsx9(Text9, { color: "white", children: "Todos " }),
+      /* @__PURE__ */ jsxs9(Text9, { dimColor: true, children: [
+        "(",
+        done,
+        "/",
+        todos.length,
+        " done",
+        doing > 0 ? `, ${doing} in progress` : "",
+        ")"
+      ] })
+    ] }),
+    todos.map((t, i) => /* @__PURE__ */ jsxs9(Box9, { marginLeft: 4, children: [
+      /* @__PURE__ */ jsxs9(Text9, { color: color[t.status], children: [
+        glyph[t.status],
+        " "
+      ] }),
+      /* @__PURE__ */ jsx9(
+        Text9,
+        {
+          color: t.status === "in_progress" ? "yellow" : void 0,
+          dimColor: t.status !== "in_progress",
+          strikethrough: t.status === "completed",
+          bold: t.status === "in_progress",
+          children: t.content
+        }
+      )
+    ] }, i))
+  ] });
+}
 function toolHeader(use) {
   const label = TOOL_LABEL[use.name] ?? use.name;
   const input = use.input ?? {};
@@ -3723,6 +3952,10 @@ function ToolResultBlock({ result, toolName }) {
   ] });
 }
 function ToolUseLine({ use, result }) {
+  if (use.name === "write_todos" && !result?.is_error) {
+    const todos = use.input.todos;
+    if (Array.isArray(todos) && todos.length > 0) return /* @__PURE__ */ jsx9(TodoBlock, { todos });
+  }
   if (use.name === "write_file" && !result?.is_error) {
     const input = use.input;
     const content = input.content ?? "";
@@ -3732,14 +3965,16 @@ function ToolUseLine({ use, result }) {
   }
   if (use.name === "edit_file" && !result?.is_error) {
     const input = use.input;
-    const oldS = input.old_str ?? "";
-    const newS = input.new_str ?? "";
-    const added = countLines(newS);
-    const removed = countLines(oldS);
-    const preview = [
-      ...oldS.split("\n").map((t) => ({ sign: "-", text: t })),
-      ...newS.split("\n").map((t) => ({ sign: "+", text: t }))
-    ];
+    const pairs = Array.isArray(input.edits) && input.edits.length > 0 ? input.edits.map((e) => ({ oldS: e.old_str ?? "", newS: e.new_str ?? "" })) : [{ oldS: input.old_str ?? "", newS: input.new_str ?? "" }];
+    let added = 0;
+    let removed = 0;
+    const preview = [];
+    for (const { oldS, newS } of pairs) {
+      added += countLines(newS);
+      removed += countLines(oldS);
+      preview.push(...oldS.split("\n").map((t) => ({ sign: "-", text: t })));
+      preview.push(...newS.split("\n").map((t) => ({ sign: "+", text: t })));
+    }
     return /* @__PURE__ */ jsx9(FileEditBlock, { label: "Update", path: input.path ?? "", added, removed, previewLines: preview });
   }
   const { label, arg } = toolHeader(use);
@@ -5078,5 +5313,5 @@ if (cmd === "version" || cmd === "--version" || cmd === "-v") {
   process.on("exit", () => {
     if (process.stdout.isTTY) process.stdout.write("\x1B]2;\x07");
   });
-  render(createElement(App));
+  render2(createElement(App));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "miii-agent",
-  "version": "0.1.31",
+  "version": "0.1.33",
   "description": "Local AI coding agent for your terminal — an open-source, offline alternative to Claude Code, Cursor, and GitHub Copilot, powered by Ollama. Private by default, free forever.",
   "type": "module",
   "bin": {