@livx.cc/agentx 0.99.72 → 0.99.73

package/dist/cli.js

@@ -19,8 +19,192 @@ var init_logging = __esm({
   }
 });
 
+// src/imageWire.ts
+import { readFileSync, writeFileSync as writeFileSync2, statSync as statSync2, mkdtempSync, rmSync } from "fs";
+import { spawnSync } from "child_process";
+import { createHash } from "crypto";
+import { tmpdir } from "os";
+import { join as join2 } from "path";
+import { PNG } from "pngjs";
+import jpeg from "jpeg-js";
+function imageSize(b) {
+  const u16 = (i) => b[i] << 8 | b[i + 1];
+  const le16 = (i) => b[i] | b[i + 1] << 8;
+  const u32 = (i) => (b[i] << 24 >>> 0) + (b[i + 1] << 16) + (b[i + 2] << 8) + b[i + 3];
+  if (b[0] === 137 && b[1] === 80 && b.length >= 24) return { w: u32(16), h: u32(20) };
+  if (b[0] === 71 && b[1] === 73 && b.length >= 10) return { w: le16(6), h: le16(8) };
+  if (b[0] === 255 && b[1] === 216) {
+    for (let i = 2; i + 9 < b.length; ) {
+      if (b[i] !== 255) return null;
+      const m = b[i + 1];
+      if (m >= 192 && m <= 207 && m !== 196 && m !== 200 && m !== 204) return { w: u16(i + 7), h: u16(i + 5) };
+      i += 2 + u16(i + 2);
+    }
+    return null;
+  }
+  if (b.length >= 30 && String.fromCharCode(...b.subarray(8, 12)) === "WEBP") {
+    const kind = String.fromCharCode(...b.subarray(12, 16));
+    if (kind === "VP8X") return { w: 1 + (b[24] | b[25] << 8 | b[26] << 16), h: 1 + (b[27] | b[28] << 8 | b[29] << 16) };
+    if (kind === "VP8 ") return { w: le16(26) & 16383, h: le16(28) & 16383 };
+    if (kind === "VP8L") {
+      const v = b[21] | b[22] << 8 | b[23] << 16 | b[24] << 24;
+      return { w: (v & 16383) + 1, h: (v >> 14 & 16383) + 1 };
+    }
+  }
+  return null;
+}
+function imageNote(what, bytes, dims, why) {
+  return `[image ${what}${dims ? `, ${dims.w}x${dims.h}` : ""}, ${fmtBytes(bytes)} \u2014 not sent: ${why}]`;
+}
+function downscaleJs(buf, maxSide) {
+  let src;
+  try {
+    if (buf[0] === 137 && buf[1] === 80) src = PNG.sync.read(buf);
+    else if (buf[0] === 255 && buf[1] === 216) src = jpeg.decode(buf, { useTArray: true, maxMemoryUsageInMB: 1024 });
+    else return null;
+  } catch (e) {
+    log2.warn("pure-JS image decode failed", e);
+    return null;
+  }
+  const { width: sw, height: sh, data: s } = src;
+  const k = Math.min(1, maxSide / Math.max(sw, sh));
+  const w = Math.max(1, Math.round(sw * k)), h = Math.max(1, Math.round(sh * k));
+  const d = new Uint8Array(w * h * 4);
+  for (let y = 0; y < h; y++) {
+    const y0 = Math.floor(y * sh / h), y1 = Math.max(y0 + 1, Math.floor((y + 1) * sh / h));
+    for (let x = 0; x < w; x++) {
+      const x0 = Math.floor(x * sw / w), x1 = Math.max(x0 + 1, Math.floor((x + 1) * sw / w));
+      let r = 0, g = 0, b = 0, a = 0;
+      for (let yy = y0; yy < y1; yy++) for (let xx = x0; xx < x1; xx++) {
+        const i = (yy * sw + xx) * 4, al = s[i + 3];
+        r += s[i] * al;
+        g += s[i + 1] * al;
+        b += s[i + 2] * al;
+        a += al;
+      }
+      const o = (y * w + x) * 4, n = (y1 - y0) * (x1 - x0), bg = 255 * (n - a / 255);
+      d[o] = (r / 255 + bg) / n;
+      d[o + 1] = (g / 255 + bg) / n;
+      d[o + 2] = (b / 255 + bg) / n;
+      d[o + 3] = 255;
+    }
+  }
+  let out = Buffer.alloc(0);
+  for (const q2 of [80, 60, 40]) {
+    out = Buffer.from(jpeg.encode({ width: w, height: h, data: d }, q2).data);
+    if (out.length <= IMAGE_MAX_BYTES) break;
+  }
+  return out;
+}
+function downscale(path, maxSide) {
+  const dir = mkdtempSync(join2(tmpdir(), "agentx-img-"));
+  const out = join2(dir, "x.jpg");
+  try {
+    const tries = [
+      ["sips", ["-Z", String(maxSide), "-s", "format", "jpeg", "-s", "formatOptions", "80", path, "--out", out]],
+      ["magick", [path, "-resize", `${maxSide}x${maxSide}>`, "-quality", "80", out]],
+      ["convert", [path, "-resize", `${maxSide}x${maxSide}>`, "-quality", "80", out]]
+    ];
+    for (const [cmd, args] of tries) {
+      const r = spawnSync(cmd, args, { stdio: "ignore", timeout: 15e3 });
+      if (r.status !== 0) continue;
+      try {
+        const o = readFileSync(out);
+        if (o.length <= IMAGE_MAX_BYTES) return o;
+        break;
+      } catch {
+      }
+    }
+    const js = downscaleJs(readFileSync(path), maxSide);
+    if (!js) log2.warn(`could not downscale ${path} (tried sips/magick/convert/pure JS)`);
+    return js;
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+function remember(id, w) {
+  cache.delete(id);
+  cache.set(id, w);
+  if (cache.size > CACHE_MAX) cache.delete(cache.keys().next().value);
+  return w;
+}
+function wireOf(key, buf, mime, label, file) {
+  const dims = imageSize(buf);
+  const fits = buf.length <= IMAGE_MAX_BYTES && (!dims || Math.max(dims.w, dims.h) <= IMAGE_MAX_SIDE);
+  let small = null;
+  if (!fits) {
+    if (file) small = downscale(file, IMAGE_MAX_SIDE);
+    else {
+      const dir = mkdtempSync(join2(tmpdir(), "agentx-img-in-"));
+      try {
+        const f = join2(dir, `in.${mime.split("/")[1] || "img"}`);
+        writeFileSync2(f, buf);
+        small = downscale(f, IMAGE_MAX_SIDE);
+      } finally {
+        rmSync(dir, { recursive: true, force: true });
+      }
+    }
+  }
+  const url = fits ? `data:${mime};base64,${buf.toString("base64")}` : small && small.length <= IMAGE_MAX_BYTES ? `data:image/jpeg;base64,${small.toString("base64")}` : null;
+  return { key, url, note: imageNote(label, buf.length, dims, url ? "this model can't see images" : "too large and it couldn't be downscaled") };
+}
+function imageForWire(path, mime, vision) {
+  let st;
+  try {
+    st = statSync2(path);
+  } catch (e) {
+    log2.warn(`image unreadable: ${path}`, e);
+    return null;
+  }
+  const key = `${st.mtimeMs}:${st.size}`;
+  let hit = cache.get(path);
+  if (!hit || hit.key !== key) hit = remember(path, wireOf(key, readFileSync(path), mime, path, path));
+  return vision && hit.url ? { url: hit.url } : { note: hit.note };
+}
+function inlineImageForWire(url, vision) {
+  const comma = url.indexOf(",");
+  const mime = url.slice(5, url.indexOf(";"));
+  if (vision && url.length < 3e5) {
+    const b64 = url.slice(comma + 1);
+    const dims = imageSize(Buffer.from(b64.slice(0, 4096), "base64")) ?? imageSize(Buffer.from(b64, "base64"));
+    if (!dims || Math.max(dims.w, dims.h) <= IMAGE_MAX_SIDE) return { url };
+  }
+  const id = `inline:${createHash("sha1").update(url).digest("base64")}`;
+  let hit = cache.get(id);
+  if (!hit) {
+    const buf = Buffer.from(url.slice(comma + 1), "base64");
+    hit = remember(id, wireOf(id, buf, mime, `(${mime})`));
+  }
+  return vision && hit.url ? { url: hit.url } : { note: hit.note };
+}
+function imageWireBytes(path, mime, vision) {
+  const r = imageForWire(path, mime, vision);
+  return !r ? 0 : "url" in r ? r.url.length : r.note.length;
+}
+function scrubBase64Text(s) {
+  if (s.length < 2e3) return s;
+  const out = s.replace(DATA_URI, (m) => imageNote(m.slice(5, m.indexOf(";")), Math.floor((m.length - m.indexOf(",") - 1) * 3 / 4), null, "base64 is never sent as text")).replace(B64_RUN, (m) => !/[+/]/.test(m) || !/\d/.test(m) ? m : `[base64 data, ${fmtBytes(Math.floor(m.length * 3 / 4))} \u2014 not sent: base64 is never sent as text]`);
+  if (out !== s) log2.warn(`scrubbed base64 from request text (${s.length} \u2192 ${out.length} chars)`);
+  return out;
+}
+var log2, IMAGE_MAX_SIDE, IMAGE_MAX_BYTES, fmtBytes, cache, CACHE_MAX, DATA_URI, B64_RUN;
+var init_imageWire = __esm({
+  "src/imageWire.ts"() {
+    "use strict";
+    init_logging();
+    log2 = forComponent("imageWire");
+    IMAGE_MAX_SIDE = 1568;
+    IMAGE_MAX_BYTES = 1e6;
+    fmtBytes = (n) => n >= 1e6 ? `${(n / 1e6).toFixed(1)} MB` : n >= 1e3 ? `${Math.round(n / 1e3)} KB` : `${n} B`;
+    cache = /* @__PURE__ */ new Map();
+    CACHE_MAX = 8;
+    DATA_URI = /data:image\/[\w.+-]+;base64,[A-Za-z0-9+/=]+/g;
+    B64_RUN = /[A-Za-z0-9+/=]{2000,}/g;
+  }
+});
+
 // src/llm.ts
-import { readFileSync, statSync as statSync2, realpathSync } from "fs";
+import { statSync as statSync3, realpathSync } from "fs";
 import { resolve, sep } from "path";
 import { randomBytes } from "crypto";
 function passesBackReasoning(model) {
@@ -77,9 +261,9 @@ function mintImageRef(path, mime) {
   const token = randomBytes(16).toString("hex");
   let bytes = 0;
   try {
-    bytes = Math.ceil(statSync2(path).size * 4 / 3);
+    bytes = Math.ceil(statSync3(path).size * 4 / 3);
   } catch (e) {
-    log2.warn(`image ref stat failed, weighing as 0: ${path}`, e);
+    log3.warn(`image ref stat failed, weighing as 0: ${path}`, e);
   }
   refRegistry.set(token, { mime, path, bytes });
   while (refRegistry.size > REF_REGISTRY_MAX) refRegistry.delete(refRegistry.keys().next().value);
@@ -92,7 +276,7 @@ function parseImageRef(url) {
   const parts = refUrlParts(url);
   const ref = parts && refRegistry.get(parts.token);
   if (!ref) {
-    log2.debug("image ref not in registry \u2014 treating as non-image text");
+    log3.debug("image ref not in registry \u2014 treating as non-image text");
     return null;
   }
   return ref;
@@ -111,7 +295,7 @@ function remintImageRefs(messages, roots) {
     try {
       allowed.push(realpathSync(resolve(r)));
     } catch (e) {
-      log2.debug(`image-ref root unavailable: ${r}`, e);
+      log3.debug(`image-ref root unavailable: ${r}`, e);
     }
   }
   if (allowed.length === 0) return messages;
@@ -128,11 +312,11 @@ function remintImageRefs(messages, roots) {
       try {
         real = realpathSync(f.path);
       } catch (e) {
-        log2.warn(`resumed image ref unreadable, will stub: ${f.path}`, e);
+        log3.warn(`resumed image ref unreadable, will stub: ${f.path}`, e);
         return p;
       }
       if (!inside(real)) {
-        log2.warn(`resumed image ref outside the allowed roots, will stub: ${f.path} -> ${real}`);
+        log3.warn(`resumed image ref outside the allowed roots, will stub: ${f.path} -> ${real}`);
         return p;
       }
       touched = true;
@@ -159,7 +343,7 @@ function toolImageRef(content) {
   try {
     return parseImageRef(JSON.parse(content).imageRef);
   } catch (e) {
-    log2.debug("bad imageRef tool result", e);
+    log3.debug("bad imageRef tool result", e);
     return null;
   }
 }
@@ -187,32 +371,41 @@ function imageWindows(messages, keepRecent) {
   const k = Math.max(0, keepRecent);
   return /* @__PURE__ */ new Set([...attach.slice(Math.max(0, attach.length - k)), ...tool.slice(Math.max(0, tool.length - k))]);
 }
-function expandImagesForSend(messages, keepRecent = 1, stub = IMAGE_ELIDE_STUB) {
+function expandImagesForSend(messages, keepRecent = 1, stub = IMAGE_ELIDE_STUB, vision = true) {
   if (!messages.some(bearsImage)) return messages;
   const keep = imageWindows(messages, keepRecent);
   let changed = false;
   const out = messages.map((m, i) => {
-    const content = keep.has(i) ? expandContent(m.content, stub) : stripContent(m.content, stub);
+    const content = keep.has(i) ? expandContent(m.content, vision) : stripContent(m.content, stub);
     if (content === m.content) return m;
     changed = true;
     return { ...m, content };
   });
   return changed ? out : messages;
 }
-function sendBytes(messages, keepRecent = 1, stub = IMAGE_ELIDE_STUB) {
+function sendBytes(messages, keepRecent = 1, vision = true, stub = IMAGE_ELIDE_STUB) {
   let n = 0;
-  for (const b of sendBytesPer(messages, keepRecent, stub)) n += b;
+  for (const b of sendBytesPer(messages, keepRecent, vision, stub)) n += b;
   return n;
 }
-function sendBytesPer(messages, keepRecent = 1, stub = IMAGE_ELIDE_STUB) {
+function sendBytesPer(messages, keepRecent = 1, vision = true, stub = IMAGE_ELIDE_STUB) {
   const keep = messages.some(bearsImage) ? imageWindows(messages, keepRecent) : null;
-  return messages.map((m, i) => wireBytes(m.content, keep == null || keep.has(i), stub) + (m.tool_calls ? JSON.stringify(m.tool_calls).length : 0) + (m.reasoning_content?.length ?? 0));
+  return messages.map((m, i) => wireBytes(m.content, keep == null || keep.has(i), vision, stub) + (m.tool_calls ? JSON.stringify(m.tool_calls).length : 0) + (m.reasoning_content?.length ?? 0));
 }
-function wireBytes(content, kept, stub) {
+function wireBytes(content, kept, vision, stub) {
   const tool = toolImageRef(content);
-  if (tool) return kept ? tool.bytes : stub.length;
+  if (tool) return kept ? imageWireBytes(tool.path, tool.mime, vision) || stub.length : stub.length;
   if (content == null || typeof content === "string") return contentBytes(content);
-  if (kept) return contentBytes(content);
+  if (kept) {
+    let n2 = 0;
+    for (const p of content) {
+      const url = p.type === "image_url" ? p.image_url?.url ?? "" : "";
+      const ref = url ? parseImageRef(url) : null;
+      const inline = url.startsWith("data:") ? inlineImageForWire(url, vision) : null;
+      n2 += ref ? imageWireBytes(ref.path, ref.mime, vision) : inline ? ("url" in inline ? inline.url : inline.note).length : contentBytes([p]);
+    }
+    return n2;
+  }
   let n = 0;
   for (const p of content) {
     if (p.type === "text") {
@@ -224,31 +417,70 @@ function wireBytes(content, kept, stub) {
   }
   return n;
 }
-function readRefDataUrl(ref) {
-  try {
-    return `data:${ref.mime};base64,${readFileSync(ref.path).toString("base64")}`;
-  } catch (e) {
-    log2.warn(`image ref unreadable, sending stub instead: ${ref.path}`, e);
-    return null;
-  }
-}
-function expandContent(content, stub) {
+function expandContent(content, vision) {
   const tool = toolImageRef(content);
   if (tool) {
-    const url = readRefDataUrl(tool);
-    return url ? JSON.stringify({ dataUrl: url, image: tool.path }) : stub;
+    const w = imageForWire(tool.path, tool.mime, vision);
+    if (!w) return IMAGE_ELIDE_STUB;
+    return "url" in w ? [{ type: "text", text: `image: ${tool.path}` }, imagePart(w.url)] : w.note;
   }
   if (typeof content === "string") return content;
   let changed = false;
   const out = content.map((p) => {
-    if (p.type !== "image_url" || !isImageRefUrl(p.image_url?.url)) return p;
+    if (p.type !== "image_url") return p;
+    const url = p.image_url?.url ?? "";
+    if (url.startsWith("data:")) {
+      const w2 = inlineImageForWire(url, vision);
+      if ("url" in w2 && w2.url === url) return p;
+      changed = true;
+      return "url" in w2 ? imagePart(w2.url) : { type: "text", text: w2.note };
+    }
+    if (!isImageRefUrl(url)) return p;
     changed = true;
-    const ref = parseImageRef(p.image_url?.url);
-    const url = ref && readRefDataUrl(ref);
-    return url ? imagePart(url) : { type: "text", text: stub };
+    const ref = parseImageRef(url);
+    if (!ref) return { type: "text", text: IMAGE_ELIDE_STUB };
+    const w = imageForWire(ref.path, ref.mime, vision);
+    if (!w) return { type: "text", text: IMAGE_ELIDE_STUB };
+    return "url" in w ? imagePart(w.url) : { type: "text", text: w.note };
   });
   return changed ? out : content;
 }
+function hoistToolImages(messages) {
+  if (!messages.some((m) => m.role === "tool" && Array.isArray(m.content) && m.content.some((p) => p.type === "image_url"))) return messages;
+  const out = [];
+  let pending = [];
+  const flush = () => {
+    if (pending.length) out.push({ role: "user", content: [{ type: "text", text: "Image output from the tool call above:" }, ...pending] });
+    pending = [];
+  };
+  for (const m of messages) {
+    if (m.role !== "tool") flush();
+    if (m.role === "tool" && Array.isArray(m.content) && m.content.some((p) => p.type === "image_url")) {
+      const imgs = m.content.filter((p) => p.type === "image_url");
+      pending.push(...imgs);
+      const text = m.content.filter((p) => p.type === "text").map((p) => p.text).join("\n");
+      out.push({ ...m, content: text || `[${imgs.length} image(s) returned; shown below]` });
+    } else out.push(m);
+  }
+  flush();
+  return out;
+}
+function scrubBase64(messages) {
+  let changed = false;
+  const out = messages.map((m) => {
+    const c = m.content;
+    let next = c;
+    if (typeof c === "string") next = scrubBase64Text(c);
+    else if (Array.isArray(c)) {
+      const parts = c.map((p) => p.type === "text" && p.text ? { ...p, text: scrubBase64Text(p.text) } : p);
+      if (parts.some((p, i) => p.text !== c[i].text)) next = parts;
+    }
+    if (next === c) return m;
+    changed = true;
+    return { ...m, content: next };
+  });
+  return changed ? out : messages;
+}
 function stripContent(content, stub) {
   if (toolImageRef(content)) return stub;
   if (typeof content === "string") return content;
@@ -271,12 +503,13 @@ function endsOnAnnouncedAction(text) {
   if (PROGRESSIVE.test(last)) return true;
   return clauses(last).some((c) => !NEXT_STEP.test(c) && !SIGN_OFF.test(c) && COMMITMENT.test(c));
 }
-var log2, p_sep, IMAGE_ELIDE_STUB, IMAGE_REF_SCHEME, REF_REGISTRY_MAX, refRegistry, isImageRefUrl, bearsImage, COMMITMENT, PROGRESSIVE, NEXT_STEP, SIGN_OFF;
+var log3, p_sep, IMAGE_ELIDE_STUB, IMAGE_REF_SCHEME, REF_REGISTRY_MAX, refRegistry, isImageRefUrl, bearsImage, COMMITMENT, PROGRESSIVE, NEXT_STEP, SIGN_OFF;
 var init_llm = __esm({
   "src/llm.ts"() {
     "use strict";
     init_logging();
-    log2 = forComponent("llm");
+    init_imageWire();
+    log3 = forComponent("llm");
     p_sep = (parts) => parts.length > 1 ? "\n" : "";
     IMAGE_ELIDE_STUB = "[image elided \u2014 re-attach @path or /paste to view again]";
     IMAGE_REF_SCHEME = "agentx-image:";
@@ -963,7 +1196,7 @@ function makeWebFetchTool(options = {}) {
 
 ${capped}`;
       } catch (e) {
-        log3.debug(`WebFetch ${u} failed`, e);
+        log4.debug(`WebFetch ${u} failed`, e);
         return `Error fetching ${u}: ${e?.name === "AbortError" ? `timed out after ${timeoutMs}ms` : e?.message ?? e}`;
       } finally {
         clearTimeout(timer);
@@ -1087,7 +1320,7 @@ function makeWebSearchTool(options = {}) {
         if (!res.ok) return `Error: search returned ${res.status} ${res.statusText}`;
         return formatHits(parseDdgHtml(await res.text(), maxResults));
       } catch (e) {
-        log3.debug("WebSearch failed", e);
+        log4.debug("WebSearch failed", e);
         return `Error searching: ${e?.name === "AbortError" ? `timed out after ${timeoutMs}ms` : e?.message ?? e}`;
       } finally {
         clearTimeout(timer);
@@ -1098,12 +1331,12 @@ function makeWebSearchTool(options = {}) {
 function makeWebSearchAnthropicTool(opts = {}) {
   return makeWebSearchTool({ provider: "anthropic", name: "WebSearchAnthropic", description: ANTHROPIC_SEARCH_DESC, anthropicApiKey: opts.anthropicApiKey, model: opts.model });
 }
-var log3, _dnsLookup, webFetchTool, webSearchTool, ANTHROPIC_SEARCH_DESC, webSearchAnthropicTool;
+var log4, _dnsLookup, webFetchTool, webSearchTool, ANTHROPIC_SEARCH_DESC, webSearchAnthropicTool;
 var init_tools_web = __esm({
   "src/tools.web.ts"() {
     "use strict";
     init_logging();
-    log3 = forComponent("web");
+    log4 = forComponent("web");
     webFetchTool = makeWebFetchTool();
     webSearchTool = makeWebSearchTool();
     ANTHROPIC_SEARCH_DESC = "High-quality web search via Anthropic's native search index. Returns concise, sourced findings \u2014 one claim per line, each with its source URL. Prefer this over WebSearch when accuracy and citations matter; it is slower (~3\u20138s) and bills the Anthropic API account per call (one cheap-model turn + search fee).";
@@ -1323,7 +1556,7 @@ function realPathOf(fs, path) {
   try {
     return fs.realPath(path);
   } catch (e) {
-    log4.debug(`realPath unavailable for ${path} \u2014 inlining image bytes instead`, e);
+    log5.debug(`realPath unavailable for ${path} \u2014 inlining image bytes instead`, e);
     return null;
   }
 }
@@ -1375,7 +1608,7 @@ function toolsByName(names, available) {
     return t;
   });
 }
-var log4, numberLines, bashTool, IMG_MIME, readTool, editTool;
+var log5, numberLines, bashTool, IMG_MIME, readTool, editTool;
 var init_tools = __esm({
   "src/tools.ts"() {
     "use strict";
@@ -1386,7 +1619,7 @@ var init_tools = __esm({
     init_tools_web();
     init_OverlayFilesystem();
     init_redact();
-    log4 = forComponent("tools");
+    log5 = forComponent("tools");
     numberLines = (content, offset = 0, limit) => {
       const lines = content.split("\n");
       const start = Math.max(0, offset);
@@ -1568,12 +1801,12 @@ ${tail || "(no output)"}`;
     }
   ];
 }
-var log5, JobRegistryOptions, secs, JobRegistry, NO_JOB, describe;
+var log6, JobRegistryOptions, secs, JobRegistry, NO_JOB, describe;
 var init_tools_jobs = __esm({
   "src/tools.jobs.ts"() {
     "use strict";
     init_logging();
-    log5 = forComponent("jobs");
+    log6 = forComponent("jobs");
     JobRegistryOptions = class {
       /** Tail buffer cap per job (chars). */
       maxBuffer = 256 * 1024;
@@ -1752,7 +1985,7 @@ var init_tools_jobs = __esm({
           try {
             onExit({ id: job.id, kind: job.kind, label: job.label, status, reason: job.reason, tail: job.buf.slice(-4e3), result });
           } catch (e) {
-            log5.warn(`job onExit handler threw for ${job.id}: ${e}`);
+            log6.warn(`job onExit handler threw for ${job.id}: ${e}`);
           }
         }
       }
@@ -1806,7 +2039,7 @@ var init_tools_jobs = __esm({
           try {
             j.onKill?.(reason);
           } catch (e) {
-            log5.warn(`onKill for ${id} threw: ${e}`);
+            log6.warn(`onKill for ${id} threw: ${e}`);
           }
         }
         return true;
@@ -1853,7 +2086,7 @@ var init_tools_jobs = __esm({
           try {
             cpu = await j.cpuTime();
           } catch (e) {
-            log5.debug(`cpu probe for ${j.id} failed: ${e}`);
+            log6.debug(`cpu probe for ${j.id} failed: ${e}`);
           }
           if (cpu != null && j.lastCpu != null && cpu > j.lastCpu) j.lastActivityAt = this.options.now();
           const prev = j.lastCpu;
@@ -1861,7 +2094,7 @@ var init_tools_jobs = __esm({
           const verdict = this.verdict(j, now4);
           if (!verdict?.idle || j.status !== "running") continue;
           if (cpu == null) {
-            log5.debug(`not reaping ${j.id}: ${verdict.reason} but CPU unknown`);
+            log6.debug(`not reaping ${j.id}: ${verdict.reason} but CPU unknown`);
             continue;
           }
           if (prev == null) continue;
@@ -1875,7 +2108,7 @@ var init_tools_jobs = __esm({
         return null;
       }
       stuck(j, reason, now4) {
-        log5.warn(`reaping ${j.id} (${j.kind} "${j.label}"): ${reason} \u2014 age ${secs(now4 - j.startedAt)}, last activity ${secs(now4 - j.lastActivityAt)} ago, idleMs=${j.idleMs}, hardCapMs=${j.hardCapMs}, ${j.bytes} byte(s) output`);
+        log6.warn(`reaping ${j.id} (${j.kind} "${j.label}"): ${reason} \u2014 age ${secs(now4 - j.startedAt)}, last activity ${secs(now4 - j.lastActivityAt)} ago, idleMs=${j.idleMs}, hardCapMs=${j.hardCapMs}, ${j.bytes} byte(s) output`);
         if (j.onKill) j.notify = true;
         this.kill(j.id, reason);
       }
@@ -1889,7 +2122,7 @@ var init_tools_jobs = __esm({
             this.timer = void 0;
             return;
           }
-          void this.sweep().catch((e) => log5.warn(`job sweep failed: ${e}`));
+          void this.sweep().catch((e) => log6.warn(`job sweep failed: ${e}`));
         }, this.options.sweepMs);
         this.timer.unref?.();
       }
@@ -1916,9 +2149,9 @@ __export(worktree_exports, {
   validateWorktreeSlug: () => validateWorktreeSlug,
   worktreeBranchName: () => worktreeBranchName
 });
-import { spawnSync } from "child_process";
-import { symlinkSync, mkdirSync, statSync as statSync3, readFileSync as readFileSync2, rmSync } from "fs";
-import { join as join2 } from "path";
+import { spawnSync as spawnSync2 } from "child_process";
+import { symlinkSync, mkdirSync, statSync as statSync4, readFileSync as readFileSync3, rmSync as rmSync2 } from "fs";
+import { join as join3 } from "path";
 function validateWorktreeSlug(slug2) {
   if (!slug2) throw new Error("worktree slug must not be empty");
   if (slug2.length > MAX_SLUG_LENGTH) throw new Error(`worktree slug must be \u2264${MAX_SLUG_LENGTH} chars (got ${slug2.length})`);
@@ -1934,13 +2167,13 @@ function worktreeBranchName(slug2) {
   return `worktree-${flattenSlug(slug2)}`;
 }
 function worktreesDir(repoRoot) {
-  return join2(repoRoot, ".claude", "worktrees");
+  return join3(repoRoot, ".claude", "worktrees");
 }
 function worktreePathFor(repoRoot, slug2) {
-  return join2(worktreesDir(repoRoot), flattenSlug(slug2));
+  return join3(worktreesDir(repoRoot), flattenSlug(slug2));
 }
 function git(args, cwd) {
-  const r = spawnSync("git", args, {
+  const r = spawnSync2("git", args, {
     cwd,
     stdio: ["ignore", "pipe", "pipe"],
     env: { ...process.env, ...GIT_NO_PROMPT_ENV }
@@ -1953,16 +2186,16 @@ function findGitRoot(from) {
 }
 function readWorktreeHead(worktreePath) {
   try {
-    const gitFile = readFileSync2(join2(worktreePath, ".git"), "utf-8").trim();
+    const gitFile = readFileSync3(join3(worktreePath, ".git"), "utf-8").trim();
     const m = gitFile.match(/^gitdir:\s*(.+)$/);
     if (!m) return null;
-    const headPath = join2(m[1], "HEAD");
-    const head = readFileSync2(headPath, "utf-8").trim();
+    const headPath = join3(m[1], "HEAD");
+    const head = readFileSync3(headPath, "utf-8").trim();
     const refMatch = head.match(/^ref:\s*(.+)$/);
     if (!refMatch) return head.length === 40 ? head : null;
-    const refPath = join2(m[1], "..", refMatch[1]);
+    const refPath = join3(m[1], "..", refMatch[1]);
     try {
-      return readFileSync2(refPath, "utf-8").trim();
+      return readFileSync3(refPath, "utf-8").trim();
     } catch {
     }
     const r = git(["rev-parse", "HEAD"], worktreePath);
@@ -1995,10 +2228,10 @@ function getOrCreateWorktree(repoRoot, slug2) {
 }
 function symlinkDirs(repoRoot, worktreePath, dirs) {
   for (const dir of dirs) {
-    const src = join2(repoRoot, dir);
-    const dst = join2(worktreePath, dir);
+    const src = join3(repoRoot, dir);
+    const dst = join3(worktreePath, dir);
     try {
-      statSync3(src);
+      statSync4(src);
     } catch {
       continue;
     }
@@ -2014,7 +2247,7 @@ function cleanupWorktree(repoRoot, slug2, opts) {
   const worktreePath = worktreePathFor(repoRoot, slug2);
   const branch = worktreeBranchName(slug2);
   try {
-    statSync3(worktreePath);
+    statSync4(worktreePath);
   } catch {
     return { removed: false, reason: "not found" };
   }
@@ -2024,7 +2257,7 @@ function cleanupWorktree(repoRoot, slug2, opts) {
   }
   for (const dir of ["node_modules", ".bun"]) {
     try {
-      rmSync(join2(worktreePath, dir));
+      rmSync2(join3(worktreePath, dir));
     } catch {
     }
   }
@@ -2561,7 +2794,7 @@ async function psGroupCpuSeconds(pgid) {
     const out = await new Promise((res, rej) => execFile4("ps", ["-A", "-o", "pid=,ppid=,pgid=,time="], { timeout: 5e3, env: { ...process.env, LC_ALL: "C" } }, (e, so) => e ? rej(e) : res(String(so))));
     return sumTreeCpu(out, pgid);
   } catch (e) {
-    log23.debug(`ps cpu probe failed for group ${pgid}: ${e}`);
+    log24.debug(`ps cpu probe failed for group ${pgid}: ${e}`);
     return void 0;
   }
 }
@@ -2709,7 +2942,7 @@ function makeRealShellTool(options) {
           proc.stderr?.on("data", collect);
           proc.on("error", (err2) => {
             if (err2?.name === "AbortError" || ctl.signal.aborted) return finish(reasonFor(timedOut, timeoutMs, clean2(out)));
-            log23.debug("shell spawn error", err2);
+            log24.debug("shell spawn error", err2);
             finish(`[exit 1] ${err2?.message ?? err2}${out ? "\n" + clean2(out) : ""}`);
           });
           proc.on("close", (code) => {
@@ -2782,7 +3015,7 @@ ${clean2(out) || "(no output yet)"}`;
     }
   ];
 }
-var log23, clean2, DETACHED, SECRET_ENV_RE, _spawn, ShellJobRegistry, shellStatus, NO_JOB2;
+var log24, clean2, DETACHED, SECRET_ENV_RE, _spawn, ShellJobRegistry, shellStatus, NO_JOB2;
 var init_tools_shell = __esm({
   "src/tools.shell.ts"() {
     "use strict";
@@ -2791,7 +3024,7 @@ var init_tools_shell = __esm({
     init_logging();
     init_shell_sandbox();
     init_tools_jobs();
-    log23 = forComponent("shell");
+    log24 = forComponent("shell");
     clean2 = (s) => truncateOutput(redactSecrets(s.replace(/\n+$/, "")));
     DETACHED = { stdio: ["ignore", "pipe", "pipe"], detached: true };
     SECRET_ENV_RE = /(_API_KEY|_TOKEN|_SECRET|_PASSWORD|_PRIVATE_KEY|^AWS_|^GITHUB_TOKEN$|^OPENAI_|^ANTHROPIC_|^GOOGLE_|^GEMINI_|^GROQ_|^NPM_TOKEN$)/i;
@@ -2939,9 +3172,9 @@ var init_tools_shell = __esm({
 
 // cli/cli.ts
 import { createInterface } from "readline/promises";
-import { existsSync as existsSync9, readFileSync as readFileSync9, appendFileSync, mkdirSync as mkdirSync12, writeFileSync as writeFileSync9, readdirSync as readdirSync4, statSync as statSync6, unlinkSync as unlinkSync5 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync10, appendFileSync, mkdirSync as mkdirSync12, writeFileSync as writeFileSync10, readdirSync as readdirSync4, statSync as statSync7, unlinkSync as unlinkSync5 } from "fs";
 import { homedir as homedir10 } from "os";
-import { spawnSync as spawnSync6 } from "child_process";
+import { spawnSync as spawnSync7 } from "child_process";
 
 // cli/clipboard.ts
 import { execFileSync } from "child_process";
@@ -3008,7 +3241,7 @@ function copyTextToClipboard(text, platform2 = process.platform) {
 }
 
 // cli/cli.ts
-import { join as join14, resolve as resolve4, basename as basename2, extname, dirname as dirname5 } from "path";
+import { join as join15, resolve as resolve4, basename as basename2, extname, dirname as dirname5 } from "path";
 import { AIClient, DecideClient, listModels, listProviders, getProviderFromModel, getModelInfo, resolveModel, isModelSupported, disposeCursorSessions, disposeClaudeCodeSessions } from "ai.libx.js";
 
 // src/ccBridge.ts
@@ -3589,8 +3822,8 @@ ${sections.join("\n\n---\n\n")}`;
 
 // src/subagent.ts
 init_tools();
-import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join4 } from "path";
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync3 } from "fs";
+import { join as join5 } from "path";
 
 // src/models.ts
 var MODEL_ALIASES = {
@@ -3767,7 +4000,7 @@ init_OverlayFilesystem();
 init_worktree();
 init_NodeDiskFilesystem();
 init_logging();
-var log6 = forComponent("subagent");
+var log7 = forComponent("subagent");
 async function boundedPool(items, limit, fn) {
   const out = new Array(items.length);
   let next = 0;
@@ -3839,17 +4072,17 @@ function traceFileFor(dir, label, depth) {
   try {
     mkdirSync2(dir, { recursive: true });
     const id = `${Date.now().toString(36)}-${(traceSeq++).toString(36)}`;
-    return join4(dir, `${id}-d${depth}-${sanitizeSlug(label) || "sub"}.json`);
+    return join5(dir, `${id}-d${depth}-${sanitizeSlug(label) || "sub"}.json`);
   } catch (e) {
-    log6.warn(`subagent trace dir unavailable (${dir}) \u2014 running without a trace: ${e instanceof Error ? e.message : String(e)}`);
+    log7.warn(`subagent trace dir unavailable (${dir}) \u2014 running without a trace: ${e instanceof Error ? e.message : String(e)}`);
     return void 0;
   }
 }
 function flushTrace(file, meta, messages, status) {
   try {
-    writeFileSync2(file, JSON.stringify({ ...meta, status, updated: Date.now(), messages }, null, 2));
+    writeFileSync3(file, JSON.stringify({ ...meta, status, updated: Date.now(), messages }, null, 2));
   } catch (e) {
-    log6.warn(`subagent trace flush failed (${file}): ${e instanceof Error ? e.message : String(e)}`);
+    log7.warn(`subagent trace flush failed (${file}): ${e instanceof Error ? e.message : String(e)}`);
   }
 }
 function installTrace(child, file, meta) {
@@ -3890,7 +4123,7 @@ async function runChildTraced(args) {
   if (file) flushTrace(file, meta, child.transcript, wc.timedOut() ? "deadline" : res.finishReason);
   let result = res.finishReason === "stop" ? res.text || `(child '${label}' finished with no summary; finishReason=${res.finishReason})` : abortHint(label, res, file);
   if (wc.timedOut()) {
-    log6.warn(`sub-task '${label}' hit its ${deadlineMs}ms wall-clock deadline (steps=${res.steps})`);
+    log7.warn(`sub-task '${label}' hit its ${deadlineMs}ms wall-clock deadline (steps=${res.steps})`);
     result += deadlineNote(deadlineMs);
   }
   await opts.hooks?.onSubagentStop?.(result, { label, agentType });
@@ -4219,7 +4452,7 @@ function reasoningToChatFragment(model, effort) {
 }
 
 // src/Agent.ts
-var log7 = forComponent("Agent");
+var log8 = forComponent("Agent");
 function envInt(key, fallback) {
   const n = typeof process !== "undefined" ? Number(process.env?.[key]) : NaN;
   return Number.isFinite(n) && n >= 0 ? n : fallback;
@@ -4300,6 +4533,9 @@ var AgentOptions = class {
    *  `maxTokens`: that is the cumulative SPEND kill-switch, and a spend budget must never be able to
    *  drive destructive compaction (`--max-tokens 50000` would otherwise shred the transcript). */
   contextWindow = 0;
+  /** Does a model take image input? true/false from the host's model catalog; undefined = unknown (images are tried,
+   *  and turned off for the run when the adapter refuses them). Unset = always try. */
+  imageInput;
   /** Pagination ceiling for a SINGLE tool result (bytes). A result over this is cropped to page 1 with
    *  a marker telling the model it was cropped (refine the query, or page further). Guards against one
    *  Grep/Read/MCP call blowing the whole context window. 0 = off. Default 60k (~15k tokens). */
@@ -4599,7 +4835,7 @@ var Agent = class _Agent {
       const disk = new NodeDiskFilesystem2(process.cwd());
       await disk.init();
       this.options.fs = new JailedFilesystem2(disk);
-      log7.info(`no fs provided \u2014 defaulting to jailed real disk at ${process.cwd()}`);
+      log8.info(`no fs provided \u2014 defaulting to jailed real disk at ${process.cwd()}`);
     }
     this.buildCtx();
   }
@@ -4744,7 +4980,8 @@ var Agent = class _Agent {
     const cap = _Agent.contextCap(this.options);
     const target = Math.round(cap * _Agent.COMPACT_TARGET);
     const kr = this.options.keepRecentImages ?? 1;
-    const tokensBefore = estimateTokens(this.transcript, kr);
+    const vis2 = this.sendsImages();
+    const tokensBefore = estimateTokens(this.transcript, kr, vis2);
     const msgsBefore = this.transcript.length;
     let max = Math.max(2, maxMessages);
     if (this.transcript.length <= max && tokensBefore <= target)
@@ -4752,18 +4989,18 @@ var Agent = class _Agent {
     void this.activeHooks?.onPreCompact?.(this.transcript);
     let out = this.transcript;
     if (out.length > max) out = compact(out, max, focus);
-    if (estimateTokens(out, kr) > target) out = elideOversizedImages(out, target, true, kr);
-    if (estimateTokens(out, kr) > target) out = capOversizedBodies(out, target, kr);
-    if (estimateTokens(out, kr) > target) out = elideOversizedImages(out, target, false, kr);
-    while (estimateTokens(out, kr) > target && max > 2 && out.length > 2) {
+    if (estimateTokens(out, kr, vis2) > target) out = elideOversizedImages(out, target, true, kr);
+    if (estimateTokens(out, kr, vis2) > target) out = capOversizedBodies(out, target, kr);
+    if (estimateTokens(out, kr, vis2) > target) out = elideOversizedImages(out, target, false, kr);
+    while (estimateTokens(out, kr, vis2) > target && max > 2 && out.length > 2) {
       max = Math.max(2, Math.floor(max / 2));
       out = capOversizedBodies(compact(out, max, focus), target, kr);
     }
-    if (estimateTokens(out, kr) > target) out = fitTokenBudget(out, target, kr);
+    if (estimateTokens(out, kr, vis2) > target) out = fitTokenBudget(out, target, kr);
     out = dropOrphanToolResults(out);
     this.transcript = out;
     this.releaseStaleImages();
-    return { tokensBefore, tokensAfter: estimateTokens(this.transcript, kr), target, cap, removed: msgsBefore - this.transcript.length };
+    return { tokensBefore, tokensAfter: estimateTokens(this.transcript, kr, vis2), target, cap, removed: msgsBefore - this.transcript.length };
   }
   /** Drop inline base64 images from older messages so Bun/JSC can reclaim the heap (see contentBytes). */
   releaseStaleImages(keepRecent = 1) {
@@ -4787,7 +5024,7 @@ var Agent = class _Agent {
     let closureNudged = false;
     let lastProgressAt = start;
     const kill = (finishReason) => {
-      log7.warn(`kill-switch: ${finishReason} (steps=${steps}, tokens=${usage.totalTokens}, budgetTokens=${Math.round(usage.totalTokens - 0.9 * usage.cacheReadTokens)}, ms=${Date.now() - start - this.parkedMs}${finishReason === "timeout" ? `, idle=${Date.now() - lastProgressAt - this.parkedMs}ms` : ""}${this.parkedMs ? ` +${this.parkedMs} parked` : ""})`);
+      log8.warn(`kill-switch: ${finishReason} (steps=${steps}, tokens=${usage.totalTokens}, budgetTokens=${Math.round(usage.totalTokens - 0.9 * usage.cacheReadTokens)}, ms=${Date.now() - start - this.parkedMs}${finishReason === "timeout" ? `, idle=${Date.now() - lastProgressAt - this.parkedMs}ms` : ""}${this.parkedMs ? ` +${this.parkedMs} parked` : ""})`);
       this.jobs.killAll(`run ended: ${finishReason}`, true);
       const claims = this.survivingClaims();
       return { text: lastAssistantText(this.transcript), steps, finishReason, messages: this.transcript, usage, usageEstimated, ...claims.length ? { fabricatedToolClaims: claims } : {} };
@@ -4802,7 +5039,7 @@ var Agent = class _Agent {
       steps++;
       this.options.host?.notify?.({ kind: "turn_start", message: `step ${steps}` });
       let res;
-      const sent = this.trimContext();
+      let sent = this.trimContext();
       const frag = reasoningToChatFragment(o.model, o.reasoning);
       const sentTools = o.model.startsWith("claude-code/") ? [] : wireTools;
       const isCursorWithTools = o.model.startsWith("cursor/") && wireTools.length > 0;
@@ -4813,9 +5050,9 @@ var Agent = class _Agent {
       this.nativeHoldMs = o.nativeHoldMs;
       if (isCursorWithTools) {
         if (typeof hostToolTimeoutMs === "number" && effectiveToolTimeoutMs !== hostToolTimeoutMs) {
-          log7.warn(`providerOptions.toolTimeoutMs=${hostToolTimeoutMs}ms is below what the registered tools need \u2014 RAISED to ${effectiveToolTimeoutMs}ms. ${toolTimeoutViolations(this.activeTools, hostToolTimeoutMs).length} tool(s) could outlive it, and the transport would have destroyed their results. To lower it, lower the tools' own maxDurationMs (e.g. the Shell tool's maxTimeoutMs) instead.`);
+          log8.warn(`providerOptions.toolTimeoutMs=${hostToolTimeoutMs}ms is below what the registered tools need \u2014 RAISED to ${effectiveToolTimeoutMs}ms. ${toolTimeoutViolations(this.activeTools, hostToolTimeoutMs).length} tool(s) could outlive it, and the transport would have destroyed their results. To lower it, lower the tools' own maxDurationMs (e.g. the Shell tool's maxTimeoutMs) instead.`);
         }
-        for (const v of toolTimeoutViolations(this.activeTools, effectiveToolTimeoutMs)) log7.warn(v);
+        for (const v of toolTimeoutViolations(this.activeTools, effectiveToolTimeoutMs)) log8.warn(v);
       }
       const hostExec = async (name, args) => {
         const tc = { id: `host-${Date.now()}`, type: "function", function: { name, arguments: JSON.stringify(args) } };
@@ -4874,12 +5111,20 @@ var Agent = class _Agent {
               res = r;
             }
             if (steps === 1 && this.isEmptyStop(res) && !this.pendingInjections.length) {
-              const e = new Error("model returned an empty turn (finishReason=stop, no text, no tools)");
+              const e = new Error(`model returned an empty turn (finishReason=${res.finishReason ?? "n/a"}, no text, no tools)`);
               e.code = "empty";
+              if (res.finishReason) e.providerFinishReason = res.finishReason;
               throw e;
             }
             break;
           } catch (err2) {
+            if (!this.imagesOff && /does not support .*input/i.test(String(err2?.message ?? "")) && sent.some((m) => Array.isArray(m.content) && m.role === "tool")) {
+              this.imagesOff = true;
+              log8.warn(`model refused image input (${err2?.message}) \u2014 resending with image Reads as text stubs`);
+              sent = this.trimContext();
+              attempt--;
+              continue;
+            }
             const sc = err2?.statusCode;
             const serverSide = sc >= 500 || sc === 408 || /Service Unavailable|overloaded|Internal server error|Bad gateway|Gateway time/i.test(String(err2?.message ?? ""));
             const network = !sc && /ECONNRESET|ECONNREFUSED|ETIMEDOUT|ENOTFOUND|EAI_AGAIN|EPIPE|socket hang up|fetch failed|network|terminated|UND_ERR/i.test(String(err2?.message ?? err2?.code ?? err2));
@@ -4887,11 +5132,11 @@ var Agent = class _Agent {
             const empty = err2?.code === "empty" || err2?.code === "cursor_silent";
             const maxAttempts = empty ? Math.max(o.emptyRetries, 0) : 2;
             const replaysTool = stalled && this.toolRanThisAttempt;
-            if (replaysTool) log7.warn("model stall after tool(s) already ran this step \u2014 not retrying (a retry would replay them)");
+            if (replaysTool) log8.warn("model stall after tool(s) already ran this step \u2014 not retrying (a retry would replay them)");
             const transient = !o.signal?.aborted && !isAbortError(err2) && !replaysTool && attempt < maxAttempts && (network || serverSide || stalled || empty);
             if (!transient) throw err2;
             const waitMs = (empty ? o.emptyRetryBaseMs : 1e3) * (attempt + 1);
-            log7.warn(`${empty ? "empty model turn" : stalled ? "model stall" : "network drop"} mid-step (${err2?.message ?? err2}) \u2014 retrying in ${waitMs}ms`);
+            log8.warn(`${empty ? "empty model turn" : stalled ? "model stall" : "network drop"} mid-step (${err2?.message ?? err2}) \u2014 retrying in ${waitMs}ms`);
             o.host?.notify?.({ kind: "retry", message: `${empty ? "model returned nothing" : stalled ? "model stalled" : "connection dropped"} \u2014 retrying step (#${attempt + 1})` });
             await new Promise((r) => setTimeout(r, waitMs));
           }
@@ -4899,13 +5144,14 @@ var Agent = class _Agent {
       } catch (err2) {
         if (err2?.code === "budget") return kill("budget");
         if (err2?.code === "stall") {
-          log7.warn(`model stalled out after retries: ${err2?.message ?? err2}`);
-          return { ...kill("timeout"), error: err2 };
+          log8.warn(`model stalled out after retries: ${err2?.message ?? err2}`);
+          return { ...kill("timeout"), providerFinishReason: "none (stalled)", error: err2 };
         }
         if (o.signal?.aborted || isAbortError(err2)) return kill("aborted");
         if (err2?.code === "empty" || err2?.code === "cursor_silent") {
-          log7.warn(`model returned empty/silent turns after retries \u2014 surfacing as failed`);
-          return { text: "", steps, finishReason: "empty", messages: this.transcript, usage, usageEstimated, error: err2 };
+          log8.warn(`model returned empty/silent turns after retries \u2014 surfacing as failed`);
+          const pfr = err2?.providerFinishReason;
+          return { text: "", steps, finishReason: "empty", ...pfr ? { providerFinishReason: pfr } : {}, messages: this.transcript, usage, usageEstimated, error: err2 };
         }
         const body = err2?.body ?? err2?.response?.data ?? err2?.error;
         let bodyStr;
@@ -4916,13 +5162,13 @@ var Agent = class _Agent {
         }
         if (bodyStr && err2 instanceof Error && !err2.message.includes(bodyStr)) err2.detail = bodyStr;
         const errLog = err2 instanceof Error ? { message: err2.message, ...err2.detail ? { detail: err2.detail } : {}, stack: err2.stack } : err2;
-        log7.error(`chat() failed: ${err2?.message ?? err2}${bodyStr ? ` \u2014 ${bodyStr}` : ""}`, errLog);
+        log8.error(`chat() failed: ${err2?.message ?? err2}${bodyStr ? ` \u2014 ${bodyStr}` : ""}`, errLog);
         return { text: "", steps, finishReason: "error", messages: this.transcript, usage, usageEstimated, error: err2 };
       }
       if (o.signal?.aborted) return kill("aborted");
       if (res.finishReason === "error" && !res.toolCalls?.length) {
         const err2 = new Error(contentText(res.content ?? "").trim() || "provider error");
-        log7.error(`chat() failed: ${err2.message}`);
+        log8.error(`chat() failed: ${err2.message}`);
         return { text: "", steps, finishReason: "error", messages: this.transcript, usage, usageEstimated, error: err2 };
       }
       if (!res.usage) {
@@ -4980,21 +5226,21 @@ var Agent = class _Agent {
         if (emptyTurn && o.failEmptyTurns) {
           if (!emptyNudged && canNudge()) {
             emptyNudged = true;
-            log7.warn(`empty model turn after tool work (step ${steps}, provider finishReason=${res.finishReason ?? "n/a"}) \u2014 nudging once`);
+            log8.warn(`empty model turn after tool work (step ${steps}, provider finishReason=${res.finishReason ?? "n/a"}) \u2014 nudging once`);
             this.transcript.push({ role: "user", content: "Continue \u2014 you returned nothing. Answer the user now using the tool results above, or keep working if you are not done." });
             continue;
           }
-          log7.warn(`model returned empty turns after tool work \u2014 surfacing as failed`);
+          log8.warn(`model returned empty turns after tool work \u2014 surfacing as failed`);
           const e = new Error("empty_response: model returned an empty turn (no text, no tools) after a re-prompt");
           e.code = "empty";
           return { text: "", steps, finishReason: "empty", ...res.finishReason ? { providerFinishReason: res.finishReason } : {}, messages: this.transcript, usage, usageEstimated, error: e };
         }
         const fabricated = o.catchFabricatedToolUse && !closureNudged ? this.fabricatedToolNames(contentText(res.content ?? "")) : [];
         for (const n of fabricated) this.fabricatedClaims.add(n);
-        if (fabricated.length && !canNudge()) log7.warn(`fabricated tool use: text names ${fabricated.join(", ")} but no step/budget left to demand the call \u2014 finishing with the existing answer`);
+        if (fabricated.length && !canNudge()) log8.warn(`fabricated tool use: text names ${fabricated.join(", ")} but no step/budget left to demand the call \u2014 finishing with the existing answer`);
         if (fabricated.length && canNudge()) {
           closureNudged = true;
-          log7.warn(`fabricated tool use: text names ${fabricated.join(", ")} but the run invoked ${this.invokedTools.size ? [...this.invokedTools].join(", ") : "nothing"} \u2014 demanding the real call`);
+          log8.warn(`fabricated tool use: text names ${fabricated.join(", ")} but the run invoked ${this.invokedTools.size ? [...this.invokedTools].join(", ") : "nothing"} \u2014 demanding the real call`);
           this.transcript.push({
             role: "user",
             content: `You referred to ${fabricated.map((n) => `\`${n}\``).join(", ")} in your reply, but you never actually called ${fabricated.length > 1 ? "those tools" : "that tool"} \u2014 no tool call was made, so any result you reported for ${fabricated.length > 1 ? "them" : "it"} was invented. Either call ${fabricated.length > 1 ? "them" : "it"} for real now, or answer without ${fabricated.length > 1 ? "them" : "it"} and do NOT claim any outcome \u2014 including a failure or a timeout \u2014 for a call you did not make.`
@@ -5003,14 +5249,14 @@ var Agent = class _Agent {
         }
         if (o.closeDelegatedTurns && res.endedWithoutClosing && !closureNudged && canNudge()) {
           closureNudged = true;
-          log7.verbose("delegated turn went silent after a tool \u2014 nudging a closing answer");
+          log8.verbose("delegated turn went silent after a tool \u2014 nudging a closing answer");
           this.transcript.push({
             role: "user",
             content: "You ran tools but did not reply. Answer the user now using the tool results above; if a tool failed, say so plainly. Do NOT re-run those tools, do NOT narrate what you did, and do NOT ask for permission to continue."
           });
           continue;
         }
-        log7.verbose(`completed in ${steps} step(s)`);
+        log8.verbose(`completed in ${steps} step(s)`);
         const drained = await this.jobs.drain(o.signal);
         if (o.signal?.aborted) return kill("aborted");
         if (drained.length) lastProgressAt = Date.now();
@@ -5044,7 +5290,7 @@ var Agent = class _Agent {
       if (this.ctx.needsInput) {
         const question = this.ctx.needsInput;
         this.ctx.needsInput = void 0;
-        log7.warn(`needs_input: ${question.question} (steps=${steps})`);
+        log8.warn(`needs_input: ${question.question} (steps=${steps})`);
         await this.jobs.drain();
         const text = [
           `OPEN QUESTION (run paused \u2014 no human was reachable): ${question.question}`,
@@ -5086,12 +5332,12 @@ var Agent = class _Agent {
         if (this.toolHoldActive()) {
           const now4 = Date.now();
           const who = this.jobs.holding().map((j) => `${j.kind} "${j.label}" (${Math.round((now4 - j.startedAt) / 1e3)}s, quiet ${Math.round((now4 - j.lastActivityAt) / 1e3)}s)`).join(", ");
-          log7.warn(`stall watchdog: no stream output for ${stallMs}ms \u2014 held by ${who}`);
+          log8.warn(`stall watchdog: no stream output for ${stallMs}ms \u2014 held by ${who}`);
           this.options.host?.notify?.({ kind: "tool_hold", message: `waiting on ${who}` });
           return poke();
         }
         const inFlight = this.jobs.list().filter((j) => j.status === "running");
-        log7.warn(`stall watchdog: no stream output for ${stallMs}ms and no tool holding the stream \u2014 aborting the request` + (inFlight.length ? ` (${inFlight.length} detached job(s) running, not awaited by the stream: ${inFlight.map((j) => `${j.id}/${j.kind}`).join(", ")})` : ""));
+        log8.warn(`stall watchdog: no stream output for ${stallMs}ms and no tool holding the stream \u2014 aborting the request` + (inFlight.length ? ` (${inFlight.length} detached job(s) running, not awaited by the stream: ${inFlight.map((j) => `${j.id}/${j.kind}`).join(", ")})` : ""));
         fired = true;
         ac.abort(stallError());
       }, stallMs);
@@ -5261,13 +5507,13 @@ var Agent = class _Agent {
     const decision = await this.park(Promise.resolve(hooks?.preToolUse?.(call, meta)));
     if (decision?.block) {
       const blocked = `Blocked by hook: ${decision.reason ?? "no reason given"}`;
-      log7.debug(`${tc.function.name} -> ${blocked}`);
+      log8.debug(`${tc.function.name} -> ${blocked}`);
       await hooks?.postToolUse?.(call, blocked, meta);
       return blocked;
     }
     this.options.host?.notify?.({ kind: "tool_use", id: tc.id ?? "", name: tc.function.name, input: args });
     if (earlyError) {
-      log7.debug(`${tc.function.name} -> ${earlyError}`);
+      log8.debug(`${tc.function.name} -> ${earlyError}`);
       await hooks?.postToolUse?.(call, earlyError, meta);
       this.options.host?.notify?.({ kind: "tool_result", id: tc.id ?? "", output: earlyError, isError: true });
       return earlyError;
@@ -5276,12 +5522,12 @@ var Agent = class _Agent {
     let images;
     let threw = false;
     try {
-      log7.debug(`${tc.function.name}(${tc.function.arguments})`);
+      log8.debug(`${tc.function.name}(${tc.function.arguments})`);
       this.ctx.emit = hooks?.onToolOutput ? (chunk) => {
         try {
           hooks.onToolOutput(call, chunk, meta);
         } catch (e) {
-          log7.debug(`onToolOutput hook error: ${e}`);
+          log8.debug(`onToolOutput hook error: ${e}`);
         }
       } : void 0;
       const raw = await tool.run(args, this.ctx);
@@ -5293,7 +5539,7 @@ var Agent = class _Agent {
       }
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
-      log7.debug(`${tc.function.name} -> error: ${msg}`);
+      log8.debug(`${tc.function.name} -> error: ${msg}`);
       result = `Error: ${msg}`;
       threw = true;
     } finally {
@@ -5353,6 +5599,13 @@ ${out}`;
    *  3. token-aware backstop (`maxContextTokens`) — drop oldest messages until under an estimated token ceiling.
    * With every knob off, returns the transcript unchanged (same reference).
    */
+  /** Set when the model refused image parts this run: tool image Reads go as text stubs from then on. */
+  imagesOff = false;
+  /** Send tool image Reads as images? Known models by their catalog flag; unknown ones try (and latch off on refusal). */
+  sendsImages() {
+    if (this.imagesOff) return false;
+    return this.options.imageInput?.(this.options.model) ?? true;
+  }
   trimContext() {
     const o = this.options;
     const m = this.transcript;
@@ -5362,17 +5615,19 @@ ${out}`;
     const browserKeep = this.browserActive ? o.browserTrim?.keepOutputs : void 0;
     const keep = browserKeep != null ? o.keepToolOutputs ? Math.min(o.keepToolOutputs, browserKeep) : browserKeep : o.keepToolOutputs;
     if (keep) out = stubOldToolResults(out ?? m, keep);
-    out = expandImagesForSend(dropOrphanToolResults(out ?? m), o.keepRecentImages ?? 1);
+    out = expandImagesForSend(dropOrphanToolResults(out ?? m), o.keepRecentImages ?? 1, void 0, this.sendsImages());
     if (o.maxContextTokens) {
       const pre = out.length;
-      out = fitTokenBudget(out, o.maxContextTokens, o.keepRecentImages ?? 1);
+      out = fitTokenBudget(out, o.maxContextTokens, o.keepRecentImages ?? 1, this.sendsImages());
       const dropped = pre - out.length;
       if (dropped > 0 && dropped !== this.lastTrimNotified) {
         this.lastTrimNotified = dropped;
         o.host?.notify?.({ kind: "compaction", message: `context full \u2014 auto-trimmed ${dropped} oldest message(s) to fit ~${Math.round(o.maxContextTokens / 1e3)}k tokens` });
       }
     }
-    return dropOrphanToolResults(out);
+    out = dropOrphanToolResults(out);
+    if (/^google\//.test(o.model ?? "")) out = hoistToolImages(out);
+    return scrubBase64(out);
   }
 };
 function dropOldest(m, max) {
@@ -5381,8 +5636,8 @@ function dropOldest(m, max) {
 }
 var ANTHROPIC_WINDOW_WITHOUT_1M_BETA = 2e5;
 var isAnthropicModel = (m) => !!m && (m.startsWith("anthropic/") || /(^|\/)claude-/.test(m));
-function estimateTokens(m, keepRecentImages = 1) {
-  return Math.ceil(sendBytes(m, keepRecentImages) / 4);
+function estimateTokens(m, keepRecentImages = 1, vision = true) {
+  return Math.ceil(sendBytes(m, keepRecentImages, vision) / 4);
 }
 var TRANSPORT_TOOL_TIMEOUT_FLOOR_MS = 18e5;
 var isMcpTool = (t) => t.name.startsWith("mcp__") || t.name === "McpCall";
@@ -5551,8 +5806,8 @@ function dropOrphanToolResults(messages) {
   const ok = (m) => m.role !== "tool" || ids.has(m.tool_call_id ?? "");
   return messages.every(ok) ? messages : messages.filter(ok);
 }
-function fitTokenBudget(messages, maxTokens, keepRecentImages = 1) {
-  const per = sendBytesPer(messages, keepRecentImages).map((b) => Math.ceil(b / 4));
+function fitTokenBudget(messages, maxTokens, keepRecentImages = 1, vision = true) {
+  const per = sendBytesPer(messages, keepRecentImages, vision).map((b) => Math.ceil(b / 4));
   let total = per.reduce((a, b) => a + b, 0);
   if (total <= maxTokens) return messages;
   const head = messages[0]?.role === "system" ? [messages[0]] : [];
@@ -5561,7 +5816,7 @@ function fitTokenBudget(messages, maxTokens, keepRecentImages = 1) {
   const ids = callIdSet(messages.slice(from));
   while (from < messages.length && messages[from].role === "tool" && !ids.has(messages[from].tool_call_id ?? "")) total -= per[from++];
   if (total > maxTokens)
-    log7.warn(`context ~${total} tok still over maxContextTokens=${maxTokens} after trimming (system head can't be dropped)`);
+    log8.warn(`context ~${total} tok still over maxContextTokens=${maxTokens} after trimming (system head can't be dropped)`);
   return [...head, ...messages.slice(from)];
 }
 function compact(m, max, focus) {
@@ -6139,7 +6394,7 @@ init_tools_web();
 init_tools();
 init_tools_structured();
 init_logging();
-var log8 = forComponent("scratch");
+var log9 = forComponent("scratch");
 var SCRATCH_DIR = "/scratch";
 function shortArgs(args) {
   try {
@@ -6179,7 +6434,7 @@ var Scratch = class {
           await (this.dirReady ??= mkdirp(this.fs, dir));
           await this.fs.writeFile(path, header + raw);
         } catch (e) {
-          log8.debug("scratch write failed; returning raw", e);
+          log9.debug("scratch write failed; returning raw", e);
           return raw;
         }
         const preview = raw.slice(0, previewChars).replace(/\s+/g, " ").trim();
@@ -6209,7 +6464,7 @@ To pull a specific detail, Grep/Read ${path}, or call Ask({ question: "\u2026",
       await (this.dirReady ??= mkdirp(this.fs, dir));
       await this.fs.writeFile(path, header + full);
     } catch (e) {
-      log8.debug("scratch spill failed; cropping lossy", e);
+      log9.debug("scratch spill failed; cropping lossy", e);
       return full.slice(0, pageBytes) + `
 
 [output cropped to ${pageBytes} of ${full.length} bytes; full output unavailable (scratch write failed) \u2014 refine your query]`;
@@ -6255,7 +6510,7 @@ Question: ${q2}`);
         const answer = (res.text ?? "").trim();
         return answer || "(no answer found in scratch)";
       } catch (e) {
-        log8.debug("Ask peek failed", e);
+        log9.debug("Ask peek failed", e);
         return `Error querying scratch: ${e?.message ?? e}`;
       }
     }
@@ -6264,7 +6519,7 @@ Question: ${q2}`);
 
 // src/lessons.ts
 init_logging();
-var log9 = forComponent("Lessons");
+var log10 = forComponent("Lessons");
 var LessonOptionsDefaults = class {
   minRepeats = 2;
 };
@@ -6289,8 +6544,8 @@ function lessonCapture(options) {
       counts.set(lesson.slug, n);
       if (n < o.minRepeats) return;
       written.add(lesson.slug);
-      await writeFact(o.fs, o.dir, lesson.slug, lesson.body).catch((e) => log9.warn(`could not persist ${lesson.slug}: ${e?.message ?? e}`));
-      log9.debug(`captured lesson ${lesson.slug} (recurred ${n}\xD7)`);
+      await writeFact(o.fs, o.dir, lesson.slug, lesson.body).catch((e) => log10.warn(`could not persist ${lesson.slug}: ${e?.message ?? e}`));
+      log10.debug(`captured lesson ${lesson.slug} (recurred ${n}\xD7)`);
     }
   };
 }
@@ -6298,7 +6553,7 @@ function lessonCapture(options) {
 // src/reflect.ts
 init_llm();
 init_logging();
-var log10 = forComponent("Reflect");
+var log11 = forComponent("Reflect");
 async function reflectOnRun(o) {
   const digest = digestRun(o.result.messages, o.maxDigestChars ?? 6e3);
   if (!digest.trim()) return null;
@@ -6314,7 +6569,7 @@ If the run was fine or the issue was purely task-specific (not generalizable), r
     const r = await o.ai.chat({ model: o.model, messages: [{ role: "user", content: prompt }], stream: false });
     text = r?.content ?? "";
   } catch (e) {
-    log10.warn(`reflection call failed: ${e?.message ?? e}`);
+    log11.warn(`reflection call failed: ${e?.message ?? e}`);
     return null;
   }
   const m = text.match(/LESSON:\s*(.+)/i);
@@ -6324,10 +6579,10 @@ If the run was fine or the issue was purely task-specific (not generalizable), r
   try {
     await writeFact(o.fs, o.dir, slug2, lesson);
   } catch (e) {
-    log10.warn(`could not persist lesson: ${e?.message ?? e}`);
+    log11.warn(`could not persist lesson: ${e?.message ?? e}`);
     return null;
   }
-  log10.debug(`reflection persisted ${slug2}`);
+  log11.debug(`reflection persisted ${slug2}`);
   return slug2;
 }
 function digestRun(messages, maxChars) {
@@ -6376,7 +6631,7 @@ function forComponent2(name) {
 }
 
 // node_modules/@bod.ee/voice/src/core/emotion.ts
-var log11 = forComponent2("Emotion");
+var log12 = forComponent2("Emotion");
 var EMOTIONS = [
   // primary (best results)
   "neutral",
@@ -6508,7 +6763,7 @@ function renderEmotions(text, opts = { show: true }) {
       speech += cartesiaTag(tag);
       if (opts.show) display += m[0];
     } else {
-      log11.debug(`dropping unknown emotion tag ${m[0]}`);
+      log12.debug(`dropping unknown emotion tag ${m[0]}`);
     }
     last = m.index + m[0].length;
   }
@@ -6550,7 +6805,7 @@ var EmotionStream = class {
       if (tag) {
         this.pending = tag;
         if (this.show) display += m[0];
-      } else log11.debug(`dropping unknown emotion tag ${m[0]}`);
+      } else log12.debug(`dropping unknown emotion tag ${m[0]}`);
       last = m.index + m[0].length;
     }
     this.emit(body.slice(last), (s, d, p) => {
@@ -6697,7 +6952,7 @@ function computeHoldMs(ctx) {
 }
 
 // node_modules/@bod.ee/voice/src/core/engine.ts
-var log12 = forComponent2("VoiceEngine");
+var log13 = forComponent2("VoiceEngine");
 var realClock = {
   now: () => performance.now(),
   setTimeout: (fn, ms) => setTimeout(fn, ms),
@@ -7085,8 +7340,8 @@ var VoiceEngine = class _VoiceEngine {
     this.tts.warmup?.();
     this.setState("listening");
     if (this.options.bargeInMode === "aec" && !this.stt.usingAec)
-      log12.warn("bargeInMode=aec but mic does not report echoCancellation applied \u2014 STT may transcribe the assistant");
-    log12.debug(`voice I/O up (${this.usingAec ? "AEC" : "heuristic echo"} capture, mode=${this.options.bargeInMode}, mic reports aec=${this.stt.usingAec})`);
+      log13.warn("bargeInMode=aec but mic does not report echoCancellation applied \u2014 STT may transcribe the assistant");
+    log13.debug(`voice I/O up (${this.usingAec ? "AEC" : "heuristic echo"} capture, mode=${this.options.bargeInMode}, mic reports aec=${this.stt.usingAec})`);
   }
   /** The RESOLVED barge-in tier (the single seam every tier branch reads). `bargeInMode` overrides
    *  the mic's self-report — see the option doc for why the report is not trustworthy on mobile. */
@@ -7111,7 +7366,7 @@ var VoiceEngine = class _VoiceEngine {
       this.options.onDiag({ t: this.clock.now(), kind, ...fields });
     } catch (e) {
       this.diagOn = false;
-      log12.debug(`onDiag threw \u2014 diagnostics disabled: ${e instanceof Error ? e.message : e}`);
+      log13.debug(`onDiag threw \u2014 diagnostics disabled: ${e instanceof Error ? e.message : e}`);
     }
   }
   idleWaiters = [];
@@ -7250,7 +7505,7 @@ var VoiceEngine = class _VoiceEngine {
     }
     for (const w of this.words(this.reply)) this.echoWords.add(w);
     this.tts.speak(forSpeech(speech), true);
-    if (!this.spokeDeltas && this.turnStartAt) log12.debug(`ttft: ${Math.round(this.clock.now() - this.turnStartAt)}ms`);
+    if (!this.spokeDeltas && this.turnStartAt) log13.debug(`ttft: ${Math.round(this.clock.now() - this.turnStartAt)}ms`);
     this.spokeDeltas = true;
     this.setState("speaking");
     if (this.options.revealMode !== "off" && display) {
@@ -7363,13 +7618,13 @@ var VoiceEngine = class _VoiceEngine {
       this.drainTimer = null;
       this.speaking = false;
       this.stopWordReveal(true);
-      if (this.turnStartAt) log12.debug(`turn: ${Math.round(this.clock.now() - this.turnStartAt)}ms (incl. playback)`);
+      if (this.turnStartAt) log13.debug(`turn: ${Math.round(this.clock.now() - this.turnStartAt)}ms (incl. playback)`);
       this.echoUntil = this.clock.now() + 2500;
       if (!this.usingAec) this.stt.reset();
       try {
         this.options.onSpeechEnd();
       } catch (e) {
-        log12.warn(`onSpeechEnd threw: ${e instanceof Error ? e.message : e}`);
+        log13.warn(`onSpeechEnd threw: ${e instanceof Error ? e.message : e}`);
       }
       this.setState("listening");
       if (this.uttQueue.length) this.pumpQueue();
@@ -7443,7 +7698,7 @@ var VoiceEngine = class _VoiceEngine {
     if (!host) return pick;
     const ctx = { text: this.lastDispatchText, question: this.lastDispatchWasQuestion, barged: this.bargedBeforeDispatch };
     const fallback = (e) => {
-      log12.warn(`pickAck failed \u2014 using the default pools: ${e instanceof Error ? e.message : e}`);
+      log13.warn(`pickAck failed \u2014 using the default pools: ${e instanceof Error ? e.message : e}`);
       pick.picked = false;
       return void 0;
     };
@@ -7533,7 +7788,7 @@ var VoiceEngine = class _VoiceEngine {
     this.ackProbe = null;
     const queued = this.uttQueue.splice(0);
     const droppedQueued = queued.length;
-    if (droppedQueued) log12.info(`barge-in cut ${droppedQueued} queued worker utterance(s) \u2014 handed to the host`);
+    if (droppedQueued) log13.info(`barge-in cut ${droppedQueued} queued worker utterance(s) \u2014 handed to the host`);
     this.overlapKeptUntil = 0;
     if (!this.speaking && !this.drainTimer) {
       if (droppedQueued) this.lastInterrupted = { full: "", heard: "", queued, queuedTurn: false };
@@ -7762,7 +8017,7 @@ var VoiceEngine = class _VoiceEngine {
       if (flat && this.lastDispatchFlat && this.clock.now() - this.lastDispatchAt < _VoiceEngine.DUP_FINAL_MS && (this.lastDispatchFlat.startsWith(flat) || flat.startsWith(this.lastDispatchFlat))) return;
       this.specSpent = true;
       this.specText = this.specPartial;
-      log12.debug(`speculate: "${this.specText.slice(0, 60)}"`);
+      log13.debug(`speculate: "${this.specText.slice(0, 60)}"`);
       this.diag("speculate", { text: this.specText });
       this.options.onSpeculate(this.specText);
     }, this.options.speculativeMs);
@@ -7831,7 +8086,7 @@ var VoiceEngine = class _VoiceEngine {
     };
     this.tts.newContext();
     this.tts.speak(phrase, false);
-    log12.debug(`backchannel: "${phrase}"`);
+    log13.debug(`backchannel: "${phrase}"`);
     this.diag("backchannel", { phrase });
     this.options.onBackchannel(phrase);
   }
@@ -7864,7 +8119,7 @@ var VoiceEngine = class _VoiceEngine {
     });
     if (idx < 0) return text;
     toks.splice(idx, 1);
-    log12.verbose(`stripped backchannel echo "${this.lastBcPhrase}" from dispatching final`);
+    log13.verbose(`stripped backchannel echo "${this.lastBcPhrase}" from dispatching final`);
     return toks.join(" ");
   }
   /** Merge a resumed utterance into the pending one, deduping any word-overlap. Soniox re-finalizes
@@ -8050,7 +8305,7 @@ var VoiceEngine = class _VoiceEngine {
     }
     const bargeHold = !this.looksIncomplete(this.pendingUtt) && this.unfinishedBargeLine(this.pendingUtt);
     if (this.options.incompleteMergeMs && (bargeHold || this.looksIncomplete(this.pendingUtt))) {
-      log12.verbose(`hold: incomplete utterance "${this.pendingUtt.slice(-40)}"`);
+      log13.verbose(`hold: incomplete utterance "${this.pendingUtt.slice(-40)}"`);
       this.diag("hold", { reason: bargeHold ? "barge_unfinished" : "incomplete", tail: this.pendingUtt.slice(-40) });
       this.options.onHold();
       if (this.options.holdFiller && !this.speaking) this.speakFiller(this.options.holdFiller);
@@ -8089,13 +8344,13 @@ var VoiceEngine = class _VoiceEngine {
       const answered = this.answeredSinceDispatch();
       const part = flat !== this.lastDispatchFlat && !answered && this.echoesDispatch(text);
       if (part || flat && flat === this.lastDispatchFlat && !answered && this.clock.now() - this.lastDispatchAt < _VoiceEngine.DUP_FINAL_MS) {
-        log12.verbose(`dropped duplicate final "${text.slice(0, 40)}" (identical to the just-dispatched utterance, no reply between)`);
+        log13.verbose(`dropped duplicate final "${text.slice(0, 40)}" (identical to the just-dispatched utterance, no reply between)`);
         this.diag("utterance_drop", { reason: "dup_final", text: text.slice(0, 60) });
         return;
       }
       const refinal = this.refinalizes(text);
       if (refinal && this.repliedSinceDispatch) {
-        log12.verbose(`dropped re-finalization "${text.slice(0, 60)}" (superset of the just-dispatched utterance, reply already flowing)`);
+        log13.verbose(`dropped re-finalization "${text.slice(0, 60)}" (superset of the just-dispatched utterance, reply already flowing)`);
         this.diag("utterance_drop", { reason: "refinalized", text: text.slice(0, 60) });
         this.lastDispatchFlat = flat;
         this.lastDispatchWords = text.trim().split(/\s+/);
@@ -8374,7 +8629,7 @@ var SpokenSplitter = class {
 };
 
 // node_modules/@bod.ee/voice/src/adapters/soniox.ts
-var log13 = forComponent2("SonioxSTT");
+var log14 = forComponent2("SonioxSTT");
 var now = () => performance.now();
 var SonioxSTTOptions = class {
   auth = "";
@@ -8419,7 +8674,7 @@ var SonioxSTT = class {
       this.onDiag({ t: now(), kind, ...fields });
     } catch (e) {
       this.diagOn = false;
-      log13.debug(`onDiag threw \u2014 STT diagnostics disabled: ${e instanceof Error ? e.message : e}`);
+      log14.debug(`onDiag threw \u2014 STT diagnostics disabled: ${e instanceof Error ? e.message : e}`);
     }
   }
   lastChunkAt = 0;
@@ -8461,11 +8716,11 @@ var SonioxSTT = class {
     this.ws.onmessage = (ev) => this.handle(JSON.parse(String(ev.data)));
     this.ws.onclose = (ev) => {
       if (this.stopped) return;
-      log13.warn(`soniox ws closed (${ev.code} ${ev.reason || ""}) \u2014 reconnecting`);
+      log14.warn(`soniox ws closed (${ev.code} ${ev.reason || ""}) \u2014 reconnecting`);
       this.diag("stt_ws_closed", { code: ev.code, reason: String(ev.reason || ""), reconnecting: true });
       this.reset();
       this.connectWs().catch((e) => {
-        log13.error(`soniox reconnect failed: ${e.message}`);
+        log14.error(`soniox reconnect failed: ${e.message}`);
         this.diag("stt_reconnect_failed", { message: e.message });
       });
     };
@@ -8477,7 +8732,7 @@ var SonioxSTT = class {
     this.endpointTimer = setInterval(() => {
       const combined = (this.finalText + this.partialText).trim();
       if (!combined || now() - this.lastChangeAt < this.options.silenceEndpointMs) return;
-      if (this.firstTokenAt) log13.debug(`stt: ${Math.round(now() - this.firstTokenAt)}ms first-token\u2192silence-endpoint, "${combined.slice(0, 60)}"`);
+      if (this.firstTokenAt) log14.debug(`stt: ${Math.round(now() - this.firstTokenAt)}ms first-token\u2192silence-endpoint, "${combined.slice(0, 60)}"`);
       this.reset();
       this.onUtterance(combined, now());
     }, 120);
@@ -8489,7 +8744,7 @@ var SonioxSTT = class {
         if (this.stopped) return;
         const ref = this.lastChunkAt || this.startedChunksAt;
         if (now() - ref > noAudioMs) {
-          log13.error(`stt: no mic audio for >${Math.round(noAudioMs / 1e3)}s \u2014 capture device stopped delivering`);
+          log14.error(`stt: no mic audio for >${Math.round(noAudioMs / 1e3)}s \u2014 capture device stopped delivering`);
           this.diag("stt_watchdog_fatal", { noAudioMs });
           this.onFatal("microphone stopped delivering audio (try a different input device, e.g. AirPods, or check System Settings \u2192 Sound \u2192 Input)");
           this.stop();
@@ -8512,7 +8767,7 @@ var SonioxSTT = class {
   handle(m) {
     if (m.error_message) {
       this.diag("stt_error", { message: String(m.error_message), code: m.error_code });
-      return log13.error(`soniox: ${m.error_message}`);
+      return log14.error(`soniox: ${m.error_message}`);
     }
     let endpoint = false;
     for (const t of m.tokens ?? []) {
@@ -8529,7 +8784,7 @@ var SonioxSTT = class {
     this.onPartial(combined);
     if (endpoint && this.finalText.trim()) {
       const utterance = this.finalText.trim();
-      if (this.firstTokenAt) log13.debug(`stt: ${Math.round(now() - this.firstTokenAt)}ms first-token\u2192endpoint, "${utterance.slice(0, 60)}"`);
+      if (this.firstTokenAt) log14.debug(`stt: ${Math.round(now() - this.firstTokenAt)}ms first-token\u2192endpoint, "${utterance.slice(0, 60)}"`);
       this.reset();
       this.onUtterance(utterance, now());
     }
@@ -8551,7 +8806,7 @@ var SonioxSTT = class {
 };
 
 // node_modules/@bod.ee/voice/src/adapters/cartesia.ts
-var log14 = forComponent2("CartesiaTTS");
+var log15 = forComponent2("CartesiaTTS");
 var now2 = () => performance.now();
 var CartesiaTTSOptions = class {
   auth = "";
@@ -8587,7 +8842,7 @@ var CartesiaTTS = class _CartesiaTTS {
       this.onDiag({ t: now2(), kind, ...fields });
     } catch (e) {
       this.diagOn = false;
-      log14.debug(`onDiag threw \u2014 TTS diagnostics disabled: ${e instanceof Error ? e.message : e}`);
+      log15.debug(`onDiag threw \u2014 TTS diagnostics disabled: ${e instanceof Error ? e.message : e}`);
     }
   }
   firstAudioAt = 0;
@@ -8622,11 +8877,11 @@ var CartesiaTTS = class _CartesiaTTS {
       this.ws.onerror = (e) => rej(new Error(`cartesia ws: ${e.message || "connect failed"}`));
     });
     this.ws.onclose = (ev) => {
-      log14.warn(`cartesia ws closed (${ev.code} ${ev.reason || ""})`);
+      log15.warn(`cartesia ws closed (${ev.code} ${ev.reason || ""})`);
       this.diag("tts_ws_closed", { code: ev.code, reason: String(ev.reason || ""), reconnecting: !this.closed });
       if (!this.closed) {
         this.connecting = this.doConnect().catch((e) => {
-          log14.error(`cartesia reconnect failed: ${e.message}`);
+          log15.error(`cartesia reconnect failed: ${e.message}`);
           this.diag("tts_reconnect_failed", { message: e.message });
         });
       }
@@ -8654,12 +8909,12 @@ var CartesiaTTS = class _CartesiaTTS {
           this.down = true;
           this.downAt = now2();
           this.consecutiveOk = 0;
-          log14.warn(`TTS circuit breaker open \u2014 ${this.consecutiveErrors} consecutive errors, switching to text-only`);
+          log15.warn(`TTS circuit breaker open \u2014 ${this.consecutiveErrors} consecutive errors, switching to text-only`);
           this.diag("tts_breaker_open", { errors: this.consecutiveErrors });
           this.onDone();
           this.startProbe();
         } else if (!this.down) {
-          (/No valid transcripts/i.test(m.message || "") ? log14.debug : log14.warn)(`cartesia: ${JSON.stringify(m)}`);
+          (/No valid transcripts/i.test(m.message || "") ? log15.debug : log15.warn)(`cartesia: ${JSON.stringify(m)}`);
         }
       }
     };
@@ -8674,7 +8929,7 @@ var CartesiaTTS = class _CartesiaTTS {
     this.stopProbe();
     const downMs = this.downAt ? now2() - this.downAt : 0;
     this.diag("tts_breaker_close", { downMs: Math.round(downMs) });
-    (downMs < 2e3 ? log14.debug : log14.info)(`TTS recovered${downMs ? ` (down ${downMs}ms)` : ""}`);
+    (downMs < 2e3 ? log15.debug : log15.info)(`TTS recovered${downMs ? ` (down ${downMs}ms)` : ""}`);
   }
   /** Ensure the WS is open before sending — reconnects if idle-closed. */
   async ensureConnected() {
@@ -8757,13 +9012,13 @@ function base64ToBytes(b64) {
 }
 
 // node_modules/@bod.ee/voice/src/adapters/fish.ts
-var log15 = forComponent2("FishTTS");
+var log16 = forComponent2("FishTTS");
 
 // node_modules/@bod.ee/voice/src/adapters/grok.ts
-var log16 = forComponent2("GrokTTS");
+var log17 = forComponent2("GrokTTS");
 
 // node_modules/@bod.ee/voice/src/adapters/grok-stt.ts
-var log17 = forComponent2("GrokSTT");
+var log18 = forComponent2("GrokSTT");
 
 // src/voice/engine.ts
 init_logging();
@@ -8775,7 +9030,7 @@ configureLogging((name) => {
 
 // src/voice/instinct.ts
 init_logging();
-var log18 = forComponent("Instinct");
+var log19 = forComponent("Instinct");
 var InstinctOptions = class {
   decider;
   /** Partial unchanged this long (a micro-pause) → consult. */
@@ -9012,13 +9267,13 @@ var Instinct = class {
    *  unfinished partial is no turn to react to — the interjection itself is the reply. */
   pickAck(ctx) {
     if (this.interjecting) {
-      log18.debug(`ack: cut-in turn \u2192 silent (engine context "${ctx.text.slice(0, 40)}" is the previous final)`);
+      log19.debug(`ack: cut-in turn \u2192 silent (engine context "${ctx.text.slice(0, 40)}" is the previous final)`);
       return Promise.resolve(null);
     }
     const text = ctx.text.trim();
     const p = (async () => {
       const intentP = ctx.barged ? this.bargeIntent(text).catch((e) => {
-        log18.warn(`barge intent for the ack failed \u2014 situational ack: ${e.message}`);
+        log19.warn(`barge intent for the ack failed \u2014 situational ack: ${e.message}`);
         return null;
       }) : null;
       const d = await this.ask(
@@ -9040,7 +9295,7 @@ var Instinct = class {
       settle = r;
     });
     const timer = setTimeout(() => {
-      log18.debug(`ack: no engine outcome in ${this.o.ackSettleMs}ms \u2014 not claimed`);
+      log19.debug(`ack: no engine outcome in ${this.o.ackSettleMs}ms \u2014 not claimed`);
       settle(null);
     }, this.o.ackSettleMs);
     void spoken.then(() => clearTimeout(timer));
@@ -9078,7 +9333,7 @@ var Instinct = class {
       });
       return { kind, heard, choice: answers.act.choice, probabilities: answers.act.probabilities, ms: Math.round(this.o.now() - t0) };
     } catch (e) {
-      log18.warn(`${kind} decision failed \u2014 falling back to engine defaults: ${e.message}`);
+      log19.warn(`${kind} decision failed \u2014 falling back to engine defaults: ${e.message}`);
       if (rethrow) throw e;
       return null;
     }
@@ -9087,7 +9342,7 @@ var Instinct = class {
 
 // src/voice/unsaid.ts
 init_logging();
-var log19 = forComponent("Unsaid");
+var log20 = forComponent("Unsaid");
 var STOP2 = new Set("that this with have from they them their there then than what when were will would your about into just also been some only over more most very which while after before because these those does here".split(" "));
 var contentStems = (s) => (s.toLowerCase().match(/[a-z0-9']+/g) ?? []).filter((w) => w.length >= 4 && !STOP2.has(w)).map((w) => w.slice(0, 4));
 var SAID_OVERLAP = 0.6;
@@ -9127,7 +9382,7 @@ async function unsaidClauses(pieces, spoken, decider, timeoutMs = 5e3) {
       return p < CONVEYED_MIN;
     }).map((x) => x.c);
   } catch (e) {
-    log19.warn(`unsaid judge failed \u2014 only near-zero-overlap clauses count as unsaid: ${e.message}`);
+    log20.warn(`unsaid judge failed \u2014 only near-zero-overlap clauses count as unsaid: ${e.message}`);
     return fallback();
   } finally {
     clearTimeout(timer);
@@ -9198,7 +9453,7 @@ async function judgeLeak(decider, sentence, userSaid) {
 }
 
 // src/duplex.ts
-var log20 = forComponent("DuplexAgent");
+var log21 = forComponent("DuplexAgent");
 function describeCall(call) {
   const v = call.args && Object.values(call.args).find((x) => typeof x === "string" && x.trim());
   const hint = v ? ` (${String(v).replace(/\s+/g, " ").trim().slice(0, 48)})` : "";
@@ -9458,7 +9713,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
           const m = this.reflexBuf.match(RESERVED_EVENT_MARKER) ?? this.reflexBuf.match(RESERVED_EVENT_OPENER);
           if (m) {
             this.fabricationCut = true;
-            log20.warn(`reflex fabricated a [task \u2026] event in its spoken stream \u2014 cutting it (kept ${m.index} chars)`);
+            log21.warn(`reflex fabricated a [task \u2026] event in its spoken stream \u2014 cutting it (kept ${m.index} chars)`);
             this.reflexBuf = this.reflexBuf.slice(0, Math.max(m.index, this.reflexForwarded));
             this.pumpReflex(true);
             return;
@@ -9550,7 +9805,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
       const at = from + ok;
       this.leakHit = true;
       this.leakCuts.push(leak.trim().slice(0, 40));
-      log20.warn(`reflex spoke its own analysis ("${leak.trim().slice(0, 40)}\u2026") \u2014 cut before TTS`);
+      log21.warn(`reflex spoke its own analysis ("${leak.trim().slice(0, 40)}\u2026") \u2014 cut before TTS`);
       this.notify("diag", "analysis_leak", { text: leak.trim().slice(0, 80), at: this.turnSpoken.trim() ? "mid_reply" : "before_speech" });
       const next = this.stepMarks.find((k) => k > at);
       if (next === void 0) {
@@ -9590,7 +9845,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
       this.notify("diag", "leak_judge", { text: s.slice(0, 80), p: Math.round(p * 100) / 100, ms: Math.round(performance.now() - t0) });
       return p >= LEAK_JUDGE_THRESHOLD;
     }, (e) => {
-      log20.warn(`leak judge failed \u2014 speaking the sentence: ${e.message}`);
+      log21.warn(`leak judge failed \u2014 speaking the sentence: ${e.message}`);
       return false;
     }).then((leak) => {
       clearTimeout(timer);
@@ -9624,7 +9879,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
       let i = t.length - 1;
       while (i >= this.turnBase && !(t[i].role === "assistant" && typeof t[i].content === "string" && t[i].content.includes(key))) i--;
       if (i < this.turnBase) {
-        log20.warn("analysis leak cut, but its text was not found in the transcript to scrub");
+        log21.warn("analysis leak cut, but its text was not found in the transcript to scrub");
         continue;
       }
       const m = t[i];
@@ -9704,7 +9959,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
     return {
       preToolUse: (call) => {
         if (this.spec?.state === "pending" && !_DuplexAgent.SPEC_SAFE_TOOLS.has(call.name)) {
-          log20.verbose(`speculation aborted: reflex called ${call.name} on unconfirmed input`);
+          log21.verbose(`speculation aborted: reflex called ${call.name} on unconfirmed input`);
           this.abortSpeculation();
           return { block: true, reason: "Speculative turn aborted." };
         }
@@ -9749,7 +10004,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
     try {
       await this.voice.send(reminder);
     } catch (e) {
-      log20.warn(`ack nudge failed: ${e instanceof Error ? e.message : e}`);
+      log21.warn(`ack nudge failed: ${e instanceof Error ? e.message : e}`);
     } finally {
       this.nudging = false;
       const i = this.voice.transcript.findIndex((m, k) => k >= base && m.role === "user" && m.content === reminder);
@@ -9801,7 +10056,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
       const accepted = this.offerOpen && this.parkedRedeliver.length > 0 && this.parkedRedeliver.every((p) => p.task === this.offer.task) && (isOfferAcceptance(content) || isTrivialBarge(content));
       const judge = accepted ? void 0 : this.options.bargeIntent;
       return (accepted ? Promise.resolve("resume") : judge ? judge(content).catch((e) => {
-        log20.warn(`bargeIntent judge failed \u2014 using the allowlist: ${e.message}`);
+        log21.warn(`bargeIntent judge failed \u2014 using the allowlist: ${e.message}`);
         return fallback();
       }) : Promise.resolve(fallback())).then((intent) => {
         this.notify("diag", "barge_intent", { intent, text: content.slice(0, 80) });
@@ -9997,7 +10252,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
       try {
         res = await this.voice.send(spec.text);
       } catch (e) {
-        log20.warn(`speculative turn failed: ${e instanceof Error ? e.message : e}`);
+        log21.warn(`speculative turn failed: ${e instanceof Error ? e.message : e}`);
       } finally {
         this.voice.options.signal = prevSignal;
       }
@@ -10011,7 +10266,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
       if (d === "abort") {
         if (this.voice.transcript.length > base) this.voice.transcript.length = base;
         this.speculativeAbortedCalls++;
-        log20.verbose(`speculation aborted (${this.speculativeAbortedCalls} total): "${spec.text.slice(0, 50)}"`);
+        log21.verbose(`speculation aborted (${this.speculativeAbortedCalls} total): "${spec.text.slice(0, 50)}"`);
         if (this.spec === spec) this.spec = void 0;
         return res ?? empty;
       }
@@ -10361,7 +10616,7 @@ Another agent just implemented the above. Independently check the CURRENT state
     this.notify("task_verify", `task ${id}: verifying`, { id });
     const cres = await new Agent(checkerOpts).run(checkBrief);
     if (cres.finishReason !== "stop") {
-      log20.warn(`task ${id}: verify inconclusive (${cres.finishReason})`);
+      log21.warn(`task ${id}: verify inconclusive (${cres.finishReason})`);
       this.notify("task_verify", `task ${id}: verify inconclusive (${cres.finishReason})`, { id, finishReason: cres.finishReason });
     }
     const sum = (a = 0, b = 0) => a + b;
@@ -10497,7 +10752,7 @@ Another agent just implemented the above. Independently check the CURRENT state
     rec.status = "done";
     rec.result = res.text;
     const incomplete = res.finishReason !== "stop" && res.finishReason !== "empty";
-    log20.verbose(`task ${id} done (${res.steps} steps${incomplete ? `, INCOMPLETE: ${res.finishReason}` : ""})`);
+    log21.verbose(`task ${id} done (${res.steps} steps${incomplete ? `, INCOMPLETE: ${res.finishReason}` : ""})`);
     this.notify("task_done", `task ${id} (${rec.label}) completed`, {
       id,
       text: res.text,
@@ -10531,14 +10786,14 @@ Another agent just implemented the above. Independently check the CURRENT state
   foldIfSuperseded(rec, note) {
     if (rec.deliveryParked !== "moved_on") return false;
     if (note.trim()) this.voice.transcript.push({ role: "assistant", content: note });
-    log20.verbose(`task ${rec.id} settled but superseded (${rec.status}) \u2014 folded into transcript, not voiced`);
+    log21.verbose(`task ${rec.id} settled but superseded (${rec.status}) \u2014 folded into transcript, not voiced`);
     return true;
   }
   failTask(rec, msg) {
     this.dropAsk(rec.id);
     rec.status = "error";
     rec.result = msg;
-    log20.warn(`task ${rec.id} failed: ${msg}`);
+    log21.warn(`task ${rec.id} failed: ${msg}`);
     this.notify("task_error", `task ${rec.id} (${rec.label}) failed: ${msg}`, { id: rec.id });
     if (this.foldIfSuperseded(rec, `The "${rec.label}" task failed: ${msg}`)) return;
     this.dropParked(rec);
@@ -10777,7 +11032,7 @@ Another agent just implemented the above. Independently check the CURRENT state
 // src/modelRouter.ts
 init_llm();
 init_logging();
-var log21 = forComponent("ModelRouter");
+var log22 = forComponent("ModelRouter");
 var ModelRouterOptions = class {
   classifier = jevClassifier();
   /** Capability tiers → model id (any provider). basic/standard run the main session; premium is only ever an offload. */
@@ -10861,10 +11116,10 @@ var ModelRouter = class {
       if (tier === "premium") d.offload = this.state.offload && (c.sameThread ?? 0) >= o.sameThreadAt ? "continue" : "fresh";
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
-      log21.warn(`classifier failed, falling back to standard: ${msg}`);
+      log22.warn(`classifier failed, falling back to standard: ${msg}`);
       d = { tier: "standard", model: o.models.standard, probs: {}, fallback: msg, classifyMs: Math.round(performance.now() - t0) };
     }
-    log21.info(`route ${d.tier}${d.offload ? `(${d.offload})` : ""} \xB7 argmax=${d.choice ?? "-"} \xB7 p=${JSON.stringify(d.probs)}${d.sameThread != null ? ` \xB7 same=${d.sameThread.toFixed(2)}` : ""} \xB7 ${d.classifyMs}ms`);
+    log22.info(`route ${d.tier}${d.offload ? `(${d.offload})` : ""} \xB7 argmax=${d.choice ?? "-"} \xB7 p=${JSON.stringify(d.probs)}${d.sameThread != null ? ` \xB7 same=${d.sameThread.toFixed(2)}` : ""} \xB7 ${d.classifyMs}ms`);
     return d;
   }
   /** Run one user turn on `agent` with routing. Returns a RunResult carrying `costUsd` + `routing`. */
@@ -10916,7 +11171,7 @@ ${text}`;
     const answer = res.text || `(premium sub-agent finished with no reply; finishReason=${res.finishReason})`;
     agent.transcript.push({ role: "user", content }, { role: "assistant", content: answer });
     this.state.offload = { messages: child.transcript, mainLen: agent.transcript.length, question: text };
-    log21.info(`offload ${cont ? "continue" : "fresh"} done \xB7 ${res.finishReason} \xB7 ${res.steps} steps`);
+    log22.info(`offload ${cont ? "continue" : "fresh"} done \xB7 ${res.finishReason} \xB7 ${res.steps} steps`);
     const costUsd = o.costOf(main2, briefUsage) + o.costOf(o.models.premium, res.usage);
     return { ...res, text: answer, messages: agent.transcript, usage: addUsage(briefUsage, res.usage), costUsd, routing: d };
   }
@@ -10932,7 +11187,7 @@ The request:
 ${text}`);
       return { text: r.text.trim() || text, usage: r.usage };
     } catch (e) {
-      log21.warn(`brief failed, sending the raw request: ${e instanceof Error ? e.message : String(e)}`);
+      log22.warn(`brief failed, sending the raw request: ${e instanceof Error ? e.message : String(e)}`);
       return { text };
     } finally {
       agent.transcript = snap;
@@ -10964,8 +11219,8 @@ async function loadJev(opts) {
   const env = { ...process.env };
   const file = opts.envFile ?? process.env.AGENTX_JEV_ENV;
   if (file) {
-    const { readFileSync: readFileSync10 } = await import("fs");
-    for (const l of readFileSync10(file, "utf8").split("\n")) {
+    const { readFileSync: readFileSync11 } = await import("fs");
+    for (const l of readFileSync11(file, "utf8").split("\n")) {
       const m = l.match(/^\s*([A-Z0-9_]+)\s*=\s*(.*?)\s*$/);
       if (m && !env[m[1]]) env[m[1]] = m[2].replace(/^['"]|['"]$/g, "");
     }
@@ -10977,7 +11232,7 @@ async function jevAvailable(opts = {}) {
     const { env } = await loadJev(opts);
     return JEV_KEYS.some((k) => env[k]?.trim());
   } catch (e) {
-    log21.debug(`jev unavailable: ${e instanceof Error ? e.message : String(e)}`);
+    log22.debug(`jev unavailable: ${e instanceof Error ? e.message : String(e)}`);
     return false;
   }
 }
@@ -11204,8 +11459,8 @@ import { MemFilesystem as MemFilesystem3, IndexedDbFilesystem, CommandExecutor a
 // src/mcp.client.ts
 init_logging();
 import { spawn } from "child_process";
-import { createHash } from "crypto";
-var log22 = forComponent("mcp");
+import { createHash as createHash2 } from "crypto";
+var log23 = forComponent("mcp");
 var PROTOCOL_VERSION = "2025-06-18";
 var DEFAULT_TIMEOUT_MS = 3e4;
 var DEFAULT_CALL_TIMEOUT_MS = 30 * 6e4;
@@ -11235,7 +11490,7 @@ var StdioTransport = class {
     proc.stdout.setEncoding("utf8");
     proc.stdout.on("data", (chunk) => this.onData(chunk));
     proc.stderr.setEncoding("utf8");
-    proc.stderr.on("data", (chunk) => log22.debug(`[${command}] stderr:`, chunk.trimEnd()));
+    proc.stderr.on("data", (chunk) => log23.debug(`[${command}] stderr:`, chunk.trimEnd()));
     proc.on("exit", (code) => this.failAll(new Error(`MCP server "${command}" exited (code ${code})`)));
     proc.on("error", (e) => this.failAll(e instanceof Error ? e : new Error(String(e))));
   }
@@ -11249,7 +11504,7 @@ var StdioTransport = class {
       try {
         this.dispatch(JSON.parse(line));
       } catch (e) {
-        log22.debug("dropping non-JSON line from MCP server:", line, e);
+        log23.debug("dropping non-JSON line from MCP server:", line, e);
       }
     }
   }
@@ -11259,7 +11514,7 @@ var StdioTransport = class {
       try {
         p2?.onProgress?.(msg.params ?? {});
       } catch (e) {
-        log22.debug("onProgress handler threw", e);
+        log23.debug("onProgress handler threw", e);
       }
       return;
     }
@@ -11297,7 +11552,7 @@ var StdioTransport = class {
       const onAbort = () => {
         if (!this.pending.delete(id)) return;
         clearTimeout(timer);
-        this.notify("notifications/cancelled", { requestId: id, reason: String(signal?.reason?.message ?? "cancelled") }).catch((e) => log22.debug("cancel notify failed", e));
+        this.notify("notifications/cancelled", { requestId: id, reason: String(signal?.reason?.message ?? "cancelled") }).catch((e) => log23.debug("cancel notify failed", e));
         reject(abortError(signal));
       };
       const done = () => signal?.removeEventListener("abort", onAbort);
@@ -11321,7 +11576,7 @@ var StdioTransport = class {
     try {
       this.proc?.stdin?.end();
     } catch (e) {
-      log22.debug("stdin end failed", e);
+      log23.debug("stdin end failed", e);
     }
     this.proc?.kill();
   }
@@ -11356,7 +11611,7 @@ var HttpTransport = class {
       return await this.post({ jsonrpc: "2.0", id, method, params: opts.onProgress ? withProgressToken(params, id) : params }, false, signal, opts.onProgress);
     } catch (e) {
       if (opts.signal?.aborted) {
-        void this.notify("notifications/cancelled", { requestId: id, reason: String(opts.signal.reason?.message ?? "cancelled") }).catch((err2) => log22.debug("cancel notify failed", err2));
+        void this.notify("notifications/cancelled", { requestId: id, reason: String(opts.signal.reason?.message ?? "cancelled") }).catch((err2) => log23.debug("cancel notify failed", err2));
         throw abortError(opts.signal);
       }
       throw e;
@@ -11399,7 +11654,7 @@ function sseMessage(line) {
   try {
     return JSON.parse(trimmed.slice(5).trim());
   } catch (e) {
-    log22.debug("skipping unparseable SSE data line", e);
+    log23.debug("skipping unparseable SSE data line", e);
     return void 0;
   }
 }
@@ -11409,7 +11664,7 @@ async function readSseResponse(resp, id, onProgress) {
       try {
         onProgress?.(obj.params ?? {});
       } catch (e) {
-        log22.debug("onProgress handler threw", e);
+        log23.debug("onProgress handler threw", e);
       }
       return void 0;
     }
@@ -11508,7 +11763,7 @@ async function mountWithDeadline(name, cfg, mountTimeoutMs) {
       return { name, client, tools, specs, serverInfo: init?.serverInfo, config: cfg };
     })(), mountTimeoutMs, name);
   } catch (e) {
-    await client.close().catch((err2) => log22.debug(`close after failed mount of "${name}": ${err2}`));
+    await client.close().catch((err2) => log23.debug(`close after failed mount of "${name}": ${err2}`));
     throw e;
   }
 }
@@ -11519,15 +11774,15 @@ function validEntries(servers) {
   return Object.entries(servers).filter(([name, cfg]) => {
     if (!cfg || cfg.disabled) return false;
     if (!cfg.command && !cfg.url) {
-      log22.warn(`MCP server "${name}" needs a command (stdio) or url (http) \u2014 skipping`);
+      log23.warn(`MCP server "${name}" needs a command (stdio) or url (http) \u2014 skipping`);
       return false;
     }
     return true;
   });
 }
 function logMountFailure(name, e) {
-  if (e instanceof McpAuthError) log22.warn(`MCP "${name}" needs-auth: HTTP ${e.status} \u2014 set bearerToken or headers in its config; skipping`);
-  else log22.error(`MCP server "${name}" failed to mount: ${e?.message ?? e}`);
+  if (e instanceof McpAuthError) log23.warn(`MCP "${name}" needs-auth: HTTP ${e.status} \u2014 set bearerToken or headers in its config; skipping`);
+  else log23.error(`MCP server "${name}" failed to mount: ${e?.message ?? e}`);
 }
 async function mountMcpServers(servers = {}, opts = {}) {
   const entries = validEntries(servers);
@@ -11537,7 +11792,7 @@ async function mountMcpServers(servers = {}, opts = {}) {
     const name = entries[i][0];
     if (r.status === "fulfilled") {
       out.push(r.value);
-      log22.debug(`MCP "${name}" mounted \u2014 ${r.value.tools.length} tool(s)${r.value.serverInfo?.name ? ` from ${r.value.serverInfo.name}` : ""}`);
+      log23.debug(`MCP "${name}" mounted \u2014 ${r.value.tools.length} tool(s)${r.value.serverInfo?.name ? ` from ${r.value.serverInfo.name}` : ""}`);
     } else logMountFailure(name, r.reason);
   });
   return out;
@@ -11577,7 +11832,7 @@ var McpPool = class {
     const prev = this.warm.get(key);
     if (prev) {
       clearTimeout(prev.timer);
-      if (prev.client !== client) void prev.client.close().catch((err2) => log22.debug(`warm-pool replace close failed: ${err2}`));
+      if (prev.client !== client) void prev.client.close().catch((err2) => log23.debug(`warm-pool replace close failed: ${err2}`));
     }
     const e = { client, timer: void 0 };
     this.warm.set(key, e);
@@ -11594,7 +11849,7 @@ var McpPool = class {
     const e = this.warm.get(key);
     if (!e) return;
     this.warm.delete(key);
-    await e.client.close().catch((err2) => log22.debug(`warm-pool evict close failed: ${err2}`));
+    await e.client.close().catch((err2) => log23.debug(`warm-pool evict close failed: ${err2}`));
   }
   async closeAll() {
     for (const e of this.warm.values()) {
@@ -11610,8 +11865,8 @@ var defaultPool = new McpPool();
 
 // cli/mcpOAuth.ts
 import { createServer } from "http";
-import { randomBytes as randomBytes2, createHash as createHash2 } from "crypto";
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, existsSync } from "fs";
+import { randomBytes as randomBytes2, createHash as createHash3 } from "crypto";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync3, existsSync } from "fs";
 import { dirname as dirname2 } from "path";
 var McpOAuthOptions = class {
   /** Where to persist tokens. Mode 0600. */
@@ -11639,14 +11894,14 @@ var McpOAuth = class {
   // -- store I/O ----------------------------------------------------------------
   load() {
     try {
-      return existsSync(this.options.storePath) ? JSON.parse(readFileSync3(this.options.storePath, "utf8")) : {};
+      return existsSync(this.options.storePath) ? JSON.parse(readFileSync4(this.options.storePath, "utf8")) : {};
     } catch {
       return {};
     }
   }
   save(store) {
     mkdirSync3(dirname2(this.options.storePath), { recursive: true });
-    writeFileSync3(this.options.storePath, JSON.stringify(store, null, 2), { mode: 384 });
+    writeFileSync4(this.options.storePath, JSON.stringify(store, null, 2), { mode: 384 });
   }
   // -- ATTENDED: one-time authorization ----------------------------------------
   /** Run the authorization-code + PKCE flow and persist the resulting tokens for `serverUrl`. */
@@ -11654,7 +11909,7 @@ var McpOAuth = class {
     const meta = await this.discover(serverUrl);
     const clientId = this.options.clientId ?? await this.registerClient(meta, serverUrl);
     const verifier = b64url(randomBytes2(32));
-    const challenge = b64url(createHash2("sha256").update(verifier).digest());
+    const challenge = b64url(createHash3("sha256").update(verifier).digest());
     const state = b64url(randomBytes2(16));
     const { code, redirectUri } = await this.captureCode(meta.authorization_endpoint, clientId, challenge, state);
     const tok = await this.exchange(meta.token_endpoint, {
@@ -11804,15 +12059,15 @@ function defaultOpenBrowser(url) {
 // cli/core.ts
 import { randomUUID } from "crypto";
 import { execFile as execFile2 } from "child_process";
-import { resolve as resolve2, basename, join as join5 } from "path";
+import { resolve as resolve2, basename, join as join6 } from "path";
 import { existsSync as existsSync3, mkdirSync as mkdirSync4 } from "fs";
-import { platform, arch, release, userInfo, homedir as homedir2, tmpdir } from "os";
+import { platform, arch, release, userInfo, homedir as homedir2, tmpdir as tmpdir2 } from "os";
 init_tools_shell();
 
 // src/tools.notify.ts
 init_logging();
 import { execFile } from "child_process";
-var log24 = forComponent("notify");
+var log25 = forComponent("notify");
 function makeNotifyTool(opts = {}) {
   const platform2 = opts.platform ?? process.platform;
   const run = opts.exec ?? execFile;
@@ -11836,7 +12091,7 @@ function makeNotifyTool(opts = {}) {
       return new Promise((resolve5) => {
         run(argv[0], argv[1], { timeout: 5e3 }, (e) => {
           if (e) {
-            log24.debug("notification failed", e);
+            log25.debug("notification failed", e);
             resolve5(`Notification failed: ${e.message}`);
           } else resolve5("Notification shown.");
         });
@@ -11850,9 +12105,9 @@ import { BodDB as BodDB2 } from "@bod.ee/db";
 
 // cli/util.ts
 init_logging();
-import { existsSync as existsSync2, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync5 } from "fs";
 import { homedir } from "os";
-var log25 = forComponent("cli-util");
+var log26 = forComponent("cli-util");
 function dotDirs(base, sub, opts = {}) {
   const home = opts.home ?? homedir();
   const dirs = [`${base}/.agent/${sub}`, `${base}/.claude/${sub}`, `${home}/.agent/${sub}`, `${home}/.claude/${sub}`];
@@ -11869,7 +12124,7 @@ function parseJson(text, fallback, what = "json") {
   try {
     return JSON.parse(text);
   } catch (e) {
-    log25.debug(`parseJson(${what}) failed: ${e.message}`);
+    log26.debug(`parseJson(${what}) failed: ${e.message}`);
     return fallback;
   }
 }
@@ -11877,9 +12132,9 @@ function readJsonFile(path, fallback) {
   if (!existsSync2(path)) return fallback;
   let text;
   try {
-    text = readFileSync4(path, "utf8");
+    text = readFileSync5(path, "utf8");
   } catch (e) {
-    log25.debug(`readJsonFile(${path}) unreadable: ${e.message}`);
+    log26.debug(`readJsonFile(${path}) unreadable: ${e.message}`);
     return fallback;
   }
   return parseJson(text, fallback, path);
@@ -11994,7 +12249,7 @@ async function buildAgent(o) {
   } else if (o.boddb) {
     const root = resolve2(o.boddb);
     mkdirSync4(root, { recursive: true });
-    const db = new BodDB2({ path: join5(root, "meta.db"), sweepInterval: 0, vfs: { storageRoot: join5(root, "files") } });
+    const db = new BodDB2({ path: join6(root, "meta.db"), sweepInterval: 0, vfs: { storageRoot: join6(root, "files") } });
     const bod = new BodDbFilesystem(db);
     const firstRun = (await bod.readDir("/").catch(() => [])).length === 0;
     await mkdirp(bod, cwd);
@@ -12061,7 +12316,7 @@ Reference files in them by their mount path (the left side).`;
     });
     realShell = [makeRealShellTool({ cwd, registry: jobs, osSandbox: o.osSandbox, jobsSurviveRun: o.singleRun !== true }), ...makeShellJobTools(jobs)];
   }
-  const scratchDir = o.scratch ? o.scratchDir ?? (virtual ? `${cwd}/.agent/scratch` : `${tmpdir()}/agentx-scratch-${process.pid}`) : void 0;
+  const scratchDir = o.scratch ? o.scratchDir ?? (virtual ? `${cwd}/.agent/scratch` : `${tmpdir2()}/agentx-scratch-${process.pid}`) : void 0;
   const scratch = scratchDir ? new Scratch(fs, { dir: scratchDir }) : void 0;
   return agentRef.agent = new Agent({
     ai: o.ai,
@@ -12154,6 +12409,7 @@ The filesystem root '/' is the real machine root \u2014 you have full filesystem
     keepToolOutputs: o.keepToolOutputs ?? 8,
     ...o.maxContextTokens != null ? { maxContextTokens: o.maxContextTokens } : {},
     ...o.contextWindow ? { contextWindow: o.contextWindow } : {},
+    ...o.imageInput ? { imageInput: o.imageInput } : {},
     ...o.browserTrim ? { browserTrim: o.browserTrim } : {}
   });
 }
@@ -12173,12 +12429,12 @@ var trunc = (s, n) => (s == null ? "" : String(s).length > n ? String(s).slice(0
 
 // cli/voice.ts
 init_logging();
-import { spawn as spawn2, spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync4, mkdirSync as mkdirSync5, readFileSync as readFileSync5, statSync as statSync4 } from "fs";
+import { spawn as spawn2, spawnSync as spawnSync3 } from "child_process";
+import { existsSync as existsSync4, mkdirSync as mkdirSync5, readFileSync as readFileSync6, statSync as statSync5 } from "fs";
 import { homedir as homedir3 } from "os";
-import { dirname as dirname3, join as join6 } from "path";
+import { dirname as dirname3, join as join7 } from "path";
 import { fileURLToPath } from "url";
-var log26 = forComponent("VoiceIO");
+var log27 = forComponent("VoiceIO");
 var now3 = () => performance.now();
 var Player = class {
   proc = null;
@@ -12192,7 +12448,7 @@ var Player = class {
       ["-loglevel", "quiet", "-nodisp", "-fflags", "nobuffer", "-flags", "low_delay", "-probesize", "32", "-f", "s16le", "-ar", String(TTS_SAMPLE_RATE), "-ch_layout", "mono", "-i", "-"],
       { stdio: ["pipe", "ignore", "ignore"] }
     );
-    this.proc.on("error", (e) => log26.warn(`ffplay error: ${e.message}`));
+    this.proc.on("error", (e) => log27.warn(`ffplay error: ${e.message}`));
     this.proc.stdin.on("error", () => {
     });
     this.bytesWritten = 0;
@@ -12219,10 +12475,10 @@ var Player = class {
     this.proc = null;
   }
 };
-var nativeDir = () => join6(dirname3(fileURLToPath(import.meta.url)), "native");
+var nativeDir = () => join7(dirname3(fileURLToPath(import.meta.url)), "native");
 function detectFfmpegMic() {
   if (process.env.MIC_DEVICE) return process.env.MIC_DEVICE;
-  const r = spawnSync2("ffmpeg", ["-f", "avfoundation", "-list_devices", "true", "-i", ""], { encoding: "utf8" });
+  const r = spawnSync3("ffmpeg", ["-f", "avfoundation", "-list_devices", "true", "-i", ""], { encoding: "utf8" });
   if (r.error?.code === "ENOENT") throw new Error("ffmpeg not installed \u2014 run `brew install ffmpeg` to enable voice");
   if (r.error) throw new Error(`ffmpeg failed to run (${r.error.message}) \u2014 likely a wrong-arch binary; run \`brew reinstall ffmpeg\``);
   const out = r.stderr ?? "";
@@ -12230,16 +12486,16 @@ function detectFfmpegMic() {
   const devices = [...audio.matchAll(/\[(\d+)\] (.+)/g)].map(([, idx, name]) => ({ idx, name: name.trim() }));
   const mic = devices.find((d) => /microphone|built-in/i.test(d.name) && !/teams|blackhole|loopback/i.test(d.name)) ?? devices[0];
   if (!mic) throw new Error("no audio input device found");
-  log26.debug(`ffmpeg mic: [${mic.idx}] ${mic.name}`);
+  log27.debug(`ffmpeg mic: [${mic.idx}] ${mic.name}`);
   return `:${mic.idx}`;
 }
 function detectedInputDevice() {
   if (process.platform !== "darwin") return null;
   let name = "";
-  if (spawnSync2("which", ["SwitchAudioSource"]).status === 0) {
-    name = (spawnSync2("SwitchAudioSource", ["-c", "-t", "input"], { encoding: "utf8" }).stdout || "").trim();
+  if (spawnSync3("which", ["SwitchAudioSource"]).status === 0) {
+    name = (spawnSync3("SwitchAudioSource", ["-c", "-t", "input"], { encoding: "utf8" }).stdout || "").trim();
   } else {
-    const out = spawnSync2("system_profiler", ["SPAudioDataType"], { encoding: "utf8" }).stdout || "";
+    const out = spawnSync3("system_profiler", ["SPAudioDataType"], { encoding: "utf8" }).stdout || "";
     let last = "";
     for (const ln of out.split("\n")) {
       const hdr = ln.match(/^\s{6,}(\S.*?):\s*$/);
@@ -12258,23 +12514,23 @@ function detectedInputDevice() {
 }
 function resolveAecBinary() {
   if (process.env.MIC_AEC === "0" || process.platform !== "darwin") return null;
-  const src = join6(nativeDir(), "mic-aec.swift");
-  const plist = join6(nativeDir(), "Info.plist");
+  const src = join7(nativeDir(), "mic-aec.swift");
+  const plist = join7(nativeDir(), "Info.plist");
   if (!existsSync4(src)) return null;
-  const cacheDir = join6(homedir3(), ".agent", "cache");
-  const bin = join6(cacheDir, "mic-aec");
-  if (existsSync4(bin) && statSync4(bin).mtimeMs >= statSync4(src).mtimeMs) return bin;
-  if (spawnSync2("which", ["swiftc"]).status !== 0) return null;
+  const cacheDir = join7(homedir3(), ".agent", "cache");
+  const bin = join7(cacheDir, "mic-aec");
+  if (existsSync4(bin) && statSync5(bin).mtimeMs >= statSync5(src).mtimeMs) return bin;
+  if (spawnSync3("which", ["swiftc"]).status !== 0) return null;
   mkdirSync5(cacheDir, { recursive: true });
-  log26.info("compiling AEC mic helper (first run)\u2026");
-  const build = spawnSync2("swiftc", ["-O", "-o", bin, src, "-Xlinker", "-sectcreate", "-Xlinker", "__TEXT", "-Xlinker", "__info_plist", "-Xlinker", plist], { encoding: "utf8" });
+  log27.info("compiling AEC mic helper (first run)\u2026");
+  const build = spawnSync3("swiftc", ["-O", "-o", bin, src, "-Xlinker", "-sectcreate", "-Xlinker", "__TEXT", "-Xlinker", "__info_plist", "-Xlinker", plist], { encoding: "utf8" });
   if (build.status !== 0) {
-    log26.warn(`AEC build failed: ${build.stderr?.slice(0, 400)}`);
+    log27.warn(`AEC build failed: ${build.stderr?.slice(0, 400)}`);
     return null;
   }
-  const sign = spawnSync2("codesign", ["-fs", "-", bin], { encoding: "utf8" });
+  const sign = spawnSync3("codesign", ["-fs", "-", bin], { encoding: "utf8" });
   if (sign.status !== 0) {
-    log26.warn(`codesign failed: ${sign.stderr?.slice(0, 200)}`);
+    log27.warn(`codesign failed: ${sign.stderr?.slice(0, 200)}`);
     return null;
   }
   return bin;
@@ -12282,14 +12538,14 @@ function resolveAecBinary() {
 function openMicSettings() {
   if (process.platform !== "darwin") return;
   try {
-    spawnSync2("open", ["x-apple.systempreferences:com.apple.preference.security?Privacy_Microphone"]);
+    spawnSync3("open", ["x-apple.systempreferences:com.apple.preference.security?Privacy_Microphone"]);
   } catch {
   }
 }
 function micPermissionStatus() {
   const bin = resolveAecBinary();
   if (!bin) return null;
-  const r = spawnSync2(bin, ["--check-mic"], { encoding: "utf8" });
+  const r = spawnSync3(bin, ["--check-mic"], { encoding: "utf8" });
   const out = (r.stdout ?? "").trim();
   if (out === "authorized") return "authorized";
   if (out === "denied" || out === "restricted") return "denied";
@@ -12299,7 +12555,7 @@ function micPermissionStatus() {
 function aecUnavailableHint() {
   if (process.env.MIC_AEC === "0" || process.platform !== "darwin") return null;
   if (resolveAecBinary()) return null;
-  if (spawnSync2("which", ["swiftc"]).status !== 0) return "install Xcode CLI tools (`xcode-select --install`) for echo cancellation";
+  if (spawnSync3("which", ["swiftc"]).status !== 0) return "install Xcode CLI tools (`xcode-select --install`) for echo cancellation";
   return null;
 }
 var NodeMicSource = class {
@@ -12315,17 +12571,17 @@ var NodeMicSource = class {
     if (this.bin) {
       this.proc = spawn2(this.bin, [], { stdio: ["ignore", "pipe", "ignore"] });
     } else {
-      if (spawnSync2("which", ["ffmpeg"]).status !== 0) throw new Error("voice I/O unavailable: no AEC helper and no ffmpeg on PATH");
-      log26.info("mic: raw capture (no AEC) \u2014 echo handled heuristically; headphones recommended");
+      if (spawnSync3("which", ["ffmpeg"]).status !== 0) throw new Error("voice I/O unavailable: no AEC helper and no ffmpeg on PATH");
+      log27.info("mic: raw capture (no AEC) \u2014 echo handled heuristically; headphones recommended");
       this.proc = spawn2(
         "ffmpeg",
         ["-loglevel", "error", "-f", "avfoundation", "-i", detectFfmpegMic(), "-ar", String(STT_SAMPLE_RATE), "-ac", "1", "-f", "s16le", "-"],
         { stdio: ["ignore", "pipe", "pipe"] }
       );
-      this.proc.stderr.on("data", (d) => log26.warn(`ffmpeg: ${String(d).trim()}`));
+      this.proc.stderr.on("data", (d) => log27.warn(`ffmpeg: ${String(d).trim()}`));
     }
     this.proc.on("exit", (c) => {
-      if (c && !this.stopped) log26.error(`mic capture exited (${c}) \u2014 check mic permission / MIC_DEVICE / MIC_AEC=0`);
+      if (c && !this.stopped) log27.error(`mic capture exited (${c}) \u2014 check mic permission / MIC_DEVICE / MIC_AEC=0`);
     });
     this.proc.stdout.on("data", (chunk) => onChunk(chunk));
   }
@@ -12391,7 +12647,7 @@ var AecDuplexAudio = class {
     this.proc.stdin.on("error", () => {
     });
     this.proc.on("exit", (c) => {
-      if (c && !this.stopped) log26.error(`aec duplex audio exited (${c}) \u2014 check mic permission / MIC_AEC=0`);
+      if (c && !this.stopped) log27.error(`aec duplex audio exited (${c}) \u2014 check mic permission / MIC_AEC=0`);
     });
     this.proc.stdout.on("data", (chunk) => {
       this.gotChunk = true;
@@ -12407,7 +12663,7 @@ var AecDuplexAudio = class {
             openMicSettings();
             this.onFatal?.("microphone permission denied \u2014 enable it in System Settings \u2192 Privacy & Security \u2192 Microphone for your terminal, then restart it");
           }
-        } else log26.debug(`mic-aec: ${s}`);
+        } else log27.debug(`mic-aec: ${s}`);
       }
     });
     if (!this.noVpio && !this.triedFallback) {
@@ -12416,7 +12672,7 @@ var AecDuplexAudio = class {
         this.triedFallback = true;
         this.noVpio = true;
         this._aec = false;
-        log26.warn("mic-aec: VPIO delivered no audio in 2.5s \u2014 falling back to non-VPIO capture (no AEC \u2192 half-duplex, no barge-in)");
+        log27.warn("mic-aec: VPIO delivered no audio in 2.5s \u2014 falling back to non-VPIO capture (no AEC \u2192 half-duplex, no barge-in)");
         this.onDegrade?.();
         this.killProc();
         this.spawnHelper();
@@ -12587,7 +12843,7 @@ function bindAckInstinct(v, instinct) {
       if (ev.kind === "ack_fired") instinct.ackOutcome(String(ev.phrase));
       else if (ev.kind === "ack_skipped" || ev.kind === "ack_cancelled") instinct.ackOutcome(null);
     } catch (e) {
-      log26.warn(`ack outcome tap failed: ${e instanceof Error ? e.message : e}`);
+      log27.warn(`ack outcome tap failed: ${e instanceof Error ? e.message : e}`);
     }
     onDiag(ev);
   };
@@ -12665,7 +12921,7 @@ function fakeVoiceParts(uttFile) {
       timer = setInterval(() => {
         let buf;
         try {
-          buf = readFileSync5(uttFile, "utf8");
+          buf = readFileSync6(uttFile, "utf8");
         } catch {
           return;
         }
@@ -12708,7 +12964,7 @@ function fakeVoiceParts(uttFile) {
 init_logging();
 import { appendFile, mkdirSync as mkdirSync6 } from "fs";
 import { dirname as dirname4 } from "path";
-var log27 = forComponent("VoiceDiag");
+var log28 = forComponent("VoiceDiag");
 var JsonlDiagSink = class {
   constructor(path) {
     this.path = path;
@@ -12749,7 +13005,7 @@ var JsonlDiagSink = class {
   disable(e) {
     this.disabled = true;
     this.queue.length = 0;
-    log27.debug(`voice diag sink disabled (${this.path}): ${e instanceof Error ? e.message : e}`);
+    log28.debug(`voice diag sink disabled (${this.path}): ${e instanceof Error ? e.message : e}`);
   }
   /** True once a failure permanently disabled the sink (tests/inspection). */
   get isDisabled() {
@@ -12763,13 +13019,13 @@ var JsonlDiagSink = class {
 
 // cli/config.ts
 import { homedir as homedir4 } from "os";
-import { existsSync as existsSync5, readFileSync as readFileSync6 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync7 } from "fs";
+import { join as join8 } from "path";
 import { pathToFileURL } from "url";
 var FILES = ["config.ts", "config.js", "config.mjs", "config.json"];
 async function loadFrom(dir) {
   for (const f of FILES) {
-    const p = join7(dir, ".agent", f);
+    const p = join8(dir, ".agent", f);
     if (!existsSync5(p)) continue;
     try {
       const mod = await import(pathToFileURL(p).href, f.endsWith(".json") ? { with: { type: "json" } } : void 0);
@@ -12782,10 +13038,10 @@ async function loadFrom(dir) {
   return {};
 }
 function loadSettings(dir) {
-  const p = join7(dir, ".agent", "settings.json");
+  const p = join8(dir, ".agent", "settings.json");
   if (!existsSync5(p)) return {};
   try {
-    const raw = JSON.parse(readFileSync6(p, "utf8"));
+    const raw = JSON.parse(readFileSync7(p, "utf8"));
     const cfg = {};
     if (raw.mcpServers && typeof raw.mcpServers === "object") cfg.mcpServers = raw.mcpServers;
     if (raw.permissions && typeof raw.permissions === "object") cfg.permissions = raw.permissions;
@@ -12818,8 +13074,8 @@ async function loadConfig(cwd) {
 }
 
 // cli/hooks-config.ts
-import { spawnSync as spawnSync3 } from "child_process";
-var log28 = forComponent("hooks");
+import { spawnSync as spawnSync4 } from "child_process";
+var log29 = forComponent("hooks");
 var escapeRegex = (s) => s.replace(/[.+^${}()|[\]\\]/g, "\\$&");
 function ruleMatches(rule, toolName) {
   if (!rule.tool || rule.tool === "*") return true;
@@ -12828,7 +13084,7 @@ function ruleMatches(rule, toolName) {
 }
 function runCmd(rule, env) {
   try {
-    const r = spawnSync3(rule.command, {
+    const r = spawnSync4(rule.command, {
       shell: true,
       encoding: "utf8",
       timeout: rule.timeoutMs ?? 1e4,
@@ -12836,7 +13092,7 @@ function runCmd(rule, env) {
     });
     return { code: r.status ?? 1, out: ((r.stdout ?? "") + (r.stderr ?? "")).trim() };
   } catch (e) {
-    log28.debug(`hook command failed: ${rule.command}`, e);
+    log29.debug(`hook command failed: ${rule.command}`, e);
     return { code: 1, out: String(e?.message ?? e) };
   }
 }
@@ -12940,15 +13196,15 @@ function formatDiff(ops, opts = {}) {
 }
 
 // cli/session.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync4, readdirSync, renameSync, symlinkSync as symlinkSync2, unlinkSync, readlinkSync, statSync as statSync5 } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync7, readFileSync as readFileSync8, writeFileSync as writeFileSync5, readdirSync, renameSync, symlinkSync as symlinkSync2, unlinkSync, readlinkSync, statSync as statSync6 } from "fs";
 import { homedir as homedir5 } from "os";
-import { join as join8 } from "path";
-var log29 = forComponent("session");
-var globalDir = () => join8(homedir5(), ".agent", "sessions");
+import { join as join9 } from "path";
+var log30 = forComponent("session");
+var globalDir = () => join9(homedir5(), ".agent", "sessions");
 var SessionStore = class {
   dir;
   constructor(cwd) {
-    this.dir = join8(cwd, ".agent", "sessions");
+    this.dir = join9(cwd, ".agent", "sessions");
   }
   /** Sortable, human-readable id: `YYYYMMDD-HHMMSS-<folder>`. */
   newId(now4 = Date.now(), cwd) {
@@ -12956,10 +13212,10 @@ var SessionStore = class {
     const p = (n, w = 2) => String(n).padStart(w, "0");
     const slug2 = (cwd ?? process.cwd()).split("/").pop()?.replace(/[^A-Za-z0-9_-]/g, "") || "session";
     let id = `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}-${slug2}`;
-    if (existsSync6(this.dir) && existsSync6(join8(this.dir, `${id}.json`))) {
+    if (existsSync6(this.dir) && existsSync6(join9(this.dir, `${id}.json`))) {
       for (let i = 2; i <= 99; i++) {
         const c = `${id}-${i}`;
-        if (!existsSync6(join8(this.dir, `${c}.json`))) {
+        if (!existsSync6(join9(this.dir, `${c}.json`))) {
           id = c;
           break;
         }
@@ -12974,29 +13230,29 @@ var SessionStore = class {
   save(data) {
     if (!this.safeId(data.meta.id)) throw new Error(`unsafe session id: ${data.meta.id}`);
     if (!existsSync6(this.dir)) mkdirSync7(this.dir, { recursive: true });
-    const path = join8(this.dir, `${data.meta.id}.json`);
+    const path = join9(this.dir, `${data.meta.id}.json`);
     const tmp = `${path}.${process.pid}.tmp`;
-    writeFileSync4(tmp, JSON.stringify(data));
+    writeFileSync5(tmp, JSON.stringify(data));
     renameSync(tmp, path);
     try {
       const gd = globalDir();
       if (!existsSync6(gd)) mkdirSync7(gd, { recursive: true });
-      const link2 = join8(gd, `${data.meta.id}.json`);
+      const link2 = join9(gd, `${data.meta.id}.json`);
       if (!existsSync6(link2)) symlinkSync2(path, link2);
     } catch {
     }
   }
   load(id) {
     if (!this.safeId(id)) {
-      log29.debug(`rejecting unsafe session id: ${id}`);
+      log30.debug(`rejecting unsafe session id: ${id}`);
       return void 0;
     }
-    const path = join8(this.dir, `${id}.json`);
+    const path = join9(this.dir, `${id}.json`);
     if (!existsSync6(path)) return void 0;
     try {
-      return JSON.parse(readFileSync7(path, "utf8"));
+      return JSON.parse(readFileSync8(path, "utf8"));
     } catch (e) {
-      log29.debug(`unreadable session ${id} \u2014 ignoring`, e);
+      log30.debug(`unreadable session ${id} \u2014 ignoring`, e);
       return void 0;
     }
   }
@@ -13007,9 +13263,9 @@ var SessionStore = class {
     for (const f of readdirSync(this.dir)) {
       if (!f.endsWith(".json")) continue;
       try {
-        metas.push(JSON.parse(readFileSync7(join8(this.dir, f), "utf8")).meta);
+        metas.push(JSON.parse(readFileSync8(join9(this.dir, f), "utf8")).meta);
       } catch (e) {
-        log29.debug(`skipping unreadable session file ${f}`, e);
+        log30.debug(`skipping unreadable session file ${f}`, e);
       }
     }
     return metas.sort((a, b) => b.updated - a.updated);
@@ -13022,7 +13278,7 @@ var SessionStore = class {
     for (const f of readdirSync(this.dir)) {
       if (!f.endsWith(".json")) continue;
       try {
-        const st = statSync5(join8(this.dir, f));
+        const st = statSync6(join9(this.dir, f));
         out.push({ id: f.slice(0, -5), mtime: st.mtimeMs, size: st.size });
       } catch {
       }
@@ -13041,11 +13297,11 @@ var SessionStore = class {
 function globalSessionLoad(idOrPrefix) {
   const gd = globalDir();
   if (!existsSync6(gd)) return void 0;
-  const exact = join8(gd, `${idOrPrefix}.json`);
+  const exact = join9(gd, `${idOrPrefix}.json`);
   if (existsSync6(exact)) {
     try {
       const target = readlinkSync(exact);
-      return JSON.parse(readFileSync7(target, "utf8"));
+      return JSON.parse(readFileSync8(target, "utf8"));
     } catch {
       return void 0;
     }
@@ -13055,8 +13311,8 @@ function globalSessionLoad(idOrPrefix) {
       if (!f.endsWith(".json")) continue;
       const base = f.slice(0, -5);
       if (base.includes(idOrPrefix) || base.endsWith(idOrPrefix)) {
-        const target = readlinkSync(join8(gd, f));
-        return JSON.parse(readFileSync7(target, "utf8"));
+        const target = readlinkSync(join9(gd, f));
+        return JSON.parse(readFileSync8(target, "utf8"));
       }
     }
   } catch {
@@ -13070,15 +13326,15 @@ function globalSessionList() {
   for (const f of readdirSync(gd)) {
     if (!f.endsWith(".json")) continue;
     try {
-      const target = readlinkSync(join8(gd, f));
+      const target = readlinkSync(join9(gd, f));
       if (!existsSync6(target)) {
         try {
-          unlinkSync(join8(gd, f));
+          unlinkSync(join9(gd, f));
         } catch {
         }
         continue;
       }
-      metas.push(JSON.parse(readFileSync7(target, "utf8")).meta);
+      metas.push(JSON.parse(readFileSync8(target, "utf8")).meta);
     } catch {
     }
   }
@@ -13245,10 +13501,10 @@ ${formatDiff(ops)}`);
 // cli/gitCheckpoints.ts
 import { execFile as execFile3 } from "child_process";
 import { promisify } from "util";
-import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync8 } from "fs";
+import { writeFileSync as writeFileSync6, mkdirSync as mkdirSync8 } from "fs";
 import { homedir as homedir6 } from "os";
-import { join as join9, resolve as resolve3, sep as sep3, parse as parsePath } from "path";
-var log30 = forComponent("checkpoints");
+import { join as join10, resolve as resolve3, sep as sep3, parse as parsePath } from "path";
+var log31 = forComponent("checkpoints");
 var exec = promisify(execFile3);
 var DEFAULT_EXCLUDE = [".agent/", ".git/", "node_modules/", "dist/", "build/", ".next/", "target/", ".venv/", "__pycache__/", "*.log"];
 function isBroadRoot(p) {
@@ -13290,11 +13546,11 @@ var ShadowRepo = class {
       mkdirSync8(this.gitDir, { recursive: true });
       const valid = await this.run("rev-parse", "--git-dir").then(() => true, () => false);
       if (!valid) await this.run("init", "-q");
-      mkdirSync8(join9(this.gitDir, "info"), { recursive: true });
-      writeFileSync5(join9(this.gitDir, "info", "exclude"), this.exclude.join("\n") + "\n");
+      mkdirSync8(join10(this.gitDir, "info"), { recursive: true });
+      writeFileSync6(join10(this.gitDir, "info", "exclude"), this.exclude.join("\n") + "\n");
       this.ready = true;
     } catch (e) {
-      log30.debug(`git checkpoints unavailable for ${this.workTree}`, e);
+      log31.debug(`git checkpoints unavailable for ${this.workTree}`, e);
       this.ready = false;
     }
     return this.ready;
@@ -13305,7 +13561,7 @@ var ShadowRepo = class {
   }
   async commit(label, forced = []) {
     await this.run("add", "-A");
-    for (const p of forced) await this.run("add", "-f", "--", p).catch((e) => log30.debug(`force-add failed: ${p}`, e));
+    for (const p of forced) await this.run("add", "-f", "--", p).catch((e) => log31.debug(`force-add failed: ${p}`, e));
     await this.run("commit", "--allow-empty", "-q", "-m", label);
   }
   /** Inject the CURRENT (pre-edit) content of `paths` into the turn-open restore point by amending it.
@@ -13313,8 +13569,8 @@ var ShadowRepo = class {
    *  turn-boundary `add -A` would never have captured it. Amend (vs a new commit) keeps one restore
    *  point per turn, so the REPL's turn↔frame mapping stays intact. */
   async amendForced(paths) {
-    for (const p of paths) await this.run("add", "-f", "--", p).catch((e) => log30.debug(`force-capture failed: ${p}`, e));
-    await this.run("commit", "--amend", "--no-edit", "-q", "--allow-empty").catch((e) => log30.debug("amend failed", e));
+    for (const p of paths) await this.run("add", "-f", "--", p).catch((e) => log31.debug(`force-capture failed: ${p}`, e));
+    await this.run("commit", "--amend", "--no-edit", "-q", "--allow-empty").catch((e) => log31.debug("amend failed", e));
   }
   /** Commits on `ref`, oldest-first (canonical index space). */
   async log(ref) {
@@ -13374,7 +13630,7 @@ var ShadowRepo = class {
       await this.run("gc", "--auto", "-q").catch(() => {
       });
     } catch (e) {
-      log30.debug("checkpoint prune failed", e);
+      log31.debug("checkpoint prune failed", e);
     }
   }
 };
@@ -13406,7 +13662,7 @@ var GitCheckpoints = class {
       const abs = resolve3(d);
       if (abs === cwd || abs.startsWith(cwd + sep3)) continue;
       if (cwd.startsWith(abs + sep3)) continue;
-      out.push({ workTree: abs, gitDir: join9(abs, ".agent", "checkpoints.git") });
+      out.push({ workTree: abs, gitDir: join10(abs, ".agent", "checkpoints.git") });
     }
     return out;
   }
@@ -13442,7 +13698,7 @@ var GitCheckpoints = class {
   use(sessionId) {
     if (sessionId === this.session) return;
     this.session = sessionId;
-    if (this.started) for (const r of this.repos) void r.point(this.ref()).catch((e) => log30.debug("re-point failed", e));
+    if (this.started) for (const r of this.repos) void r.point(this.ref()).catch((e) => log31.debug("re-point failed", e));
   }
   async begin(label) {
     if (!await this.start()) return;
@@ -13462,7 +13718,7 @@ var GitCheckpoints = class {
           process.stderr.write(`\x1B[2m  checkpoints: '${this.repos[i].root}' too large to snapshot in ${Math.round(this.options.opTimeoutMs / 1e3)}s \u2014 file rewind disabled here\x1B[0m
 `);
         } else {
-          log30.debug("checkpoint commit failed", e);
+          log31.debug("checkpoint commit failed", e);
           survivors.push(this.repos[i]);
           survivorCaches.push(this.caches[i] ?? []);
         }
@@ -13497,7 +13753,7 @@ var GitCheckpoints = class {
           if (this.forced.has(abs)) continue;
           this.forced.add(abs);
           const i = this.repoIndexFor(abs);
-          if (i >= 0) await this.repos[i].amendForced([abs]).catch((e) => log30.debug("amendForced failed", e));
+          if (i >= 0) await this.repos[i].amendForced([abs]).catch((e) => log31.debug("amendForced failed", e));
         }
       }
     };
@@ -13549,7 +13805,7 @@ var GitCheckpointsOptions = class {
   /** Real working tree to snapshot (the launch cwd). */
   workTree = process.cwd();
   /** Isolated git dir for the cwd shadow repo (kept out of the user's real .git). */
-  gitDir = join9(process.cwd(), ".agent", "checkpoints.git");
+  gitDir = join10(process.cwd(), ".agent", "checkpoints.git");
   /** Extra mounted dirs (`--add-dir`); those outside cwd each get their own shadow repo. */
   addDirs = [];
   /** Conversation id → per-session restore-point ref. */
@@ -13565,9 +13821,9 @@ var GitCheckpointsOptions = class {
 };
 
 // cli/permissions.ts
-import { writeFileSync as writeFileSync6, mkdirSync as mkdirSync9 } from "fs";
+import { writeFileSync as writeFileSync7, mkdirSync as mkdirSync9 } from "fs";
 import { homedir as homedir7 } from "os";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 var RULE_RE = /^(\w[\w*-]*)(?:\((.+)\))?$/;
 function parseOne(raw, decision) {
   const m = RULE_RE.exec(raw.trim());
@@ -13589,13 +13845,13 @@ function parsePermRules(perms, explicit = false) {
 function describeRule(r) {
   return `${r.decision.padEnd(5)} ${r.tool ?? "*"}${r.pathGlob ? `(${r.pathGlob})` : ""}`;
 }
-var PERM_FILE = (cwd) => join10(cwd, ".agent", "permissions.json");
+var PERM_FILE = (cwd) => join11(cwd, ".agent", "permissions.json");
 function loadPersistedRules(cwd) {
   const j = readJsonFile(PERM_FILE(cwd), null);
   return j ? { allow: j.allow ?? [], ask: j.ask ?? [], deny: j.deny ?? [] } : {};
 }
 function loadClaudeSettings(cwd, home = homedir7()) {
-  const files = [join10(home, ".claude", "settings.json"), join10(cwd, ".claude", "settings.json"), join10(cwd, ".claude", "settings.local.json")];
+  const files = [join11(home, ".claude", "settings.json"), join11(cwd, ".claude", "settings.json"), join11(cwd, ".claude", "settings.local.json")];
   let out = {};
   for (const p of files) {
     const perms = readJsonFile(p, null)?.permissions;
@@ -13608,8 +13864,8 @@ function persistRule(cwd, decision, ruleStr) {
   const list = cur[decision] ??= [];
   if (!list.includes(ruleStr)) list.push(ruleStr);
   try {
-    mkdirSync9(join10(cwd, ".agent"), { recursive: true });
-    writeFileSync6(PERM_FILE(cwd), JSON.stringify(cur, null, 2) + "\n");
+    mkdirSync9(join11(cwd, ".agent"), { recursive: true });
+    writeFileSync7(PERM_FILE(cwd), JSON.stringify(cur, null, 2) + "\n");
   } catch {
   }
 }
@@ -13622,7 +13878,7 @@ function mergePerms(a, b) {
   }
   return Object.keys(out).length ? out : void 0;
 }
-var TRUST_FILE = join10(homedir7(), ".agent", "trusted.json");
+var TRUST_FILE = join11(homedir7(), ".agent", "trusted.json");
 function isTrusted(cwd, file = TRUST_FILE) {
   const list = readJsonFile(file, []);
   return Array.isArray(list) && list.includes(cwd);
@@ -13632,8 +13888,8 @@ function trustDir(cwd, file = TRUST_FILE) {
   if (!Array.isArray(list)) list = [];
   if (!list.includes(cwd)) list.push(cwd);
   try {
-    mkdirSync9(join10(file, ".."), { recursive: true });
-    writeFileSync6(file, JSON.stringify(list, null, 2) + "\n");
+    mkdirSync9(join11(file, ".."), { recursive: true });
+    writeFileSync7(file, JSON.stringify(list, null, 2) + "\n");
   } catch {
   }
 }
@@ -13696,10 +13952,10 @@ function completePath(listDir, ref) {
 
 // cli/lineEditor.ts
 import { emitKeypressEvents } from "readline";
-import { spawnSync as spawnSync4 } from "child_process";
-import { writeFileSync as writeFileSync7, readFileSync as readFileSync8, unlinkSync as unlinkSync2 } from "fs";
-import { tmpdir as tmpdir2 } from "os";
-import { join as join11 } from "path";
+import { spawnSync as spawnSync5 } from "child_process";
+import { writeFileSync as writeFileSync8, readFileSync as readFileSync9, unlinkSync as unlinkSync2 } from "fs";
+import { tmpdir as tmpdir3 } from "os";
+import { join as join12 } from "path";
 
 // cli/bidi.ts
 var RTL_RE = /[\u0590-\u05ff\u0600-\u06ff\u0750-\u077f\u08a0-\u08ff\ufb1d-\ufdff\ufe70-\ufeff]/;
@@ -14886,14 +15142,14 @@ function createLineEditor(out, input = keyInput) {
   function externalEdit(s) {
     const spec = process.env.VISUAL || process.env.EDITOR || "vi";
     const [cmd, ...cargs] = spec.split(" ").filter(Boolean);
-    const file = join11(tmpdir2(), `agentx-edit-${process.pid}-${Date.now()}.md`);
+    const file = join12(tmpdir3(), `agentx-edit-${process.pid}-${Date.now()}.md`);
     try {
-      writeFileSync7(file, s.buf);
+      writeFileSync8(file, s.buf);
       process.stdin.setRawMode(false);
       out.write("\x1B[?2004l");
-      const r = spawnSync4(cmd, [...cargs, file], { stdio: "inherit" });
+      const r = spawnSync5(cmd, [...cargs, file], { stdio: "inherit" });
       if (r.status === 0) {
-        const text = readFileSync8(file, "utf8").replace(/\n$/, "");
+        const text = readFileSync9(file, "utf8").replace(/\n$/, "");
         s.reset();
         if (text) s.insert(text);
       }
@@ -15346,24 +15602,24 @@ function readPlainLine() {
 }
 
 // cli/osScheduler.ts
-import { spawnSync as spawnSync5 } from "child_process";
-import { writeFileSync as writeFileSync8, mkdirSync as mkdirSync10, readdirSync as readdirSync2, unlinkSync as unlinkSync3, chmodSync, existsSync as existsSync7 } from "fs";
+import { spawnSync as spawnSync6 } from "child_process";
+import { writeFileSync as writeFileSync9, mkdirSync as mkdirSync10, readdirSync as readdirSync2, unlinkSync as unlinkSync3, chmodSync, existsSync as existsSync7 } from "fs";
 import { homedir as homedir8 } from "os";
-import { join as join12 } from "path";
-var log31 = forComponent("os-sched");
+import { join as join13 } from "path";
+var log32 = forComponent("os-sched");
 var OsScheduler = class {
   options;
   constructor(options) {
     this.options = { ...new OsSchedulerOptions(), ...options };
   }
   get dir() {
-    return join12(this.options.home, ".agent", "sched");
+    return join13(this.options.home, ".agent", "sched");
   }
   label(id) {
     return `cc.livx.agentx.sched-${id}`;
   }
   plistPath(id) {
-    return join12(this.options.home, "Library", "LaunchAgents", `${this.label(id)}.plist`);
+    return join13(this.options.home, "Library", "LaunchAgents", `${this.label(id)}.plist`);
   }
   run(cmd, args, input) {
     return this.options.exec(cmd, args, input);
@@ -15379,11 +15635,11 @@ var OsScheduler = class {
     const script = this.writeScript(spec, oneOff);
     const mechanism = this.options.platform === "darwin" ? this.scheduleDarwin(spec, script) : this.scheduleLinux(spec, script, oneOff);
     const meta = { ...spec, created: Date.now(), mechanism };
-    writeFileSync8(join12(this.dir, `${spec.id}.json`), JSON.stringify(meta, null, 2));
+    writeFileSync9(join13(this.dir, `${spec.id}.json`), JSON.stringify(meta, null, 2));
     return mechanism;
   }
   cancel(id) {
-    const meta = readJsonFile(join12(this.dir, `${id}.json`), null);
+    const meta = readJsonFile(join13(this.dir, `${id}.json`), null);
     if (!meta) return false;
     try {
       if (this.options.platform === "darwin") {
@@ -15412,11 +15668,11 @@ var OsScheduler = class {
         }
       }
     } catch (e) {
-      log31.debug(`cancel ${id}`, e);
+      log32.debug(`cancel ${id}`, e);
     }
     for (const f of [`${id}.json`, `${id}.sh`]) {
       try {
-        unlinkSync3(join12(this.dir, f));
+        unlinkSync3(join13(this.dir, f));
       } catch {
       }
     }
@@ -15424,19 +15680,19 @@ var OsScheduler = class {
   }
   list() {
     if (!existsSync7(this.dir)) return [];
-    return readdirSync2(this.dir).filter((f) => f.endsWith(".json")).map((f) => readJsonFile(join12(this.dir, f), null)).filter(Boolean);
+    return readdirSync2(this.dir).filter((f) => f.endsWith(".json")).map((f) => readJsonFile(join13(this.dir, f), null)).filter(Boolean);
   }
   /** The per-job runner script: cd to the project, headless-resume the session, log, notify. */
   writeScript(spec, oneOff) {
-    const p = join12(this.dir, `${spec.id}.sh`);
+    const p = join13(this.dir, `${spec.id}.sh`);
     const q2 = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
-    const cleanup = oneOff ? this.options.platform === "darwin" ? `launchctl remove ${this.label(spec.id)} 2>/dev/null; rm -f ${q2(this.plistPath(spec.id))} ${q2(join12(this.dir, `${spec.id}.json`))} ${q2(p)}
-` : `rm -f ${q2(join12(this.dir, `${spec.id}.json`))} ${q2(p)}
+    const cleanup = oneOff ? this.options.platform === "darwin" ? `launchctl remove ${this.label(spec.id)} 2>/dev/null; rm -f ${q2(this.plistPath(spec.id))} ${q2(join13(this.dir, `${spec.id}.json`))} ${q2(p)}
+` : `rm -f ${q2(join13(this.dir, `${spec.id}.json`))} ${q2(p)}
 ` : "";
-    writeFileSync8(p, `#!/bin/sh
+    writeFileSync9(p, `#!/bin/sh
 # agentx scheduled job ${spec.id}${spec.label ? ` \u2014 ${spec.label}` : ""}
 cd ${q2(spec.cwd)} || exit 1
-${this.options.agentx} -p ${q2(spec.prompt)} --resume ${q2(spec.sessionId)} --yes >> ${q2(join12(this.dir, `${spec.id}.log`))} 2>&1
+${this.options.agentx} -p ${q2(spec.prompt)} --resume ${q2(spec.sessionId)} --yes >> ${q2(join13(this.dir, `${spec.id}.log`))} 2>&1
 ${cleanup}`);
     chmodSync(p, 493);
     return p;
@@ -15473,8 +15729,8 @@ ${trigger}
 <key>RunAtLoad</key><false/>
 </dict></plist>
 `;
-    mkdirSync10(join12(this.options.home, "Library", "LaunchAgents"), { recursive: true });
-    writeFileSync8(this.plistPath(spec.id), plist);
+    mkdirSync10(join13(this.options.home, "Library", "LaunchAgents"), { recursive: true });
+    writeFileSync9(this.plistPath(spec.id), plist);
     this.run("launchctl", ["load", this.plistPath(spec.id)]);
     return `launchd:${this.label(spec.id)}`;
   }
@@ -15511,7 +15767,7 @@ var OsSchedulerOptions = class {
   /** Injectable executor for tests. Returns stdout+stderr merged — `at` reports "job N" on STDERR,
    *  and the job id is what atrm needs for cancel. Throws on non-zero exit. */
   exec = (cmd, args, input) => {
-    const r = spawnSync5(cmd, args, { input, encoding: "utf8" });
+    const r = spawnSync6(cmd, args, { input, encoding: "utf8" });
     if (r.error) throw r.error;
     if (r.status !== 0) throw new Error(`${cmd} exited ${r.status}: ${r.stderr || r.stdout}`);
     return `${r.stdout ?? ""}${r.stderr ?? ""}`;
@@ -15528,10 +15784,10 @@ import { createServer as createServer2, createConnection } from "net";
 import { spawn as spawn3 } from "child_process";
 import { existsSync as existsSync8, mkdirSync as mkdirSync11, unlinkSync as unlinkSync4, readdirSync as readdirSync3 } from "fs";
 import { homedir as homedir9 } from "os";
-import { join as join13 } from "path";
-var log32 = forComponent("remote-trigger");
-var TRIGGER_DIR = () => join13(homedir9(), ".agent", "triggers");
-var sockPath = (sessionId, dir = TRIGGER_DIR()) => join13(dir, `${sessionId}.sock`);
+import { join as join14 } from "path";
+var log33 = forComponent("remote-trigger");
+var TRIGGER_DIR = () => join14(homedir9(), ".agent", "triggers");
+var sockPath = (sessionId, dir = TRIGGER_DIR()) => join14(dir, `${sessionId}.sock`);
 var TriggerServer = class {
   constructor(onTrigger) {
     this.onTrigger = onTrigger;
@@ -15567,13 +15823,13 @@ var TriggerServer = class {
             conn.end(JSON.stringify({ ok: false, error: String(e) }) + "\n");
           }
         });
-        conn.on("error", (e) => log32.debug("trigger conn error", e));
+        conn.on("error", (e) => log33.debug("trigger conn error", e));
       });
-      this.server.on("error", (e) => log32.debug("trigger server error", e));
+      this.server.on("error", (e) => log33.debug("trigger server error", e));
       this.server.listen(p);
       this.path = p;
     } catch (e) {
-      log32.debug("trigger server unavailable", e);
+      log33.debug("trigger server unavailable", e);
     }
   }
   /** Re-bind on /resume (the session id changed). */
@@ -15695,10 +15951,10 @@ var strike = C("9");
 var link = (text, url) => useColor ? `\x1B]8;;${url}\x1B\\${cyan(text)}\x1B]8;;\x1B\\` : `${text} (${url})`;
 var mdPalette = { bold, dim, cyan, italic, strike, green, link };
 var err = (s) => process.stderr.write(s);
-var log33 = forComponent("cli");
+var log34 = forComponent("cli");
 var VERSION = (() => {
   try {
-    return JSON.parse(readFileSync9(new URL("../package.json", import.meta.url), "utf8")).version ?? "?";
+    return JSON.parse(readFileSync10(new URL("../package.json", import.meta.url), "utf8")).version ?? "?";
   } catch {
     return "?";
   }
@@ -15717,7 +15973,7 @@ async function checkForUpdate(current) {
   return `Update available: ${current} \u2192 ${latest}. Run \`bun add -g @livx.cc/agentx\` to update.`;
 }
 function installUpdate() {
-  const r = spawnSync6("bun", ["add", "-g", "@livx.cc/agentx"], { stdio: "inherit" });
+  const r = spawnSync7("bun", ["add", "-g", "@livx.cc/agentx"], { stdio: "inherit" });
   return (r.status ?? 1) === 0;
 }
 var typeaheadOnLine = false;
@@ -16005,7 +16261,7 @@ function resolveModelOrNewest(model) {
 var ENV_KEY_ALIASES = { google: ["GEMINI_API_KEY"] };
 function loadEnvFile(file) {
   if (!existsSync9(file)) return;
-  for (const line of readFileSync9(file, "utf8").split("\n")) {
+  for (const line of readFileSync10(file, "utf8").split("\n")) {
     const m = line.match(/^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/);
     if (!m || m[1] in process.env) continue;
     let val = m[2].trim();
@@ -16016,10 +16272,10 @@ function loadEnvFile(file) {
 }
 function loadInstallEnv() {
   let dir = dirname5(import.meta.path);
-  for (let i = 0; i < 5 && !existsSync9(join14(dir, "package.json")); i++) dir = dirname5(dir);
+  for (let i = 0; i < 5 && !existsSync9(join15(dir, "package.json")); i++) dir = dirname5(dir);
   for (const name of [".env", ".env.local"]) {
-    loadEnvFile(join14(dir, name));
-    loadEnvFile(join14(homedir10(), ".agent", name));
+    loadEnvFile(join15(dir, name));
+    loadEnvFile(join15(homedir10(), ".agent", name));
   }
 }
 async function loadBodifySecrets() {
@@ -16070,6 +16326,7 @@ function makeHost(format = "text", opts) {
   };
   const activitySeen = /* @__PURE__ */ new Set();
   const turnActivityIds = /* @__PURE__ */ new Set();
+  const toolNames = /* @__PURE__ */ new Map();
   let anonActivityCount = 0;
   return {
     flushText,
@@ -16153,7 +16410,17 @@ function makeHost(format = "text", opts) {
         spinner.start();
         return;
       }
+      if (streamJson && (e.kind === "tool_use" || e.kind === "tool_result")) {
+        const t = e;
+        if (t.kind === "tool_use") toolNames.set(t.id, t.name ?? "");
+        const name = toolNames.get(t.id);
+        if (t.kind === "tool_result") toolNames.delete(t.id);
+        const line = t.kind === "tool_use" ? { type: "tool_activity", id: t.id, name: t.name, input: t.input, status: "running" } : { type: "tool_activity", id: t.id, ...name ? { name } : {}, output: typeof t.output === "string" ? t.output.slice(0, 4e3) : t.output, status: t.isError ? "error" : "completed" };
+        process.stdout.write(JSON.stringify(line) + "\n");
+        return;
+      }
       if (!("message" in e)) return;
+      if (streamJson && e.kind === "retry") process.stdout.write(JSON.stringify({ type: "notice", kind: "retry", text: e.message }) + "\n");
       flushLookupGroup();
       closeReasonLine();
       flushText();
@@ -16480,7 +16747,7 @@ function turnCost(model, usage) {
   const priced = model.startsWith("claude-code/") ? `anthropic/${resolveModelAlias(model.slice("claude-code/".length))}` : model;
   return costOf(getModelInfo(priced)?.pricing, usage?.promptTokens ?? 0, usage?.completionTokens ?? 0, usage?.cacheCreationTokens ?? 0, usage?.cacheReadTokens ?? 0, priced);
 }
-async function evaluateGoal(ai, condition, transcript, log34) {
+async function evaluateGoal(ai, condition, transcript, log35) {
   const recent = transcript.filter((m) => m.role === "assistant").slice(-8).map((m) => {
     const text = typeof m.content === "string" ? m.content : m.content.filter((p) => p.type === "text").map((p) => p.text).join(" ");
     return text.slice(0, 600);
@@ -16500,7 +16767,7 @@ ${recent}` }
     const match = r.content.match(/\{[\s\S]*\}/);
     if (match) return JSON.parse(match[0]);
   } catch (e) {
-    log34(dim(`  (goal evaluator error: ${e?.message ?? e})
+    log35(dim(`  (goal evaluator error: ${e?.message ?? e})
 `));
   }
   return { met: false, reason: "evaluation unclear" };
@@ -16511,8 +16778,12 @@ function errInfo(e) {
 function fmtUsd(n) {
   return n >= 1 ? `$${n.toFixed(2)}` : `$${n.toFixed(4)}`;
 }
-function estimateTranscriptTokens(messages, keepRecentImages = 1) {
-  return estimateTokens(messages, keepRecentImages);
+var imageInputOf = (m) => {
+  const i = getModelInfo(m);
+  return i ? !!i.imageInput || !!i.vision : void 0;
+};
+function estimateTranscriptTokens(messages, keepRecentImages = 1, vision = true) {
+  return estimateTokens(messages, keepRecentImages, vision);
 }
 function formatStatus(s) {
   const L = (k, v) => `  ${k.padEnd(12)} ${v}
@@ -16630,6 +16901,7 @@ function optsFor(args, ai, cfg = {}, extraTools = []) {
     model,
     // The real context window drives the context % and `/compact`'s budget (never `maxTokens` — that's spend).
     contextWindow: getModelInfo(model)?.contextWindow ?? 0,
+    imageInput: imageInputOf,
     cwd: args.cwd,
     tools: cfg.tools,
     extraTools,
@@ -16721,13 +16993,13 @@ function mcpAgentTools(mounted, opts) {
   return tools;
 }
 async function closeMcp(mounted) {
-  await Promise.all(mounted.map((m) => m.client.close().catch((e) => log33.debug("mcp close failed", e))));
+  await Promise.all(mounted.map((m) => m.client.close().catch((e) => log34.debug("mcp close failed", e))));
 }
 var IMG_EXT = { ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".gif": "image/gif", ".webp": "image/webp" };
 function mentionRefs(line) {
   return [...line.matchAll(/(?:^|\s)@(?:"([^"]+)"|(\S+))/g)].map((m) => m[1] ?? m[2].replace(/[?!.,;:)\]}'">]+$/, "")).filter(Boolean);
 }
-var untilde = (p) => p.startsWith("~/") ? join14(homedir10(), p.slice(2)) : p;
+var untilde = (p) => p.startsWith("~/") ? join15(homedir10(), p.slice(2)) : p;
 function readImageParts(cwd, line) {
   const refs = mentionRefs(line);
   const parts = [];
@@ -16736,7 +17008,7 @@ function readImageParts(cwd, line) {
     if (!mime) continue;
     const abs = ref.startsWith("~/") ? untilde(ref) : resolve4(cwd, ref);
     try {
-      statSync6(abs);
+      statSync7(abs);
     } catch {
       continue;
     }
@@ -16752,7 +17024,7 @@ function pastePathClassifier(cwd) {
     if (!/^(\/|~\/|\.\/|\.\.\/)/.test(t)) return null;
     const abs = t.startsWith("~/") ? untilde(t) : resolve4(cwd, t);
     try {
-      if (!statSync6(abs).isFile()) return null;
+      if (!statSync7(abs).isFile()) return null;
     } catch {
       return null;
     }
@@ -16773,7 +17045,7 @@ async function expandMentions(fs, line) {
     if (loaded.includes(ref) || missing.includes(ref)) continue;
     if (ref.includes(":") && mcpMentionResolver) {
       const body = await mcpMentionResolver(ref).catch((e) => {
-        log33.debug("mcp mention resolve failed", e);
+        log34.debug("mcp mention resolve failed", e);
         return null;
       });
       if (body != null) {
@@ -16813,7 +17085,8 @@ function jsonResult(res, session) {
     sessionId: session.meta.id,
     // The parked question, machine-readable — the caller answers it and resumes `sessionId`.
     ...res.finishReason === "needs_input" && res.question ? { question: res.question } : {},
-    ...(res.finishReason === "error" || res.finishReason === "empty") && res.error ? { error: res.error?.message ?? String(res.error) } : {}
+    // 'timeout' too: a provider stall ("model stalled: no stream output for 60s") vs the between-steps idle ceiling (no error).
+    ...(res.finishReason === "error" || res.finishReason === "empty" || res.finishReason === "timeout") && res.error ? { error: res.error?.message ?? String(res.error) } : {}
   };
 }
 async function readMultiline(readLine) {
@@ -16862,7 +17135,7 @@ async function runTurn(agent, store, session, task, cp, cwd = process.cwd(), sen
       try {
         store.save(session);
       } catch (ex) {
-        log33.debug("mid-turn session flush failed", ex);
+        log34.debug("mid-turn session flush failed", ex);
       }
     }
     return origNotify(e);
@@ -16930,7 +17203,7 @@ async function runTurn(agent, store, session, task, cp, cwd = process.cwd(), sen
   }
   return { ok, res };
 }
-var remintSessionImages = (data, store, cwd) => remintImageRefs(data.messages, [join14(store.dir, `${data.meta.id}.images`), cwd]);
+var remintSessionImages = (data, store, cwd) => remintImageRefs(data.messages, [join15(store.dir, `${data.meta.id}.images`), cwd]);
 function startSession(args, store, agent, cwd) {
   if (args.resume || args.cont) {
     const data = args.resume ? store.load(args.resume) ?? globalSessionLoad(args.resume) : store.latestData();
@@ -16977,25 +17250,25 @@ var AGENTS_MD_TEMPLATE = `# ${"${name}"}
 `;
 function initInstructions(cwd) {
   for (const f of ["AGENTS.md", "CLAUDE.md"]) {
-    if (existsSync9(join14(cwd, f))) {
+    if (existsSync9(join15(cwd, f))) {
       err(yellow(`  ${f} already exists \u2014 leaving it as-is
 `));
       return;
     }
   }
-  const path = join14(cwd, "AGENTS.md");
-  writeFileSync9(path, AGENTS_MD_TEMPLATE.replace("${name}", basename2(cwd)));
+  const path = join15(cwd, "AGENTS.md");
+  writeFileSync10(path, AGENTS_MD_TEMPLATE.replace("${name}", basename2(cwd)));
   err(green(`  created ${path}
 `) + dim("  edit it, then it auto-loads into every run.\n"));
 }
 function persistSetting(cwd, key, value) {
-  const path = join14(cwd, ".agent", "settings.json");
+  const path = join15(cwd, ".agent", "settings.json");
   try {
-    const obj = existsSync9(path) ? JSON.parse(readFileSync9(path, "utf8")) : {};
+    const obj = existsSync9(path) ? JSON.parse(readFileSync10(path, "utf8")) : {};
     if (obj[key] === value) return;
     obj[key] = value;
     mkdirSync12(dirname5(path), { recursive: true });
-    writeFileSync9(path, JSON.stringify(obj, null, 2) + "\n");
+    writeFileSync10(path, JSON.stringify(obj, null, 2) + "\n");
   } catch (e) {
     err(yellow(`  \u26A0 couldn't persist ${key} to ${path} \u2014 ${e?.message ?? e}
 `));
@@ -17011,14 +17284,14 @@ var isCancelTeardown = (e) => {
 function installCancelGuards(mounted) {
   process.on("unhandledRejection", (e) => {
     if (isCancelTeardown(e)) {
-      log33.debug("suppressed unhandledRejection (cursor stream cancel)", e);
+      log34.debug("suppressed unhandledRejection (cursor stream cancel)", e);
       return;
     }
-    log33.error("unhandledRejection", e);
+    log34.error("unhandledRejection", e);
   });
   process.on("uncaughtException", (e) => {
     if (isCancelTeardown(e)) {
-      log33.debug("suppressed uncaughtException (cursor stream cancel)", e);
+      log34.debug("suppressed uncaughtException (cursor stream cancel)", e);
       return;
     }
     console.error(e);
@@ -17027,7 +17300,7 @@ function installCancelGuards(mounted) {
   });
 }
 async function repl(args, ai, cfg, cwd) {
-  const oauth = new McpOAuth({ storePath: join14(cwd, ".agent", "mcp-auth.json") });
+  const oauth = new McpOAuth({ storePath: join15(cwd, ".agent", "mcp-auth.json") });
   const mounted = await mountMcp(cfg, oauth);
   let mcpToolNames = [];
   const initialMcpTools = mcpAgentTools(mounted);
@@ -17303,7 +17576,7 @@ async function repl(args, ai, cfg, cwd) {
       quickLook: {
         branch: () => {
           try {
-            const head = readFileSync9(join14(cwd, ".git", "HEAD"), "utf8").trim();
+            const head = readFileSync10(join15(cwd, ".git", "HEAD"), "utf8").trim();
             return head.startsWith("ref: refs/heads/") ? `branch: ${head.slice("ref: refs/heads/".length)}` : `detached HEAD at ${head.slice(0, 12)}`;
           } catch {
             return "not a git repository";
@@ -17437,11 +17710,11 @@ async function repl(args, ai, cfg, cwd) {
   const pendingImages = [];
   const bangContext = [];
   const grabClipboardAttachment = () => {
-    const dir = join14(store.dir, `${session.meta.id}.images`);
+    const dir = join15(store.dir, `${session.meta.id}.images`);
     try {
       mkdirSync12(dir, { recursive: true });
     } catch (e) {
-      log33.debug("paste image dir create failed", e);
+      log34.debug("paste image dir create failed", e);
     }
     const img = grabClipboardImage(dir, String(Date.now()));
     return img ? { display: "Image", ref: "@" + img.path, path: img.path } : null;
@@ -17495,7 +17768,7 @@ async function repl(args, ai, cfg, cwd) {
     err(dim(`  \u23F0 ${scheduler.size} scheduled job(s) re-armed
 `));
   }
-  const checkpoints = args.vfs || args.boddb ? new CheckpointStack(agent.options.fs) : new GitCheckpoints({ workTree: cwd, gitDir: join14(cwd, ".agent", "checkpoints.git"), addDirs: args.addDirs, sessionId: session.meta.id });
+  const checkpoints = args.vfs || args.boddb ? new CheckpointStack(agent.options.fs) : new GitCheckpoints({ workTree: cwd, gitDir: join15(cwd, ".agent", "checkpoints.git"), addDirs: args.addDirs, sessionId: session.meta.id });
   const cpHooks = checkpoints.hooks?.();
   if (cpHooks) {
     agent.options.hooks = composeHooks(agent.options.hooks, cpHooks);
@@ -17547,14 +17820,14 @@ ${lines.join("\n")}
 Added entries are loadable now via the Skill/SlashCommand tools; removed ones are gone even if still listed in the system prompt.
 </system-reminder>`;
   };
-  const histPath = join14(cwd, ".agent", "history");
-  const history = existsSync9(histPath) ? readFileSync9(histPath, "utf8").split("\n").filter(Boolean).reverse().slice(0, 500) : [];
-  const remember = (line) => {
+  const histPath = join15(cwd, ".agent", "history");
+  const history = existsSync9(histPath) ? readFileSync10(histPath, "utf8").split("\n").filter(Boolean).reverse().slice(0, 500) : [];
+  const remember2 = (line) => {
     try {
-      mkdirSync12(join14(cwd, ".agent"), { recursive: true });
+      mkdirSync12(join15(cwd, ".agent"), { recursive: true });
       appendFileSync(histPath, line + "\n");
     } catch (e) {
-      log33.debug("history write failed", e);
+      log34.debug("history write failed", e);
     }
   };
   const ago = (t) => {
@@ -17626,7 +17899,7 @@ Added entries are loadable now via the Skill/SlashCommand tools; removed ones ar
       try {
         store.save(session);
       } catch (e) {
-        log33.debug("session save after rewind failed", e);
+        log34.debug("session save after rewind failed", e);
       }
       err(green("  \u27F2 jumped back") + dim(` \u2014 ${face.transcript.length} message(s) kept; edit + resend
 `));
@@ -17661,7 +17934,7 @@ ${task}`;
       bangContext.length = 0;
     }
     const delta = await refreshCatalogs().catch((e) => {
-      log33.debug("catalog refresh failed", e);
+      log34.debug("catalog refresh failed", e);
       return "";
     });
     if (delta) {
@@ -17839,7 +18112,7 @@ ${task}`;
     context: {
       desc: "context-window usage (messages + estimated tokens)",
       run: () => {
-        const est = estimateTranscriptTokens(face.transcript, face.options.keepRecentImages);
+        const est = estimateTranscriptTokens(face.transcript, face.options.keepRecentImages, face.options.imageInput?.(face.options.model) !== false);
         const cap = Agent.contextCap(face.options);
         err(dim(`  ${face.transcript.length} message(s) \xB7 ~${(est / 1e3).toFixed(1)}k tokens (~${Math.round(est / cap * 100)}% of ${Math.round(cap / 1e3)}k budget)
 `));
@@ -17854,8 +18127,8 @@ ${task}`;
           const wasRaw = process.stdin.isTTY && process.stdin.isRaw;
           if (wasRaw) process.stdin.setRawMode(false);
           try {
-            const { spawnSync: spawnSync7 } = await import("child_process");
-            const r = spawnSync7("less", ["-R"], { input: text, stdio: ["pipe", "inherit", "inherit"] });
+            const { spawnSync: spawnSync8 } = await import("child_process");
+            const r = spawnSync8("less", ["-R"], { input: text, stdio: ["pipe", "inherit", "inherit"] });
             if (r.error) err(text);
           } finally {
             if (wasRaw) process.stdin.setRawMode(true);
@@ -17875,8 +18148,8 @@ ${task}`;
         keys.length ? ok(`provider keys: ${keys.join(", ")}`) : bad("no provider keys set (ANTHROPIC_API_KEY / OPENAI_API_KEY / GOOGLE_API_KEY / GROQ_API_KEY)");
         process.env.BODIFY_API_KEY && process.env.BODIFY_APP_ID ? ok(`bodify secrets: ${process.env.BODIFY_APP_ID}`) : warn("bodify secrets: not configured (set BODIFY_API_KEY + BODIFY_APP_ID)");
         {
-          const { spawnSync: spawnSync7 } = await import("child_process");
-          const has = (cmd) => spawnSync7("which", [cmd]).status === 0;
+          const { spawnSync: spawnSync8 } = await import("child_process");
+          const has = (cmd) => spawnSync8("which", [cmd]).status === 0;
           if (!VoiceIO.available()) warn("voice: keys missing (SONIOX_API_KEY / CARTESIA_API_KEY / CARTESIA_VOICE_ID) \u2014 voice disabled");
           else {
             ok("voice: keys present");
@@ -17897,7 +18170,7 @@ ${task}`;
         try {
           const probe = `${cwd}/.agent/sessions/.doctor-probe`;
           mkdirSync12(`${cwd}/.agent/sessions`, { recursive: true });
-          writeFileSync9(probe, "ok");
+          writeFileSync10(probe, "ok");
           unlinkSync5(probe);
           ok(`session store writable (${cwd}/.agent/sessions)`);
         } catch (e) {
@@ -17925,7 +18198,7 @@ ${task}`;
       desc: "rescan skills/commands dirs and rebuild the system prompt (one cache miss) \u2014 picks up entries created mid-session",
       run: async () => {
         await refreshCatalogs().catch((e) => {
-          log33.debug("catalog refresh failed", e);
+          log34.debug("catalog refresh failed", e);
         });
         face.reprepare();
         err(green(`  \u2713 reloaded \u2014 ${skills.length} skill(s), ${cmds.length} command(s); system prompt rebuilds on next message
@@ -18307,8 +18580,8 @@ ${task}`;
         const wasRaw = process.stdin.isTTY && process.stdin.isRaw;
         if (wasRaw) process.stdin.setRawMode(false);
         try {
-          const { spawnSync: spawnSync7 } = await import("child_process");
-          spawnSync7(ed, [idx], { stdio: "inherit" });
+          const { spawnSync: spawnSync8 } = await import("child_process");
+          spawnSync8(ed, [idx], { stdio: "inherit" });
         } finally {
           if (wasRaw) process.stdin.setRawMode(true);
         }
@@ -18427,7 +18700,7 @@ ${task}`;
           try {
             for (const def of (await loadAgents(fs2, d)).agents) if (!seen.has(def.name)) seen.set(def.name, { def, from: d });
           } catch (e) {
-            log33.debug(`loadAgents(${d}) failed`, e);
+            log34.debug(`loadAgents(${d}) failed`, e);
           }
         }
         if (!seen.size) {
@@ -18515,7 +18788,7 @@ ${task}`;
           }
           if (idx >= 0) {
             const old = mounted.splice(idx, 1)[0];
-            await old.client.close().catch((e) => log33.debug("mcp close failed", e));
+            await old.client.close().catch((e) => log34.debug("mcp close failed", e));
           }
           try {
             const m = await mountMcpServer(name, conf);
@@ -18543,7 +18816,7 @@ ${task}`;
           }
           const m = mounted.splice(idx, 1)[0];
           remountMcpTools();
-          await m.client.close().catch((e) => log33.debug("mcp close failed", e));
+          await m.client.close().catch((e) => log34.debug("mcp close failed", e));
           err(dim(`  removed "${name}"
 `));
           return;
@@ -18658,11 +18931,11 @@ ${task}`;
           return;
         }
         const md = exportMarkdown(session.meta, shown);
-        const name = a[0] ? extname(a[0]) ? a[0] : a[0] + ".md" : join14(".agent", "exports", `${session.meta.id}.md`);
+        const name = a[0] ? extname(a[0]) ? a[0] : a[0] + ".md" : join15(".agent", "exports", `${session.meta.id}.md`);
         const path = resolve4(cwd, name);
         try {
           mkdirSync12(dirname5(path), { recursive: true });
-          writeFileSync9(path, md);
+          writeFileSync10(path, md);
           err(green(`  \u2713 exported \u2192 ${path}
 `) + dim(`  ${shown.length} message(s) \xB7 ${md.length} chars
 `));
@@ -18744,9 +19017,9 @@ ${task}`;
   });
   const listDir = (absDir) => {
     try {
-      return readdirSync4(join14(cwd, absDir.replace(/^\/+/, "")), { withFileTypes: true }).map((d) => ({ name: d.name, dir: d.isDirectory() }));
+      return readdirSync4(join15(cwd, absDir.replace(/^\/+/, "")), { withFileTypes: true }).map((d) => ({ name: d.name, dir: d.isDirectory() }));
     } catch (e) {
-      log33.debug("completion readdir failed", absDir, e);
+      log34.debug("completion readdir failed", absDir, e);
       return null;
     }
   };
@@ -18849,7 +19122,7 @@ ${task}`;
     if (!opts?.id) takeCut(voiceIO, false);
     if (/^[!#/]/.test(line)) dispatchPending = false;
     history.unshift(line.replace(/\n+/g, " \u23CE "));
-    remember(line.replace(/\n+/g, " \u23CE "));
+    remember2(line.replace(/\n+/g, " \u23CE "));
     if (line.startsWith("!")) {
       const cmd = line.slice(1).trim();
       if (cmd) {
@@ -18883,7 +19156,7 @@ ${out}
         return;
       }
       await refreshCatalogs().catch((e) => {
-        log33.debug("catalog refresh failed", e);
+        log34.debug("catalog refresh failed", e);
       });
       const sk = skills.find((x) => x.name === name);
       if (sk) {
@@ -18929,7 +19202,7 @@ ${out}
       return false;
     }
     const fakeVoice = process.env.AGENTX_VOICE_FAKE ? fakeVoiceParts(process.env.AGENTX_VOICE_FAKE) : null;
-    voiceDiag = new JsonlDiagSink(join14(store.dir, `${session.meta.id}.voice.jsonl`));
+    voiceDiag = new JsonlDiagSink(join15(store.dir, `${session.meta.id}.voice.jsonl`));
     voiceIO = new VoiceIO({
       ...fakeVoice ?? {},
       onDiag: (ev) => voiceDiag?.push(ev),
@@ -18994,7 +19267,7 @@ ${out}
         if (delivery || cut) dx?.parkCutDelivery(delivery, !!cut, heard);
         const cutReply = cut && cut.full.length - cut.heard.length > 40 ? cut : null;
         const noteP = replaces ? replaces.note : !cutReply ? Promise.resolve("") : (instinct ? instinct.bargeIntent(text).catch((e) => {
-          log33.warn(`barge intent failed \u2014 model decides: ${e.message}`);
+          log34.warn(`barge intent failed \u2014 model decides: ${e.message}`);
           return void 0;
         }) : Promise.resolve(void 0)).then(async (intent) => interruptionNote(cutReply, intent) + ackedNote(await instinct?.ackFor(text)));
         const cutIn = replaces ? replaces.cutIn : interjectNote;
@@ -19152,7 +19425,7 @@ ${out}
     err("\n");
     const initial = prefill ?? (carry || void 0);
     prefill = void 0;
-    const ctxTok = estimateTranscriptTokens(face.transcript, face.options.keepRecentImages);
+    const ctxTok = estimateTranscriptTokens(face.transcript, face.options.keepRecentImages, face.options.imageInput?.(face.options.model) !== false);
     const ctxCap = Agent.contextCap(face.options);
     {
       const pct = Math.round(ctxTok / ctxCap * 100);
@@ -19332,7 +19605,7 @@ ${out}
 }
 async function duplexServe(args, ai, cfg, cwd) {
   const out = (o) => process.stdout.write(JSON.stringify(o) + "\n");
-  const mounted = await mountMcp(cfg, new McpOAuth({ storePath: join14(cwd, ".agent", "mcp-auth.json") }));
+  const mounted = await mountMcp(cfg, new McpOAuth({ storePath: join15(cwd, ".agent", "mcp-auth.json") }));
   installCancelGuards(mounted);
   const agent = await makeAgent(args, ai, cfg, mcpAgentTools(mounted, { quiet: true }), mounted.map((m) => m.name));
   const { host: _h, stream: _s, signal: _g, providerOptions: _po, ...wo } = agent.options;
@@ -19376,7 +19649,7 @@ async function duplexServe(args, ai, cfg, cwd) {
     try {
       store.save(session);
     } catch (e) {
-      log33.warn("duplex session save failed", e);
+      log34.warn("duplex session save failed", e);
     }
   };
   out({ type: "ready", sessionId: session.meta.id, reflexModel: dx.options.reflexModel, actModel: dx.options.actModel });
@@ -19400,7 +19673,7 @@ async function duplexServe(args, ai, cfg, cwd) {
         const note = reply && reply.full.length - reply.heard.length > 40 ? interruptionNote(reply) : "";
         const id = m.id ? String(m.id) : void 0;
         void runTurn(dx.voice, store, session, m.text + note, void 0, cwd, (c) => dx.send(c, { id, replaces: m.replaces ? String(m.replaces) : void 0, followUp: typeof m.followUp === "string" || m.followUp && typeof m.followUp === "object" ? m.followUp : void 0 })).then(({ res }) => out({ type: "turn_done", id, finishReason: res?.finishReason ?? "error" })).catch((e) => {
-          log33.error("duplex turn failed", e);
+          log34.error("duplex turn failed", e);
           out({ type: "turn_done", id, finishReason: "error", error: String(e?.message ?? e) });
         });
       }
@@ -19514,7 +19787,7 @@ async function main() {
     }
   });
   if (args.task) {
-    const mounted = await mountMcp(cfg, new McpOAuth({ storePath: join14(cwd, ".agent", "mcp-auth.json") }));
+    const mounted = await mountMcp(cfg, new McpOAuth({ storePath: join15(cwd, ".agent", "mcp-auth.json") }));
     const agent = await makeAgent(args, ai, cfg, mcpAgentTools(mounted), mounted.map((m) => m.name));
     const store = new SessionStore(cwd);
     const session = startSession(args, store, agent, cwd);