@livx.cc/agentx 0.99.27 → 0.99.30

package/dist/cli.js

@@ -9,6 +9,271 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/logging.ts
+import { log } from "libx.js/src/modules/log";
+var forComponent;
+var init_logging = __esm({
+  "src/logging.ts"() {
+    "use strict";
+    forComponent = (name) => log.forComponent(name);
+  }
+});
+
+// src/llm.ts
+import { readFileSync, statSync as statSync2, realpathSync } from "fs";
+import { resolve, sep } from "path";
+import { randomBytes } from "crypto";
+function contentText(content) {
+  if (content == null) return "";
+  if (typeof content === "string") return content;
+  return content.map((p) => p.type === "text" ? p.text ?? "" : "[image]").join(p_sep(content));
+}
+function imagePart(url) {
+  return { type: "image_url", image_url: { url } };
+}
+function messageHasInlineImage(content) {
+  if (content == null || typeof content === "string") return false;
+  return content.some((p) => p.type === "image_url" && (p.image_url?.url ?? "").startsWith("data:"));
+}
+function contentBytes(content) {
+  if (content == null) return 0;
+  if (typeof content === "string") return content.length;
+  let n = 0;
+  for (const p of content) {
+    if (p.type === "text") {
+      n += (p.text ?? "").length;
+      continue;
+    }
+    const url = p.image_url?.url ?? "";
+    const ref = parseImageRef(url);
+    n += (ref ? ref.bytes : url.length) || 7;
+  }
+  return n;
+}
+function elideInlineImages(content, stub = IMAGE_ELIDE_STUB) {
+  return elideImageParts(content, (url) => url.startsWith("data:"), stub);
+}
+function elideImages(content, stub = IMAGE_ELIDE_STUB) {
+  return elideImageParts(content, (url) => url.startsWith("data:") || isImageRefUrl(url), stub);
+}
+function elideImageParts(content, hit, stub) {
+  if (typeof content === "string") return content;
+  let changed = false;
+  const out = [];
+  for (const p of content) {
+    if (p.type !== "image_url" || !hit(p.image_url?.url ?? "")) {
+      out.push(p);
+      continue;
+    }
+    changed = true;
+    out.push({ type: "text", text: stub });
+  }
+  return changed ? out : content;
+}
+function mintImageRef(path, mime) {
+  const token = randomBytes(16).toString("hex");
+  let bytes = 0;
+  try {
+    bytes = Math.ceil(statSync2(path).size * 4 / 3);
+  } catch (e) {
+    log2.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);
+  return `${IMAGE_REF_SCHEME}${mime};${token};${path}`;
+}
+function imageRefPart(path, mime) {
+  return { type: "image_url", image_url: { url: mintImageRef(path, mime) } };
+}
+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");
+    return null;
+  }
+  return ref;
+}
+function refUrlParts(url) {
+  if (!isImageRefUrl(url)) return null;
+  const rest = url.slice(IMAGE_REF_SCHEME.length);
+  const a = rest.indexOf(";");
+  if (a < 0) return null;
+  const b = rest.indexOf(";", a + 1);
+  return { mime: rest.slice(0, a), token: b < 0 ? rest.slice(a + 1) : rest.slice(a + 1, b), path: b < 0 ? "" : rest.slice(b + 1) };
+}
+function remintImageRefs(messages, roots) {
+  const allowed = [];
+  for (const r of roots) {
+    try {
+      allowed.push(realpathSync(resolve(r)));
+    } catch (e) {
+      log2.debug(`image-ref root unavailable: ${r}`, e);
+    }
+  }
+  if (allowed.length === 0) return messages;
+  const inside = (p) => allowed.some((root) => p === root || p.startsWith(root + sep));
+  let changed = false;
+  const out = messages.map((m) => {
+    if (m.role !== "user" && m.role !== "assistant" || typeof m.content === "string" || m.content == null) return m;
+    let touched = false;
+    const parts = m.content.map((p) => {
+      if (p.type !== "image_url") return p;
+      const f = refUrlParts(p.image_url?.url);
+      if (!f || refRegistry.has(f.token)) return p;
+      let real;
+      try {
+        real = realpathSync(f.path);
+      } catch (e) {
+        log2.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}`);
+        return p;
+      }
+      touched = true;
+      return { type: "image_url", image_url: { url: mintImageRef(real, f.mime) } };
+    });
+    if (!touched) return m;
+    changed = true;
+    return { ...m, content: parts };
+  });
+  return changed ? out : messages;
+}
+function messageHasImageRef(content) {
+  if (content == null || typeof content === "string") return false;
+  return content.some((p) => p.type === "image_url" && isImageRefUrl(p.image_url?.url));
+}
+function messageHasImage(content) {
+  return messageHasInlineImage(content) || messageHasImageRef(content);
+}
+function imageRefResult(path, mime) {
+  return JSON.stringify({ imageRef: mintImageRef(path, mime), image: path });
+}
+function toolImageRef(content) {
+  if (typeof content !== "string" || !content.startsWith('{"imageRef":')) return null;
+  try {
+    return parseImageRef(JSON.parse(content).imageRef);
+  } catch (e) {
+    log2.debug("bad imageRef tool result", e);
+    return null;
+  }
+}
+function elideStaleImages(messages, keepRecent = 1) {
+  const idx = messages.map((m, i) => messageHasImage(m.content) ? i : -1).filter((i) => i >= 0);
+  const drop = new Set(idx.slice(0, Math.max(0, idx.length - keepRecent)));
+  if (drop.size === 0) return messages;
+  let changed = false;
+  const out = messages.map((m, i) => {
+    if (!drop.has(i)) return m;
+    const c = elideInlineImages(m.content);
+    if (c === m.content) return m;
+    changed = true;
+    return { ...m, content: c };
+  });
+  return changed ? out : messages;
+}
+function imageWindows(messages, keepRecent) {
+  const attach = [];
+  const tool = [];
+  messages.forEach((m, i) => {
+    if (toolImageRef(m.content)) tool.push(i);
+    else if (messageHasImage(m.content)) attach.push(i);
+  });
+  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) {
+  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);
+    if (content === m.content) return m;
+    changed = true;
+    return { ...m, content };
+  });
+  return changed ? out : messages;
+}
+function sendBytes(messages, keepRecent = 1, stub = IMAGE_ELIDE_STUB) {
+  let n = 0;
+  for (const b of sendBytesPer(messages, keepRecent, stub)) n += b;
+  return n;
+}
+function sendBytesPer(messages, keepRecent = 1, 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));
+}
+function wireBytes(content, kept, stub) {
+  const tool = toolImageRef(content);
+  if (tool) return kept ? tool.bytes : stub.length;
+  if (content == null || typeof content === "string") return contentBytes(content);
+  if (kept) return contentBytes(content);
+  let n = 0;
+  for (const p of content) {
+    if (p.type === "text") {
+      n += (p.text ?? "").length;
+      continue;
+    }
+    const url = p.image_url?.url ?? "";
+    n += url.startsWith("data:") || isImageRefUrl(url) ? stub.length : url.length || 7;
+  }
+  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) {
+  const tool = toolImageRef(content);
+  if (tool) {
+    const url = readRefDataUrl(tool);
+    return url ? JSON.stringify({ dataUrl: url, image: tool.path }) : stub;
+  }
+  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;
+    changed = true;
+    const ref = parseImageRef(p.image_url?.url);
+    const url = ref && readRefDataUrl(ref);
+    return url ? imagePart(url) : { type: "text", text: stub };
+  });
+  return changed ? out : content;
+}
+function stripContent(content, stub) {
+  if (toolImageRef(content)) return stub;
+  if (typeof content === "string") return content;
+  let changed = false;
+  const out = content.map((p) => {
+    const url = p.type === "image_url" ? p.image_url?.url ?? "" : "";
+    if (!url.startsWith("data:") && !isImageRefUrl(url)) return p;
+    changed = true;
+    return { type: "text", text: stub };
+  });
+  return changed ? out : content;
+}
+var log2, p_sep, IMAGE_ELIDE_STUB, IMAGE_REF_SCHEME, REF_REGISTRY_MAX, refRegistry, isImageRefUrl, bearsImage;
+var init_llm = __esm({
+  "src/llm.ts"() {
+    "use strict";
+    init_logging();
+    log2 = 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:";
+    REF_REGISTRY_MAX = 256;
+    refRegistry = /* @__PURE__ */ new Map();
+    isImageRefUrl = (url) => !!url && url.startsWith(IMAGE_REF_SCHEME);
+    bearsImage = (m) => messageHasImage(m.content) || toolImageRef(m.content) != null;
+  }
+});
+
 // src/redact.ts
 function redactSecrets(text) {
   if (!text) return text;
@@ -475,16 +740,6 @@ var init_todo = __esm({
   }
 });
 
-// src/logging.ts
-import { log } from "libx.js/src/modules/log";
-var forComponent;
-var init_logging = __esm({
-  "src/logging.ts"() {
-    "use strict";
-    forComponent = (name) => log.forComponent(name);
-  }
-});
-
 // src/tools.web.ts
 function htmlToText(html) {
   let s = html.replace(/<script[\s\S]*?<\/script>/gi, " ").replace(/<style[\s\S]*?<\/style>/gi, " ").replace(/<title[\s\S]*?<\/title>/gi, " ").replace(/<noscript[\s\S]*?<\/noscript>/gi, " ").replace(/<textarea[\s\S]*?<\/textarea>/gi, " ").replace(/<!--[\s\S]*?-->/g, " ").replace(/<\/(p|div|li|h[1-6]|tr|section|article|header|footer|nav)>/gi, "\n").replace(/<br\s*\/?>/gi, "\n").replace(/<[^>]+>/g, " ");
@@ -606,7 +861,7 @@ function makeWebFetchTool(options = {}) {
 
 ${capped}`;
       } catch (e) {
-        log2.debug(`WebFetch ${u} failed`, e);
+        log3.debug(`WebFetch ${u} failed`, e);
         return `Error fetching ${u}: ${e?.name === "AbortError" ? `timed out after ${timeoutMs}ms` : e?.message ?? e}`;
       } finally {
         clearTimeout(timer);
@@ -730,7 +985,7 @@ function makeWebSearchTool(options = {}) {
         if (!res.ok) return `Error: search returned ${res.status} ${res.statusText}`;
         return formatHits(parseDdgHtml(await res.text(), maxResults));
       } catch (e) {
-        log2.debug("WebSearch failed", e);
+        log3.debug("WebSearch failed", e);
         return `Error searching: ${e?.name === "AbortError" ? `timed out after ${timeoutMs}ms` : e?.message ?? e}`;
       } finally {
         clearTimeout(timer);
@@ -741,12 +996,12 @@ function makeWebSearchTool(options = {}) {
 function makeWebSearchAnthropicTool(opts = {}) {
   return makeWebSearchTool({ provider: "anthropic", name: "WebSearchAnthropic", description: ANTHROPIC_SEARCH_DESC, anthropicApiKey: opts.anthropicApiKey, model: opts.model });
 }
-var log2, _dnsLookup, webFetchTool, webSearchTool, ANTHROPIC_SEARCH_DESC, webSearchAnthropicTool;
+var log3, _dnsLookup, webFetchTool, webSearchTool, ANTHROPIC_SEARCH_DESC, webSearchAnthropicTool;
 var init_tools_web = __esm({
   "src/tools.web.ts"() {
     "use strict";
     init_logging();
-    log2 = forComponent("web");
+    log3 = 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).";
@@ -961,6 +1216,36 @@ ${out}`.trim() : out || "(command succeeded, no output)";
   );
   return `Started background job ${id} \u2014 poll with JobOutput({id:"${id}"}) / JobStatus, stop with JobKill.`;
 }
+function realPathOf(fs, path) {
+  if (typeof fs.realPath !== "function") return null;
+  try {
+    return fs.realPath(path);
+  } catch (e) {
+    log4.debug(`realPath unavailable for ${path} \u2014 inlining image bytes instead`, e);
+    return null;
+  }
+}
+function isBinary(raw) {
+  if (raw === "") return false;
+  const head = raw.length > 8192 ? raw.slice(0, 8192) : raw;
+  let repl2 = 0;
+  for (let i = 0; i < head.length; i++) {
+    const c = head.charCodeAt(i);
+    if (c === 0) return true;
+    if (c === 65533) repl2++;
+  }
+  return repl2 / head.length > 0.1;
+}
+async function byteSize(fs, path, raw) {
+  const bfs = fs;
+  if (typeof bfs.readFileBytes === "function") {
+    try {
+      return (await bfs.readFileBytes(path)).length;
+    } catch {
+    }
+  }
+  return Buffer.byteLength(raw, "utf8");
+}
 function exitSessionTool(onExit) {
   return {
     name: "ExitSession",
@@ -987,15 +1272,18 @@ function toolsByName(names) {
     return t;
   });
 }
-var numberLines, bashTool, IMG_MIME, readTool, editTool;
+var log4, numberLines, bashTool, IMG_MIME, readTool, editTool;
 var init_tools = __esm({
   "src/tools.ts"() {
     "use strict";
+    init_llm();
+    init_logging();
     init_tools_structured();
     init_todo();
     init_tools_web();
     init_OverlayFilesystem();
     init_redact();
+    log4 = forComponent("tools");
     numberLines = (content, offset = 0, limit) => {
       const lines = content.split("\n");
       const start = Math.max(0, offset);
@@ -1050,12 +1338,22 @@ var init_tools = __esm({
           if (typeof fs.readFileBytes !== "function") {
             return `[${path} is an image, but this filesystem can't read binary \u2014 attach it as @${path} instead, or run on disk.]`;
           }
+          const real = realPathOf(fs, path);
+          if (real) {
+            if (!await ctx.fs.exists(path)) return `Error: File not found: ${path}`;
+            return imageRefResult(real, IMG_MIME[ext]);
+          }
           const bytes = await fs.readFileBytes(path);
           const b64 = Buffer.from(bytes).toString("base64");
           return JSON.stringify({ dataUrl: `data:${IMG_MIME[ext]};base64,${b64}`, image: path });
         }
         const raw = await ctx.fs.readFile(path);
+        if (isBinary(raw)) {
+          const bytes = await byteSize(ctx.fs, path, raw);
+          return `[binary file: ${path} \u2014 ${bytes} bytes, not shown as text. Read renders png/jpg/jpeg/gif/webp images directly; otherwise attach it as @${path}.]`;
+        }
         ctx.readState.set(ctx.fs.resolvePath(path), raw);
+        if (raw === "") return `[empty file: ${path} \u2014 0 bytes]`;
         const content = CONFIG_FILE_RE.test(ctx.fs.resolvePath(path)) ? redactSecrets(raw) : raw;
         const total = content === "" ? 0 : content.split("\n").length;
         const start = Math.max(0, offset ?? 0);
@@ -1123,7 +1421,7 @@ __export(worktree_exports, {
   worktreeBranchName: () => worktreeBranchName
 });
 import { spawnSync } from "child_process";
-import { symlinkSync, mkdirSync, statSync as statSync2, readFileSync, rmSync } from "fs";
+import { symlinkSync, mkdirSync, statSync as statSync3, readFileSync as readFileSync2, rmSync } from "fs";
 import { join as join2 } from "path";
 function validateWorktreeSlug(slug2) {
   if (!slug2) throw new Error("worktree slug must not be empty");
@@ -1159,16 +1457,16 @@ function findGitRoot(from) {
 }
 function readWorktreeHead(worktreePath) {
   try {
-    const gitFile = readFileSync(join2(worktreePath, ".git"), "utf-8").trim();
+    const gitFile = readFileSync2(join2(worktreePath, ".git"), "utf-8").trim();
     const m = gitFile.match(/^gitdir:\s*(.+)$/);
     if (!m) return null;
     const headPath = join2(m[1], "HEAD");
-    const head = readFileSync(headPath, "utf-8").trim();
+    const head = readFileSync2(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]);
     try {
-      return readFileSync(refPath, "utf-8").trim();
+      return readFileSync2(refPath, "utf-8").trim();
     } catch {
     }
     const r = git(["rev-parse", "HEAD"], worktreePath);
@@ -1204,7 +1502,7 @@ function symlinkDirs(repoRoot, worktreePath, dirs) {
     const src = join2(repoRoot, dir);
     const dst = join2(worktreePath, dir);
     try {
-      statSync2(src);
+      statSync3(src);
     } catch {
       continue;
     }
@@ -1220,7 +1518,7 @@ function cleanupWorktree(repoRoot, slug2, opts) {
   const worktreePath = worktreePathFor(repoRoot, slug2);
   const branch = worktreeBranchName(slug2);
   try {
-    statSync2(worktreePath);
+    statSync3(worktreePath);
   } catch {
     return { removed: false, reason: "not found" };
   }
@@ -1355,6 +1653,11 @@ var init_NodeDiskFilesystem = __esm({
           throw new Error(`File not found: ${path}`);
         }
       }
+      /** The REAL on-disk path behind a VFS path — an optional capability (not on IFilesystem) the Read
+       *  tool duck-types so it can persist an image REFERENCE instead of megabytes of base64. */
+      realPath(path) {
+        return this.real(this.resolvePath(path));
+      }
       /** Read raw bytes (for binary files like images). Not on the base IFilesystem (which is utf8-only) — an
        *  optional capability the Read tool duck-types to return image blocks. Same symlink/jail guards as readFile. */
       async readFileBytes(path) {
@@ -1537,6 +1840,12 @@ var init_JailedFilesystem = __esm({
         if (typeof inner.readFileBytes !== "function") throw new Error("binary read not supported by this filesystem");
         return inner.readFileBytes(this.guardRead("readFileBytes", path));
       }
+      /** Forward the optional real-path capability (image REFS), jail-guarded like readFile. */
+      realPath(path) {
+        const inner = this.inner;
+        if (typeof inner.realPath !== "function") throw new Error("realPath not supported by this filesystem");
+        return inner.realPath(this.guardRead("realPath", path));
+      }
       async writeFile(path, content) {
         return this.inner.writeFile(this.guardWrite("writeFile", path), content);
       }
@@ -1777,13 +2086,13 @@ function makeRealShellTool(options) {
         }
       };
       try {
-        return await new Promise((resolve4) => {
+        return await new Promise((resolve5) => {
           let out = "";
           let settled = false;
           const finish = (s) => {
             if (settled) return;
             settled = true;
-            resolve4(s);
+            resolve5(s);
           };
           let proc;
           try {
@@ -1806,7 +2115,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, clean(out)));
-            log14.debug("shell spawn error", err2);
+            log16.debug("shell spawn error", err2);
             finish(`[exit 1] ${err2?.message ?? err2}${out ? "\n" + clean(out) : ""}`);
           });
           proc.on("close", (code) => {
@@ -1868,7 +2177,7 @@ ${clean(out) || "(no output yet)"}`;
     }
   ];
 }
-var log14, clean, DETACHED, SECRET_ENV_RE, _spawn, ShellJobRegistry, NO_JOB2;
+var log16, clean, DETACHED, SECRET_ENV_RE, _spawn, ShellJobRegistry, NO_JOB2;
 var init_tools_shell = __esm({
   "src/tools.shell.ts"() {
     "use strict";
@@ -1876,7 +2185,7 @@ var init_tools_shell = __esm({
     init_redact();
     init_logging();
     init_shell_sandbox();
-    log14 = forComponent("shell");
+    log16 = forComponent("shell");
     clean = (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;
@@ -1958,8 +2267,8 @@ var init_tools_shell = __esm({
 
 // cli/cli.ts
 import { createInterface } from "readline/promises";
-import { existsSync as existsSync9, readFileSync as readFileSync8, appendFileSync, mkdirSync as mkdirSync12, writeFileSync as writeFileSync9, readdirSync as readdirSync4, statSync as statSync4, unlinkSync as unlinkSync5 } from "fs";
-import { homedir as homedir10, tmpdir as tmpdir3 } from "os";
+import { existsSync as existsSync9, readFileSync as readFileSync9, appendFileSync, mkdirSync as mkdirSync12, writeFileSync as writeFileSync9, readdirSync as readdirSync4, statSync as statSync5, unlinkSync as unlinkSync5 } from "fs";
+import { homedir as homedir10 } from "os";
 import { spawnSync as spawnSync6 } from "child_process";
 
 // cli/clipboard.ts
@@ -2027,21 +2336,11 @@ function copyTextToClipboard(text, platform2 = process.platform) {
 }
 
 // cli/cli.ts
-import { join as join14, resolve as resolve3, basename as basename2, extname, dirname as dirname5 } from "path";
+import { join as join14, resolve as resolve4, basename as basename2, extname, dirname as dirname5 } from "path";
 import { AIClient, listModels, listProviders, getProviderFromModel, getModelInfo, resolveModel, isModelSupported, disposeCursorSessions, disposeClaudeCodeSessions } from "ai.libx.js";
 
-// src/llm.ts
-function contentText(content) {
-  if (content == null) return "";
-  if (typeof content === "string") return content;
-  return content.map((p) => p.type === "text" ? p.text ?? "" : "[image]").join(p_sep(content));
-}
-var p_sep = (parts) => parts.length > 1 ? "\n" : "";
-function imagePart(url) {
-  return { type: "image_url", image_url: { url } };
-}
-
 // src/Agent.ts
+init_llm();
 init_tools();
 
 // src/tools.jobs.ts
@@ -2680,7 +2979,7 @@ init_OverlayFilesystem();
 init_worktree();
 init_NodeDiskFilesystem();
 init_logging();
-var log3 = forComponent("subagent");
+var log5 = forComponent("subagent");
 async function boundedPool(items, limit, fn) {
   const out = new Array(items.length);
   let next = 0;
@@ -2722,7 +3021,7 @@ function traceFileFor(dir, label, depth) {
     const id = `${Date.now().toString(36)}-${(traceSeq++).toString(36)}`;
     return join4(dir, `${id}-d${depth}-${sanitizeSlug(label) || "sub"}.json`);
   } catch (e) {
-    log3.warn(`subagent trace dir unavailable (${dir}) \u2014 running without a trace: ${e instanceof Error ? e.message : String(e)}`);
+    log5.warn(`subagent trace dir unavailable (${dir}) \u2014 running without a trace: ${e instanceof Error ? e.message : String(e)}`);
     return void 0;
   }
 }
@@ -2730,7 +3029,7 @@ function flushTrace(file, meta, messages, status) {
   try {
     writeFileSync2(file, JSON.stringify({ ...meta, status, updated: Date.now(), messages }, null, 2));
   } catch (e) {
-    log3.warn(`subagent trace flush failed (${file}): ${e instanceof Error ? e.message : String(e)}`);
+    log5.warn(`subagent trace flush failed (${file}): ${e instanceof Error ? e.message : String(e)}`);
   }
 }
 function installTrace(child, file, meta) {
@@ -3191,7 +3490,11 @@ function reasoningToChatFragment(model, effort) {
 }
 
 // src/Agent.ts
-var log4 = forComponent("Agent");
+var log6 = forComponent("Agent");
+function envInt(key, fallback) {
+  const n = typeof process !== "undefined" ? Number(process.env?.[key]) : NaN;
+  return Number.isFinite(n) && n >= 0 ? n : fallback;
+}
 function isBrowserTool(name) {
   return name.startsWith("mcp__") && /browser/i.test(name.slice(5).split("__")[0]);
 }
@@ -3217,8 +3520,9 @@ var AgentOptions = class {
   /** Hard ceiling on accumulated tokens (prompt+completion) across the run; cache READS count at 0.1×
    *  (their real price) so a fat cached context doesn't trip the guard on healthy turns. 0 = unbounded. */
   maxTokens = 2e5;
-  /** Wall-clock ceiling in ms for the whole run. 0 = unbounded. */
-  timeoutMs = 12e4;
+  /** Idle ceiling in ms: max time since the last productive step before the run is killed (a long/active
+   *  step resets it — see runLoop's `lastProgressAt`). Not a whole-run wall clock. 0 = unbounded. */
+  timeoutMs = 3e5;
   /** Idle-stall watchdog for a SINGLE streamed model request: abort it if no chunk (text OR reasoning)
    *  arrives for this long. The between-steps `timeoutMs` can't preempt an in-flight `chat()`, so a
    *  provider that goes silent mid-stream would otherwise park the loop forever. 0 = off. */
@@ -3229,15 +3533,33 @@ var AgentOptions = class {
   maxToolCalls = 100;
   /** External cancellation — abort the loop between steps (e.g. a UI "Cancel" button). */
   signal;
+  /** Retry budget for an EMPTY/silent-turn (a delegated-runtime wedge: cursor's warm helper spins then
+   *  returns a content-less end, surfaced as `code:'empty'`/`code:'cursor_silent'`). Tuned WIDER than the
+   *  network-drop budget (fixed 2) because clearing a wedge needs several reap+respawn cycles — each retry
+   *  hits a FRESH cursor session (the adapter evicts the wedged warm helper on the silent-end). Still bounded:
+   *  after exhaustion the turn surfaces `finishReason:'empty'` (non-zero exit), never infinite, never silent.
+   *  Env: AGENTX_EMPTY_RETRIES. */
+  emptyRetries = envInt("AGENTX_EMPTY_RETRIES", 4);
+  /** Base backoff (ms) between empty-turn retries; grows linearly per attempt (longer than the network
+   *  class's fixed 1s so a wedged helper has time to be reaped/respawned). Env: AGENTX_EMPTY_RETRY_BASE_MS. */
+  emptyRetryBaseMs = envInt("AGENTX_EMPTY_RETRY_BASE_MS", 1500);
   /** 0 = never trim. Otherwise cap the messages sent per turn (system + most recent). */
   maxContextMessages = 0;
   /** Note-taking: keep the most-recent N tool-result outputs verbatim; collapse OLDER ones to a one-line
    *  stub in the sent context (the model already consumed them — it can re-Read/re-run). The stored
    *  transcript is never mutated. 0 = keep all verbatim. */
   keepToolOutputs = 0;
+  /** How many of the most-recent image-bearing messages get their image REF expanded to real base64 in
+   *  the outgoing request. Older ones (and legacy inline base64) go on the wire as the elision stub. */
+  keepRecentImages = 1;
   /** Token-aware backstop (~4 chars/token estimate). After note-taking, drop oldest messages from the
    *  sent context until the estimate is under this ceiling (pairing-safe). 0 = off. */
   maxContextTokens = 0;
+  /** The MODEL's context window (tokens) — what the context % is measured against and what `/compact`
+   *  targets 50% of. Filled by the CLI from model metadata; 0 = fall back to 200k. Deliberately NOT
+   *  `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;
   /** 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). */
@@ -3293,8 +3615,10 @@ var AgentOptions = class {
   /** Stream tokens from the model. Takes effect only with a `host.notify`; off => current (non-stream) behavior. */
   stream = false;
   /** Closure reflex for delegated runtimes (cursor/claude-code): when such a turn ends on a tool call with
-   *  no assistant text after it (the runtime went silent post-work), nudge ONE more step for a brief summary
-   *  of what changed + what's pending — so the turn delivers a wrap-up instead of trailing off mid-narration.
+   *  no assistant text after it (the runtime went silent post-work), nudge ONE more step to ANSWER the user
+   *  from the tool results already in the transcript — so the turn delivers a reply instead of trailing off
+   *  mid-narration. Deliberately not a "summarize what you did" nudge: that produced process reports and
+   *  permission-asking instead of answers (see the nudge text in runLoop).
    *  Fires at most once per run and only for delegated runtimes (native turns never emit the trigger). */
   closeDelegatedTurns = true;
   /** Fold the dropped middle of an over-long transcript into a synthetic summary (edge-safe, no LLM). Off => drop-oldest. */
@@ -3481,7 +3805,7 @@ var Agent = class _Agent {
       const disk = new NodeDiskFilesystem2(process.cwd());
       await disk.init();
       this.options.fs = new JailedFilesystem2(disk);
-      log4.info(`no fs provided \u2014 defaulting to jailed real disk at ${process.cwd()}`);
+      log6.info(`no fs provided \u2014 defaulting to jailed real disk at ${process.cwd()}`);
     }
     this.buildCtx();
   }
@@ -3599,19 +3923,42 @@ var Agent = class _Agent {
     return this.runLoop();
   }
   /**
-   * Fold the conversation in place (manual `/compact`): keep the system message + the
-   * most-recent window, summarizing the dropped middle (deterministic, no LLM call).
-   * No-op when the transcript already fits. Returns the number of messages removed.
-   * `focus` (e.g. from `/compact keep the API details`) preserves matching lines from the
-   * dropped span verbatim in the summary, instead of losing them to the generic recap.
+   * Fold the conversation in place (manual `/compact`) until it fits a TOKEN budget — not a message
+   * count. Message-count folding alone frees almost nothing when a few recent tool results are huge,
+   * so we escalate: fold the middle into a synthetic recap → elide oversized tool-result bodies in the
+   * retained window → halve the window → drop-oldest backstop. Deterministic, no LLM call.
+   * `focus` (e.g. `/compact keep the API details`) preserves matching lines from the dropped span verbatim.
+   * Returns before/after token estimates so the caller can report honestly (0 freed => say so).
    */
   compactNow(maxMessages = 12, focus) {
-    const max = Math.max(2, maxMessages);
-    if (this.transcript.length <= max) return 0;
+    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 msgsBefore = this.transcript.length;
+    let max = Math.max(2, maxMessages);
+    if (this.transcript.length <= max && tokensBefore <= target)
+      return { tokensBefore, tokensAfter: tokensBefore, target, cap, removed: 0 };
     void this.activeHooks?.onPreCompact?.(this.transcript);
-    const before = this.transcript.length;
-    this.transcript = compact(this.transcript, max, focus);
-    return before - this.transcript.length;
+    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) {
+      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);
+    out = dropOrphanToolResults(out);
+    this.transcript = out;
+    this.releaseStaleImages();
+    return { tokensBefore, tokensAfter: estimateTokens(this.transcript, kr), 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) {
+    const next = elideStaleImages(this.transcript, keepRecent);
+    if (next !== this.transcript) this.transcript = next;
   }
   async runLoop() {
     const o = this.options;
@@ -3627,15 +3974,16 @@ var Agent = class _Agent {
     let lastFp = "";
     let repeats = 0;
     let closureNudged = false;
+    let lastProgressAt = start;
     const kill = (finishReason) => {
-      log4.warn(`kill-switch: ${finishReason} (steps=${steps}, tokens=${usage.totalTokens}, budgetTokens=${Math.round(usage.totalTokens - 0.9 * usage.cacheReadTokens)}, ms=${Date.now() - start - this.parkedMs}${this.parkedMs ? ` +${this.parkedMs} parked` : ""})`);
+      log6.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.ctx.jobs?.killAll();
       return { text: lastAssistantText(this.transcript), steps, finishReason, messages: this.transcript, usage, usageEstimated };
     };
     while (true) {
       if (o.signal?.aborted) return kill("aborted");
       if (steps >= o.maxSteps) return kill("max_steps");
-      if (o.timeoutMs && Date.now() - start - this.parkedMs >= o.timeoutMs) return kill("timeout");
+      if (o.timeoutMs && Date.now() - lastProgressAt - this.parkedMs >= o.timeoutMs) return kill("timeout");
       const budgetTokens = usage.totalTokens - 0.9 * usage.cacheReadTokens;
       if (o.maxTokens && budgetTokens >= o.maxTokens) return kill("budget");
       steps++;
@@ -3675,27 +4023,38 @@ var Agent = class _Agent {
               const r = await o.ai.chat({ model: o.model, messages: sent, tools: sentTools, stream: false, signal: o.signal, ...o.toolChoice ? { toolChoice: o.toolChoice } : {}, ...reasonOpts });
               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)");
+              e.code = "empty";
+              throw e;
+            }
             break;
           } catch (err2) {
             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));
             const stalled = err2?.code === "stall";
-            const transient = !o.signal?.aborted && !isAbortError(err2) && attempt < 2 && (network || serverSide || stalled);
+            const empty = err2?.code === "empty" || err2?.code === "cursor_silent";
+            const maxAttempts = empty ? Math.max(o.emptyRetries, 0) : 2;
+            const transient = !o.signal?.aborted && !isAbortError(err2) && attempt < maxAttempts && (network || serverSide || stalled || empty);
             if (!transient) throw err2;
-            const waitMs = 1e3 * (attempt + 1);
-            log4.warn(`${stalled ? "model stall" : "network drop"} mid-step (${err2?.message ?? err2}) \u2014 retrying in ${waitMs}ms`);
-            o.host?.notify?.({ kind: "retry", message: `${stalled ? "model stalled" : "connection dropped"} \u2014 retrying step (#${attempt + 1})` });
+            const waitMs = (empty ? o.emptyRetryBaseMs : 1e3) * (attempt + 1);
+            log6.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));
           }
         }
       } catch (err2) {
         if (err2?.code === "budget") return kill("budget");
         if (err2?.code === "stall") {
-          log4.warn(`model stalled out after retries: ${err2?.message ?? err2}`);
+          log6.warn(`model stalled out after retries: ${err2?.message ?? err2}`);
           return kill("timeout");
         }
         if (o.signal?.aborted || isAbortError(err2)) return kill("aborted");
+        if (err2?.code === "empty" || err2?.code === "cursor_silent") {
+          log6.warn(`model returned empty/silent turns after retries \u2014 surfacing as failed`);
+          return { text: "", steps, finishReason: "empty", messages: this.transcript, usage, usageEstimated, error: err2 };
+        }
         const body = err2?.body ?? err2?.response?.data ?? err2?.error;
         let bodyStr;
         try {
@@ -3705,7 +4064,7 @@ 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;
-        log4.error(`chat() failed: ${err2?.message ?? err2}${bodyStr ? ` \u2014 ${bodyStr}` : ""}`, errLog);
+        log6.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");
@@ -3749,6 +4108,7 @@ var Agent = class _Agent {
       }
       const toolCalls = res.toolCalls ?? [];
       const emptyTurn = toolCalls.length === 0 && delegatedTools.length === 0 && contentText(res.content ?? "").trim() === "";
+      if (!emptyTurn) lastProgressAt = Date.now();
       if (!emptyTurn) {
         this.transcript.push({
           role: "assistant",
@@ -3760,12 +4120,16 @@ var Agent = class _Agent {
         if (this.drainInjections()) continue;
         if (o.closeDelegatedTurns && res.endedOnToolNoText && !closureNudged && steps < o.maxSteps) {
           closureNudged = true;
-          log4.verbose("delegated turn went silent after a tool \u2014 nudging a closing summary");
-          this.transcript.push({ role: "user", content: "Summarize what you did this turn and what (if anything) still needs doing. Be concise." });
+          log6.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;
         }
-        log4.verbose(`completed in ${steps} step(s)`);
+        log6.verbose(`completed in ${steps} step(s)`);
         await this.ctx.jobs?.drain();
+        this.releaseStaleImages();
         await this.activeHooks?.onStop?.(res.content ?? "");
         return { text: res.content ?? "", steps, finishReason: "stop", messages: this.transcript, usage, usageEstimated };
       }
@@ -3791,7 +4155,7 @@ var Agent = class _Agent {
       if (this.ctx.needsInput) {
         const question = this.ctx.needsInput;
         this.ctx.needsInput = void 0;
-        log4.warn(`needs_input: ${question.question} (steps=${steps})`);
+        log6.warn(`needs_input: ${question.question} (steps=${steps})`);
         await this.ctx.jobs?.drain();
         const text = [
           `OPEN QUESTION (run paused \u2014 no human was reachable): ${question.question}`,
@@ -3848,6 +4212,12 @@ var Agent = class _Agent {
       }
     };
   }
+  /** A clean-stop turn that carries no assistant text AND no tool calls (native or delegated) — a
+   *  non-result the model produced by going silent. Callers retry it rather than report "done". */
+  isEmptyStop(res) {
+    const stop = res.finishReason === "stop" || res.finishReason == null;
+    return stop && (res.toolCalls?.length ?? 0) === 0 && (res.delegatedTools?.length ?? 0) === 0 && contentText(res.content ?? "").trim() === "";
+  }
   async consumeStream(stream, poke) {
     let content = "";
     let finishReason;
@@ -3906,13 +4276,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"}`;
-      log4.debug(`${tc.function.name} -> ${blocked}`);
+      log6.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) {
-      log4.debug(`${tc.function.name} -> ${earlyError}`);
+      log6.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;
@@ -3921,12 +4291,12 @@ var Agent = class _Agent {
     let images;
     let threw = false;
     try {
-      log4.debug(`${tc.function.name}(${tc.function.arguments})`);
+      log6.debug(`${tc.function.name}(${tc.function.arguments})`);
       this.ctx.emit = hooks?.onToolOutput ? (chunk) => {
         try {
           hooks.onToolOutput(call, chunk, meta);
         } catch (e) {
-          log4.debug(`onToolOutput hook error: ${e}`);
+          log6.debug(`onToolOutput hook error: ${e}`);
         }
       } : void 0;
       const raw = await tool.run(args, this.ctx);
@@ -3938,7 +4308,7 @@ var Agent = class _Agent {
       }
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
-      log4.debug(`${tc.function.name} -> error: ${msg}`);
+      log6.debug(`${tc.function.name} -> error: ${msg}`);
       result = `Error: ${msg}`;
       threw = true;
     } finally {
@@ -3964,6 +4334,16 @@ var Agent = class _Agent {
     }
     return images?.length ? { text: result, images } : result;
   }
+  /** `/compact` aims to land the transcript at this fraction of the context window. */
+  static COMPACT_TARGET = 0.5;
+  /** THE context-window cap resolution — `/compact`'s budget and the CLI's context footer/warnings both
+   *  route here, so the percentage the user reads and the one compaction targets can never drift. */
+  static contextCap(o) {
+    if (o.maxContextTokens) return o.maxContextTokens;
+    const w = o.contextWindow || 0;
+    if (w > ANTHROPIC_WINDOW_WITHOUT_1M_BETA && isAnthropicModel(o.model)) return ANTHROPIC_WINDOW_WITHOUT_1M_BETA;
+    return w || 2e5;
+  }
   static WRITE_CLASS = ["Write", "Edit", "MultiEdit", "ApplyEdits"];
   /** Append an autoTest failure section to a write-class tool result, if configured. */
   async maybeAutoTest(toolName, result) {
@@ -3997,26 +4377,27 @@ ${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);
     if (o.maxContextTokens) {
-      const pre = (out ?? m).length;
-      out = fitTokenBudget(out ?? m, o.maxContextTokens);
+      const pre = out.length;
+      out = fitTokenBudget(out, o.maxContextTokens, o.keepRecentImages ?? 1);
       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 ?? m);
+    return dropOrphanToolResults(out);
   }
 };
 function dropOldest(m, max) {
   const head = m[0]?.role === "system" ? [m[0]] : [];
   return [...head, ...m.slice(-(max - head.length))];
 }
-function estimateTokens(m) {
-  let chars = 0;
-  for (const x of m) chars += contentText(x.content).length + (x.tool_calls ? JSON.stringify(x.tool_calls).length : 0);
-  return Math.ceil(chars / 4);
+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 cropResult(result, cap) {
   const head = result.slice(0, cap);
@@ -4050,6 +4431,60 @@ function stubOldToolResults(messages, keep) {
     return { ...x, content: `[${x.name ?? "tool"}${where ? ` ${where}` : ""} output elided \u2014 ${lines} lines; re-run the tool to view]` };
   });
 }
+function elideOversizedImages(messages, target, protectNewest = false, keepRecentImages = 1) {
+  let out = messages;
+  const withImages = out.map((_, i) => i).filter((i) => messageHasImage(out[i].content));
+  const newest = protectNewest ? withImages[withImages.length - 1] : -1;
+  const weight = sendBytesPer(out, keepRecentImages);
+  const heaviestFirst = withImages.filter((i) => i !== newest).sort((a, b) => weight[b] - weight[a]);
+  for (const i of heaviestFirst) {
+    if (estimateTokens(out, keepRecentImages) <= target) break;
+    const c = elideImages(out[i].content);
+    if (c === out[i].content) continue;
+    out = out.map((m, j) => j === i ? { ...m, content: c } : m);
+  }
+  return out;
+}
+function capOversizedBodies(messages, target, keepRecentImages = 1) {
+  let out = messages;
+  for (const cap of [8e3, 4e3, 2e3, 800, 300, 120]) {
+    if (estimateTokens(out, keepRecentImages) <= target) break;
+    out = out.map((x) => x.role === "system" ? x : elideBody(x, cap));
+  }
+  return out;
+}
+function elideBody(x, cap) {
+  const note = (bytes, imgs2) => `
+
+[${bytes} bytes elided by /compact${x.role === "tool" ? " \u2014 re-run the tool to view" : ""}${imgs2 ? `; ${imgs2} image part(s) KEPT in full \u2014 they still cost context` : ""}]`;
+  if (!Array.isArray(x.content)) {
+    const text = contentText(x.content);
+    if (text.length <= cap) return x;
+    return { ...x, content: `${text.slice(0, cap)}${note(text.length - cap, 0)}` };
+  }
+  const imgs = x.content.filter((p) => p.type !== "text").length;
+  let left = cap;
+  let elided = 0;
+  const parts = [];
+  for (const p of x.content) {
+    if (p.type !== "text") {
+      parts.push(p);
+      continue;
+    }
+    const t = p.text ?? "";
+    if (t.length <= left) {
+      left -= t.length;
+      if (t) parts.push(p);
+      continue;
+    }
+    const keep = left;
+    left = 0;
+    elided += t.length - keep;
+    if (keep > 0) parts.push({ ...p, text: t.slice(0, keep) });
+  }
+  if (!elided) return parts.length === x.content.length || !parts.length ? x : { ...x, content: parts };
+  return { ...x, content: [...parts, { type: "text", text: note(elided, imgs).trimStart() }] };
+}
 var callIdSet = (msgs) => {
   const ids = /* @__PURE__ */ new Set();
   for (const m of msgs) if (m.role === "assistant") for (const tc of m.tool_calls ?? []) ids.add(tc.id);
@@ -4060,8 +4495,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) {
-  const per = messages.map((x) => estimateTokens([x]));
+function fitTokenBudget(messages, maxTokens, keepRecentImages = 1) {
+  const per = sendBytesPer(messages, keepRecentImages).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]] : [];
@@ -4070,7 +4505,7 @@ function fitTokenBudget(messages, maxTokens) {
   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)
-    log4.warn(`context ~${total} tok still over maxContextTokens=${maxTokens} after trimming (system head can't be dropped)`);
+    log6.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) {
@@ -4082,11 +4517,24 @@ function compact(m, max, focus) {
   if (dropped.length === 0) return [...head, ...tail];
   return [...head, { role: "system", content: summarize(dropped, focus) }, ...tail];
 }
+var SUMMARY_HEAD = "[summary of ";
+var MAX_CARRIED_COUNT = 1e4;
+var isSyntheticSummary = (m) => m.role === "system" && typeof m.content === "string" && m.content.startsWith(SUMMARY_HEAD);
 function summarize(messages, focus) {
   const tools = /* @__PURE__ */ new Set();
   const files = /* @__PURE__ */ new Set();
+  const carried = [];
+  let carriedCount = 0;
+  let priors = 0;
   let lastAssistant = "";
   for (const msg of messages) {
+    if (isSyntheticSummary(msg)) {
+      priors++;
+      const [head, ...rest] = String(msg.content).split("\n");
+      carriedCount += Math.min(Math.max(Number(/of (\d+)/.exec(head)?.[1]) || 0, 0), MAX_CARRIED_COUNT);
+      for (const l of rest) if (l.trim() && !carried.includes(l) && carried.length < 20) carried.push(l);
+      continue;
+    }
     for (const tc of msg.tool_calls ?? []) {
       tools.add(tc.function.name);
       try {
@@ -4097,14 +4545,16 @@ function summarize(messages, focus) {
     }
     if (msg.role === "assistant" && msg.content) lastAssistant = contentText(msg.content);
   }
-  const lines = [`[summary of ${messages.length} earlier message(s)]`];
+  const lines = [`${SUMMARY_HEAD}${messages.length - priors + carriedCount} earlier message(s)]`];
   if (tools.size) lines.push(`tools used: ${[...tools].join(", ")}`);
   if (files.size) lines.push(`files touched: ${[...files].join(", ")}`);
   if (lastAssistant) lines.push(`last assistant: ${lastAssistant}`);
+  if (carried.length) lines.push("earlier recap:", ...carried.map((l) => `  ${l}`));
   if (focus?.trim()) {
     const words = focus.toLowerCase().split(/\s+/).filter((w) => w.length > 2);
     const kept = [];
-    outer: for (const msg of messages) {
+    const ordered = [...messages.filter((m) => !isSyntheticSummary(m)), ...messages.filter(isSyntheticSummary)];
+    outer: for (const msg of ordered) {
       if (msg.role === "tool") continue;
       for (const line of contentText(msg.content).split("\n")) {
         const l = line.toLowerCase();
@@ -4627,7 +5077,7 @@ init_tools_web();
 init_tools();
 init_tools_structured();
 init_logging();
-var log5 = forComponent("scratch");
+var log7 = forComponent("scratch");
 var SCRATCH_DIR = "/scratch";
 function shortArgs(args) {
   try {
@@ -4667,7 +5117,7 @@ var Scratch = class {
           await (this.dirReady ??= mkdirp(this.fs, dir));
           await this.fs.writeFile(path, header + raw);
         } catch (e) {
-          log5.debug("scratch write failed; returning raw", e);
+          log7.debug("scratch write failed; returning raw", e);
           return raw;
         }
         const preview = raw.slice(0, previewChars).replace(/\s+/g, " ").trim();
@@ -4697,7 +5147,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) {
-      log5.debug("scratch spill failed; cropping lossy", e);
+      log7.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]`;
@@ -4743,7 +5193,7 @@ Question: ${q2}`);
         const answer = (res.text ?? "").trim();
         return answer || "(no answer found in scratch)";
       } catch (e) {
-        log5.debug("Ask peek failed", e);
+        log7.debug("Ask peek failed", e);
         return `Error querying scratch: ${e?.message ?? e}`;
       }
     }
@@ -4752,7 +5202,7 @@ Question: ${q2}`);
 
 // src/lessons.ts
 init_logging();
-var log6 = forComponent("Lessons");
+var log8 = forComponent("Lessons");
 var LessonOptionsDefaults = class {
   minRepeats = 2;
 };
@@ -4777,15 +5227,16 @@ 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) => log6.warn(`could not persist ${lesson.slug}: ${e?.message ?? e}`));
-      log6.debug(`captured lesson ${lesson.slug} (recurred ${n}\xD7)`);
+      await writeFact(o.fs, o.dir, lesson.slug, lesson.body).catch((e) => log8.warn(`could not persist ${lesson.slug}: ${e?.message ?? e}`));
+      log8.debug(`captured lesson ${lesson.slug} (recurred ${n}\xD7)`);
     }
   };
 }
 
 // src/reflect.ts
+init_llm();
 init_logging();
-var log7 = forComponent("Reflect");
+var log9 = forComponent("Reflect");
 async function reflectOnRun(o) {
   const digest = digestRun(o.result.messages, o.maxDigestChars ?? 6e3);
   if (!digest.trim()) return null;
@@ -4801,7 +5252,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) {
-    log7.warn(`reflection call failed: ${e?.message ?? e}`);
+    log9.warn(`reflection call failed: ${e?.message ?? e}`);
     return null;
   }
   const m = text.match(/LESSON:\s*(.+)/i);
@@ -4811,10 +5262,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) {
-    log7.warn(`could not persist lesson: ${e?.message ?? e}`);
+    log9.warn(`could not persist lesson: ${e?.message ?? e}`);
     return null;
   }
-  log7.debug(`reflection persisted ${slug2}`);
+  log9.debug(`reflection persisted ${slug2}`);
   return slug2;
 }
 function digestRun(messages, maxChars) {
@@ -4830,6 +5281,7 @@ function digestRun(messages, maxChars) {
 
 // src/duplex.ts
 import { MemFilesystem as MemFilesystem2 } from "@livx.cc/wcli/core";
+init_llm();
 init_logging();
 
 // node_modules/@bod.ee/voice/src/core/logging.ts
@@ -4862,7 +5314,7 @@ function forComponent2(name) {
 }
 
 // node_modules/@bod.ee/voice/src/core/emotion.ts
-var log8 = forComponent2("Emotion");
+var log10 = forComponent2("Emotion");
 var EMOTIONS = [
   // primary (best results)
   "neutral",
@@ -4994,7 +5446,7 @@ function renderEmotions(text, opts = { show: true }) {
       speech += cartesiaTag(tag);
       if (opts.show) display += m[0];
     } else {
-      log8.debug(`dropping unknown emotion tag ${m[0]}`);
+      log10.debug(`dropping unknown emotion tag ${m[0]}`);
     }
     last = m.index + m[0].length;
   }
@@ -5036,7 +5488,7 @@ var EmotionStream = class {
       if (tag) {
         this.pending = tag;
         if (this.show) display += m[0];
-      } else log8.debug(`dropping unknown emotion tag ${m[0]}`);
+      } else log10.debug(`dropping unknown emotion tag ${m[0]}`);
       last = m.index + m[0].length;
     }
     this.emit(body.slice(last), (s, d, p) => {
@@ -5059,7 +5511,7 @@ var EmotionStream = class {
 };
 
 // node_modules/@bod.ee/voice/src/core/engine.ts
-var log9 = forComponent2("VoiceEngine");
+var log11 = forComponent2("VoiceEngine");
 var realClock = {
   now: () => performance.now(),
   setTimeout: (fn, ms) => setTimeout(fn, ms),
@@ -5334,7 +5786,7 @@ var VoiceEngine = class _VoiceEngine {
     await Promise.all([this.tts.connect(), this.stt.start()]);
     this.tts.warmup?.();
     this.setState("listening");
-    log9.debug(`voice I/O up (${this.stt.usingAec ? "AEC" : "heuristic echo"} capture)`);
+    log11.debug(`voice I/O up (${this.stt.usingAec ? "AEC" : "heuristic echo"} capture)`);
   }
   get usingAec() {
     return this.stt.usingAec;
@@ -5356,7 +5808,7 @@ var VoiceEngine = class _VoiceEngine {
       this.options.onDiag({ t: this.clock.now(), kind, ...fields });
     } catch (e) {
       this.diagOn = false;
-      log9.debug(`onDiag threw \u2014 diagnostics disabled: ${e instanceof Error ? e.message : e}`);
+      log11.debug(`onDiag threw \u2014 diagnostics disabled: ${e instanceof Error ? e.message : e}`);
     }
   }
   idleWaiters = [];
@@ -5465,7 +5917,7 @@ var VoiceEngine = class _VoiceEngine {
     if (prose.trim()) this.repliedSinceDispatch = true;
     for (const w of this.words(this.reply)) this.echoWords.add(w);
     this.tts.speak(forSpeech(speech), true);
-    if (!this.spokeDeltas && this.turnStartAt) log9.debug(`ttft: ${Math.round(this.clock.now() - this.turnStartAt)}ms`);
+    if (!this.spokeDeltas && this.turnStartAt) log11.debug(`ttft: ${Math.round(this.clock.now() - this.turnStartAt)}ms`);
     this.spokeDeltas = true;
     this.setState("speaking");
     if (this.options.revealMode !== "off" && display) {
@@ -5542,7 +5994,7 @@ var VoiceEngine = class _VoiceEngine {
       this.drainTimer = null;
       this.speaking = false;
       this.stopWordReveal(true);
-      if (this.turnStartAt) log9.debug(`turn: ${Math.round(this.clock.now() - this.turnStartAt)}ms (incl. playback)`);
+      if (this.turnStartAt) log11.debug(`turn: ${Math.round(this.clock.now() - this.turnStartAt)}ms (incl. playback)`);
       this.echoUntil = this.clock.now() + 2500;
       if (!this.usingAec) this.stt.reset();
       this.setState("listening");
@@ -5630,7 +6082,7 @@ var VoiceEngine = class _VoiceEngine {
     this.clearAckTimer("interrupt");
     this.adaptiveAckFired = false;
     this.ackProbe = null;
-    if (this.uttQueue.length) log9.info(`barge-in dropped ${this.uttQueue.length} queued worker utterance(s)`);
+    if (this.uttQueue.length) log11.info(`barge-in dropped ${this.uttQueue.length} queued worker utterance(s)`);
     const droppedQueued = this.uttQueue.length;
     this.uttQueue = [];
     if (!this.speaking && !this.drainTimer) return;
@@ -5776,7 +6228,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;
-      log9.debug(`speculate: "${this.specText.slice(0, 60)}"`);
+      log11.debug(`speculate: "${this.specText.slice(0, 60)}"`);
       this.diag("speculate", { text: this.specText });
       this.options.onSpeculate(this.specText);
     }, this.options.speculativeMs);
@@ -5845,7 +6297,7 @@ var VoiceEngine = class _VoiceEngine {
     };
     this.tts.newContext();
     this.tts.speak(phrase, false);
-    log9.debug(`backchannel: "${phrase}"`);
+    log11.debug(`backchannel: "${phrase}"`);
     this.diag("backchannel", { phrase });
     this.options.onBackchannel(phrase);
   }
@@ -5878,7 +6330,7 @@ var VoiceEngine = class _VoiceEngine {
     });
     if (idx < 0) return text;
     toks.splice(idx, 1);
-    log9.verbose(`stripped backchannel echo "${this.lastBcPhrase}" from dispatching final`);
+    log11.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
@@ -5969,7 +6421,7 @@ var VoiceEngine = class _VoiceEngine {
     this.pendingUtt = this.mergeUtterance(this.pendingUtt, text);
     if (this.pendingTimer) this.clock.clearTimeout(this.pendingTimer);
     if (this.options.incompleteMergeMs && this.looksIncomplete(this.pendingUtt)) {
-      log9.verbose(`hold: incomplete utterance "${this.pendingUtt.slice(-40)}"`);
+      log11.verbose(`hold: incomplete utterance "${this.pendingUtt.slice(-40)}"`);
       this.diag("hold", { reason: "incomplete", tail: this.pendingUtt.slice(-40) });
       this.options.onHold();
       if (this.options.holdFiller && !this.speaking) this.speakFiller(this.options.holdFiller);
@@ -6004,13 +6456,13 @@ var VoiceEngine = class _VoiceEngine {
     if (text) {
       const flat = text.toLowerCase().replace(/[^a-z0-9]/g, "");
       if (flat && flat === this.lastDispatchFlat && !this.repliedSinceDispatch && this.clock.now() - this.lastDispatchAt < _VoiceEngine.DUP_FINAL_MS) {
-        log9.verbose(`dropped duplicate final "${text.slice(0, 40)}" (identical to the just-dispatched utterance, no reply between)`);
+        log11.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) {
-        log9.verbose(`dropped re-finalization "${text.slice(0, 60)}" (superset of the just-dispatched utterance, reply already flowing)`);
+        log11.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+/);
@@ -6170,7 +6622,7 @@ var SpokenSplitter = class {
 };
 
 // node_modules/@bod.ee/voice/src/adapters/soniox.ts
-var log10 = forComponent2("SonioxSTT");
+var log12 = forComponent2("SonioxSTT");
 var now = () => performance.now();
 var SonioxSTTOptions = class {
   auth = "";
@@ -6211,7 +6663,7 @@ var SonioxSTT = class {
       this.onDiag({ t: now(), kind, ...fields });
     } catch (e) {
       this.diagOn = false;
-      log10.debug(`onDiag threw \u2014 STT diagnostics disabled: ${e instanceof Error ? e.message : e}`);
+      log12.debug(`onDiag threw \u2014 STT diagnostics disabled: ${e instanceof Error ? e.message : e}`);
     }
   }
   lastChunkAt = 0;
@@ -6253,11 +6705,11 @@ var SonioxSTT = class {
     this.ws.onmessage = (ev) => this.handle(JSON.parse(String(ev.data)));
     this.ws.onclose = (ev) => {
       if (this.stopped) return;
-      log10.warn(`soniox ws closed (${ev.code} ${ev.reason || ""}) \u2014 reconnecting`);
+      log12.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) => {
-        log10.error(`soniox reconnect failed: ${e.message}`);
+        log12.error(`soniox reconnect failed: ${e.message}`);
         this.diag("stt_reconnect_failed", { message: e.message });
       });
     };
@@ -6269,7 +6721,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) log10.debug(`stt: ${Math.round(now() - this.firstTokenAt)}ms first-token\u2192silence-endpoint, "${combined.slice(0, 60)}"`);
+      if (this.firstTokenAt) log12.debug(`stt: ${Math.round(now() - this.firstTokenAt)}ms first-token\u2192silence-endpoint, "${combined.slice(0, 60)}"`);
       this.reset();
       this.onUtterance(combined, now());
     }, 120);
@@ -6281,7 +6733,7 @@ var SonioxSTT = class {
         if (this.stopped) return;
         const ref = this.lastChunkAt || this.startedChunksAt;
         if (now() - ref > noAudioMs) {
-          log10.error(`stt: no mic audio for >${Math.round(noAudioMs / 1e3)}s \u2014 capture device stopped delivering`);
+          log12.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();
@@ -6304,7 +6756,7 @@ var SonioxSTT = class {
   handle(m) {
     if (m.error_message) {
       this.diag("stt_error", { message: String(m.error_message), code: m.error_code });
-      return log10.error(`soniox: ${m.error_message}`);
+      return log12.error(`soniox: ${m.error_message}`);
     }
     let endpoint = false;
     for (const t of m.tokens ?? []) {
@@ -6321,7 +6773,7 @@ var SonioxSTT = class {
     this.onPartial(combined);
     if (endpoint && this.finalText.trim()) {
       const utterance = this.finalText.trim();
-      if (this.firstTokenAt) log10.debug(`stt: ${Math.round(now() - this.firstTokenAt)}ms first-token\u2192endpoint, "${utterance.slice(0, 60)}"`);
+      if (this.firstTokenAt) log12.debug(`stt: ${Math.round(now() - this.firstTokenAt)}ms first-token\u2192endpoint, "${utterance.slice(0, 60)}"`);
       this.reset();
       this.onUtterance(utterance, now());
     }
@@ -6343,7 +6795,7 @@ var SonioxSTT = class {
 };
 
 // node_modules/@bod.ee/voice/src/adapters/cartesia.ts
-var log11 = forComponent2("CartesiaTTS");
+var log13 = forComponent2("CartesiaTTS");
 var now2 = () => performance.now();
 var CartesiaTTSOptions = class {
   auth = "";
@@ -6379,7 +6831,7 @@ var CartesiaTTS = class _CartesiaTTS {
       this.onDiag({ t: now2(), kind, ...fields });
     } catch (e) {
       this.diagOn = false;
-      log11.debug(`onDiag threw \u2014 TTS diagnostics disabled: ${e instanceof Error ? e.message : e}`);
+      log13.debug(`onDiag threw \u2014 TTS diagnostics disabled: ${e instanceof Error ? e.message : e}`);
     }
   }
   firstAudioAt = 0;
@@ -6414,11 +6866,11 @@ var CartesiaTTS = class _CartesiaTTS {
       this.ws.onerror = (e) => rej(new Error(`cartesia ws: ${e.message || "connect failed"}`));
     });
     this.ws.onclose = (ev) => {
-      log11.warn(`cartesia ws closed (${ev.code} ${ev.reason || ""})`);
+      log13.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) => {
-          log11.error(`cartesia reconnect failed: ${e.message}`);
+          log13.error(`cartesia reconnect failed: ${e.message}`);
           this.diag("tts_reconnect_failed", { message: e.message });
         });
       }
@@ -6446,12 +6898,12 @@ var CartesiaTTS = class _CartesiaTTS {
           this.down = true;
           this.downAt = now2();
           this.consecutiveOk = 0;
-          log11.warn(`TTS circuit breaker open \u2014 ${this.consecutiveErrors} consecutive errors, switching to text-only`);
+          log13.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 || "") ? log11.debug : log11.warn)(`cartesia: ${JSON.stringify(m)}`);
+          (/No valid transcripts/i.test(m.message || "") ? log13.debug : log13.warn)(`cartesia: ${JSON.stringify(m)}`);
         }
       }
     };
@@ -6466,7 +6918,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 ? log11.debug : log11.info)(`TTS recovered${downMs ? ` (down ${downMs}ms)` : ""}`);
+    (downMs < 2e3 ? log13.debug : log13.info)(`TTS recovered${downMs ? ` (down ${downMs}ms)` : ""}`);
   }
   /** Ensure the WS is open before sending — reconnects if idle-closed. */
   async ensureConnected() {
@@ -6557,7 +7009,7 @@ configureLogging((name) => {
 });
 
 // src/duplex.ts
-var log12 = forComponent("DuplexAgent");
+var log14 = 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)})` : "";
@@ -6768,7 +7220,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;
-            log12.warn(`reflex fabricated a [task \u2026] event in its spoken stream \u2014 cutting it (kept ${m.index} chars)`);
+            log14.warn(`reflex fabricated a [task \u2026] event in its spoken stream \u2014 cutting it (kept ${m.index} chars)`);
             const safe = this.reflexBuf.slice(this.reflexForwarded, m.index);
             if (!safe) return;
             if (safe.trim()) this.spokeThisTurn = true;
@@ -6861,7 +7313,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)) {
-          log12.verbose(`speculation aborted: reflex called ${call.name} on unconfirmed input`);
+          log14.verbose(`speculation aborted: reflex called ${call.name} on unconfirmed input`);
           this.abortSpeculation();
           return { block: true, reason: "Speculative turn aborted." };
         }
@@ -6899,7 +7351,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
     try {
       await this.voice.send(fallback ? "[reminder] You said nothing to the user this turn. Tell them, in ONE short spoken sentence, what just happened \u2014 no tools." : dispatched ? "[reminder] You dispatched a task but said nothing to the user. Say ONE short spoken acknowledgement now \u2014 no tools." : "[reminder] You said nothing to the user this turn. Give your ONE short spoken reply now \u2014 no tools.");
     } catch (e) {
-      log12.warn(`ack nudge failed: ${e instanceof Error ? e.message : e}`);
+      log14.warn(`ack nudge failed: ${e instanceof Error ? e.message : e}`);
     } finally {
       this.nudging = false;
     }
@@ -6992,7 +7444,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
       try {
         res = await this.voice.send(spec.text);
       } catch (e) {
-        log12.warn(`speculative turn failed: ${e instanceof Error ? e.message : e}`);
+        log14.warn(`speculative turn failed: ${e instanceof Error ? e.message : e}`);
       } finally {
         this.voice.options.signal = prevSignal;
       }
@@ -7006,7 +7458,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++;
-        log12.verbose(`speculation aborted (${this.speculativeAbortedCalls} total): "${spec.text.slice(0, 50)}"`);
+        log14.verbose(`speculation aborted (${this.speculativeAbortedCalls} total): "${spec.text.slice(0, 50)}"`);
         if (this.spec === spec) this.spec = void 0;
         return res ?? empty;
       }
@@ -7271,7 +7723,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") {
-      log12.warn(`task ${id}: verify inconclusive (${cres.finishReason})`);
+      log14.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;
@@ -7337,14 +7789,14 @@ Another agent just implemented the above. Independently check the CURRENT state
    *  '[task <id> asks] …' and resolves with the user's answer via AnswerTask — or '' on timeout/
    *  task settle (callers map '' to deny / best-judgment). Workers never block forever. */
   parkQuestion(askId, question) {
-    return new Promise((resolve4) => {
+    return new Promise((resolve5) => {
       let settled = false;
       const finish = (answer) => {
         if (settled) return;
         settled = true;
         clearTimeout(timer);
         this.pendingAsks.delete(askId);
-        resolve4(answer);
+        resolve5(answer);
       };
       const timer = setTimeout(() => {
         this.notify("task_ask_timeout", `task ${askId}: question timed out \u2014 proceeding without an answer`);
@@ -7406,8 +7858,8 @@ Another agent just implemented the above. Independently check the CURRENT state
     }
     rec.status = "done";
     rec.result = res.text;
-    const incomplete = res.finishReason !== "stop";
-    log12.verbose(`task ${id} done (${res.steps} steps${incomplete ? `, INCOMPLETE: ${res.finishReason}` : ""})`);
+    const incomplete = res.finishReason !== "stop" && res.finishReason !== "empty";
+    log14.verbose(`task ${id} done (${res.steps} steps${incomplete ? `, INCOMPLETE: ${res.finishReason}` : ""})`);
     this.notify("task_done", `task ${id} (${rec.label}) completed`, {
       id,
       text: res.text,
@@ -7449,14 +7901,14 @@ Another agent just implemented the above. Independently check the CURRENT state
   foldIfSuperseded(rec, note) {
     if (!(rec.deliveryParked && this.suppressParkedResume)) return false;
     if (note.trim()) this.voice.transcript.push({ role: "assistant", content: note });
-    log12.verbose(`task ${rec.id} settled but superseded (${rec.status}) \u2014 folded into transcript, not voiced`);
+    log14.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;
-    log12.warn(`task ${rec.id} failed: ${msg}`);
+    log14.warn(`task ${rec.id} failed: ${msg}`);
     this.notify("task_error", `task ${rec.id} (${rec.label}) failed: ${msg}`);
     if (this.foldIfSuperseded(rec, `The "${rec.label}" task failed: ${msg}`)) return;
     this.queueRevoice(this.integrationPrompt(rec, "error", msg, "error"), true);
@@ -7761,11 +8213,11 @@ function buildMcpCatalog(servers) {
   }
   return { specs, routes };
 }
-function searchOverCatalog(servers, specs, routes, resolve4, options) {
+function searchOverCatalog(servers, specs, routes, resolve5, options) {
   const tools = specs.length ? makeMcpToolSearch(specs, (name, args) => {
     const r = routes.get(name);
     if (!r) throw new Error(`unknown MCP tool '${name}' \u2014 use ToolSearch to find valid names`);
-    return resolve4(r.server, r.rawName, args ?? {});
+    return resolve5(r.server, r.rawName, args ?? {});
   }, options) : [];
   return { tools, serverNames: servers, toolCount: specs.length };
 }
@@ -7777,6 +8229,7 @@ function makeMcpToolSearchFromMounted(mounted, options) {
 
 // src/index.ts
 init_logging();
+init_llm();
 init_worktree();
 import { MemFilesystem as MemFilesystem3, IndexedDbFilesystem, CommandExecutor as CommandExecutor2, registerHeadlessCommands as registerHeadlessCommands2 } from "@livx.cc/wcli/core";
 
@@ -7784,7 +8237,7 @@ import { MemFilesystem as MemFilesystem3, IndexedDbFilesystem, CommandExecutor a
 init_logging();
 import { spawn } from "child_process";
 import { createHash } from "crypto";
-var log13 = forComponent("mcp");
+var log15 = forComponent("mcp");
 var PROTOCOL_VERSION = "2025-06-18";
 var DEFAULT_TIMEOUT_MS = 3e4;
 var StdioTransport = class {
@@ -7803,7 +8256,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) => log13.debug(`[${command}] stderr:`, chunk.trimEnd()));
+    proc.stderr.on("data", (chunk) => log15.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))));
   }
@@ -7817,7 +8270,7 @@ var StdioTransport = class {
       try {
         this.dispatch(JSON.parse(line));
       } catch (e) {
-        log13.debug("dropping non-JSON line from MCP server:", line, e);
+        log15.debug("dropping non-JSON line from MCP server:", line, e);
       }
     }
   }
@@ -7843,12 +8296,12 @@ var StdioTransport = class {
   request(method, params) {
     const id = this.nextId++;
     const timeoutMs = this.spec.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
         reject(new Error(`MCP request "${method}" timed out after ${timeoutMs}ms`));
       }, timeoutMs);
-      this.pending.set(id, { resolve: resolve4, reject, timer });
+      this.pending.set(id, { resolve: resolve5, reject, timer });
       try {
         this.write({ jsonrpc: "2.0", id, method, params });
       } catch (e) {
@@ -7866,7 +8319,7 @@ var StdioTransport = class {
     try {
       this.proc?.stdin?.end();
     } catch (e) {
-      log13.debug("stdin end failed", e);
+      log15.debug("stdin end failed", e);
     }
     this.proc?.kill();
   }
@@ -7935,7 +8388,7 @@ function parseSseResponse(body) {
       const obj = JSON.parse(trimmed.slice(5).trim());
       if (obj && (obj.result !== void 0 || obj.error !== void 0)) return obj;
     } catch (e) {
-      log13.debug("skipping unparseable SSE data line", e);
+      log15.debug("skipping unparseable SSE data line", e);
     }
   }
   return {};
@@ -7981,12 +8434,12 @@ function buildTransport(cfg) {
 }
 function withTimeout(p, ms, label) {
   if (!ms || ms <= 0) return p;
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const timer = setTimeout(() => reject(new Error(`MCP "${label}" mount exceeded ${ms}ms`)), ms);
     timer.unref?.();
     p.then((v) => {
       clearTimeout(timer);
-      resolve4(v);
+      resolve5(v);
     }, (e) => {
       clearTimeout(timer);
       reject(e);
@@ -8003,7 +8456,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) => log13.debug(`close after failed mount of "${name}": ${err2}`));
+    await client.close().catch((err2) => log15.debug(`close after failed mount of "${name}": ${err2}`));
     throw e;
   }
 }
@@ -8014,15 +8467,15 @@ function validEntries(servers) {
   return Object.entries(servers).filter(([name, cfg]) => {
     if (!cfg || cfg.disabled) return false;
     if (!cfg.command && !cfg.url) {
-      log13.warn(`MCP server "${name}" needs a command (stdio) or url (http) \u2014 skipping`);
+      log15.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) log13.warn(`MCP "${name}" needs-auth: HTTP ${e.status} \u2014 set bearerToken or headers in its config; skipping`);
-  else log13.error(`MCP server "${name}" failed to mount: ${e?.message ?? e}`);
+  if (e instanceof McpAuthError) log15.warn(`MCP "${name}" needs-auth: HTTP ${e.status} \u2014 set bearerToken or headers in its config; skipping`);
+  else log15.error(`MCP server "${name}" failed to mount: ${e?.message ?? e}`);
 }
 async function mountMcpServers(servers = {}, opts = {}) {
   const entries = validEntries(servers);
@@ -8032,7 +8485,7 @@ async function mountMcpServers(servers = {}, opts = {}) {
     const name = entries[i][0];
     if (r.status === "fulfilled") {
       out.push(r.value);
-      log13.debug(`MCP "${name}" mounted \u2014 ${r.value.tools.length} tool(s)${r.value.serverInfo?.name ? ` from ${r.value.serverInfo.name}` : ""}`);
+      log15.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;
@@ -8072,7 +8525,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) => log13.debug(`warm-pool replace close failed: ${err2}`));
+      if (prev.client !== client) void prev.client.close().catch((err2) => log15.debug(`warm-pool replace close failed: ${err2}`));
     }
     const e = { client, timer: void 0 };
     this.warm.set(key, e);
@@ -8089,7 +8542,7 @@ var McpPool = class {
     const e = this.warm.get(key);
     if (!e) return;
     this.warm.delete(key);
-    await e.client.close().catch((err2) => log13.debug(`warm-pool evict close failed: ${err2}`));
+    await e.client.close().catch((err2) => log15.debug(`warm-pool evict close failed: ${err2}`));
   }
   async closeAll() {
     for (const e of this.warm.values()) {
@@ -8105,8 +8558,8 @@ var defaultPool = new McpPool();
 
 // cli/mcpOAuth.ts
 import { createServer } from "http";
-import { randomBytes, createHash as createHash2 } from "crypto";
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, existsSync } from "fs";
+import { randomBytes as randomBytes2, createHash as createHash2 } from "crypto";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, existsSync } from "fs";
 import { dirname as dirname2 } from "path";
 var McpOAuthOptions = class {
   /** Where to persist tokens. Mode 0600. */
@@ -8134,7 +8587,7 @@ var McpOAuth = class {
   // -- store I/O ----------------------------------------------------------------
   load() {
     try {
-      return existsSync(this.options.storePath) ? JSON.parse(readFileSync2(this.options.storePath, "utf8")) : {};
+      return existsSync(this.options.storePath) ? JSON.parse(readFileSync3(this.options.storePath, "utf8")) : {};
     } catch {
       return {};
     }
@@ -8148,9 +8601,9 @@ var McpOAuth = class {
   async register(serverUrl) {
     const meta = await this.discover(serverUrl);
     const clientId = this.options.clientId ?? await this.registerClient(meta, serverUrl);
-    const verifier = b64url(randomBytes(32));
+    const verifier = b64url(randomBytes2(32));
     const challenge = b64url(createHash2("sha256").update(verifier).digest());
-    const state = b64url(randomBytes(16));
+    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, {
       grant_type: "authorization_code",
@@ -8232,7 +8685,7 @@ var McpOAuth = class {
   }
   /** Start a one-route loopback server, open the browser, and resolve with the returned auth code. */
   captureCode(authEndpoint, clientId, challenge, state) {
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       const server = createServer((req, res) => {
         const url = new URL(req.url ?? "/", "http://127.0.0.1");
         if (url.pathname !== "/callback") {
@@ -8246,7 +8699,7 @@ var McpOAuth = class {
         clearTimeout(timer);
         if (gotState !== state) return reject(new Error("OAuth state mismatch (possible CSRF) \u2014 aborting"));
         if (!code) return reject(new Error(`authorization failed: ${url.searchParams.get("error") ?? "no code"}`));
-        resolve4({ code, redirectUri });
+        resolve5({ code, redirectUri });
       });
       let redirectUri = "";
       const timer = setTimeout(() => {
@@ -8299,7 +8752,7 @@ function defaultOpenBrowser(url) {
 // cli/core.ts
 import { randomUUID } from "crypto";
 import { execFile as execFile2 } from "child_process";
-import { resolve, basename, join as join5 } from "path";
+import { resolve as resolve2, basename, join as join5 } from "path";
 import { existsSync as existsSync3, mkdirSync as mkdirSync4 } from "fs";
 import { platform, arch, release, userInfo, homedir as homedir2, tmpdir } from "os";
 init_tools_shell();
@@ -8307,7 +8760,7 @@ init_tools_shell();
 // src/tools.notify.ts
 init_logging();
 import { execFile } from "child_process";
-var log15 = forComponent("notify");
+var log17 = forComponent("notify");
 function makeNotifyTool(opts = {}) {
   const platform2 = opts.platform ?? process.platform;
   const run = opts.exec ?? execFile;
@@ -8328,12 +8781,12 @@ function makeNotifyTool(opts = {}) {
       if (!msg) return "Error: empty message";
       const argv = platform2 === "darwin" ? ["osascript", ["-e", `display notification ${JSON.stringify(msg)} with title ${JSON.stringify(head)}`]] : platform2 === "linux" ? ["notify-send", [head, msg]] : null;
       if (!argv) return `Notifications unavailable on ${platform2}.`;
-      return new Promise((resolve4) => {
+      return new Promise((resolve5) => {
         run(argv[0], argv[1], { timeout: 5e3 }, (e) => {
           if (e) {
-            log15.debug("notification failed", e);
-            resolve4(`Notification failed: ${e.message}`);
-          } else resolve4("Notification shown.");
+            log17.debug("notification failed", e);
+            resolve5(`Notification failed: ${e.message}`);
+          } else resolve5("Notification shown.");
         });
       });
     }
@@ -8345,9 +8798,9 @@ import { BodDB as BodDB2 } from "@bod.ee/db";
 
 // cli/util.ts
 init_logging();
-import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync4 } from "fs";
 import { homedir } from "os";
-var log16 = forComponent("cli-util");
+var log18 = 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}`];
@@ -8364,7 +8817,7 @@ function parseJson(text, fallback, what = "json") {
   try {
     return JSON.parse(text);
   } catch (e) {
-    log16.debug(`parseJson(${what}) failed: ${e.message}`);
+    log18.debug(`parseJson(${what}) failed: ${e.message}`);
     return fallback;
   }
 }
@@ -8372,9 +8825,9 @@ function readJsonFile(path, fallback) {
   if (!existsSync2(path)) return fallback;
   let text;
   try {
-    text = readFileSync3(path, "utf8");
+    text = readFileSync4(path, "utf8");
   } catch (e) {
-    log16.debug(`readJsonFile(${path}) unreadable: ${e.message}`);
+    log18.debug(`readJsonFile(${path}) unreadable: ${e.message}`);
     return fallback;
   }
   return parseJson(text, fallback, path);
@@ -8466,7 +8919,7 @@ async function buildAgent(o) {
     throw new Error(
       "buildAgent: explicit `sandbox` required \u2014 false = disk (the REAL filesystem, full reach like Claude Code; secrets still hidden) or true = sandbox (an in-memory copy of cwd; the real disk is never modified). This forces a conscious sandboxing decision."
     );
-  const cwd = resolve(o.cwd ?? process.cwd());
+  const cwd = resolve2(o.cwd ?? process.cwd());
   const disk = new NodeDiskFilesystem("/", { denySymlinks: false });
   await disk.init();
   const jailedDisk = new JailedFilesystem(disk);
@@ -8487,7 +8940,7 @@ async function buildAgent(o) {
     mem.setCwd(cwd);
     fs = mem;
   } else if (o.boddb) {
-    const root = resolve(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 bod = new BodDbFilesystem(db);
@@ -8503,7 +8956,7 @@ async function buildAgent(o) {
     const mounts = [];
     const notes = [];
     for (const d of o.addDirs) {
-      const abs = resolve(d);
+      const abs = resolve2(d);
       let name = basename(abs) || "dir", prefix = `/${name}`, n = 2;
       while (used.has(prefix)) prefix = `/${name}-${n++}`;
       used.add(prefix);
@@ -8638,6 +9091,7 @@ The filesystem root '/' is the real machine root \u2014 you have full filesystem
     // Context-v2: by default, note-take over a long session (stub tool outputs older than the last 8).
     keepToolOutputs: o.keepToolOutputs ?? 8,
     ...o.maxContextTokens != null ? { maxContextTokens: o.maxContextTokens } : {},
+    ...o.contextWindow ? { contextWindow: o.contextWindow } : {},
     ...o.browserTrim ? { browserTrim: o.browserTrim } : {}
   });
 }
@@ -8658,11 +9112,11 @@ 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 readFileSync4, statSync as statSync3 } from "fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync5, readFileSync as readFileSync5, statSync as statSync4 } from "fs";
 import { homedir as homedir3 } from "os";
 import { dirname as dirname3, join as join6 } from "path";
 import { fileURLToPath } from "url";
-var log17 = forComponent("VoiceIO");
+var log19 = forComponent("VoiceIO");
 var now3 = () => performance.now();
 var Player = class {
   proc = null;
@@ -8676,7 +9130,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) => log17.warn(`ffplay error: ${e.message}`));
+    this.proc.on("error", (e) => log19.warn(`ffplay error: ${e.message}`));
     this.proc.stdin.on("error", () => {
     });
     this.bytesWritten = 0;
@@ -8714,7 +9168,7 @@ 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");
-  log17.debug(`ffmpeg mic: [${mic.idx}] ${mic.name}`);
+  log19.debug(`ffmpeg mic: [${mic.idx}] ${mic.name}`);
   return `:${mic.idx}`;
 }
 function detectedInputDevice() {
@@ -8747,18 +9201,18 @@ function resolveAecBinary() {
   if (!existsSync4(src)) return null;
   const cacheDir = join6(homedir3(), ".agent", "cache");
   const bin = join6(cacheDir, "mic-aec");
-  if (existsSync4(bin) && statSync3(bin).mtimeMs >= statSync3(src).mtimeMs) return bin;
+  if (existsSync4(bin) && statSync4(bin).mtimeMs >= statSync4(src).mtimeMs) return bin;
   if (spawnSync2("which", ["swiftc"]).status !== 0) return null;
   mkdirSync5(cacheDir, { recursive: true });
-  log17.info("compiling AEC mic helper (first run)\u2026");
+  log19.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" });
   if (build.status !== 0) {
-    log17.warn(`AEC build failed: ${build.stderr?.slice(0, 400)}`);
+    log19.warn(`AEC build failed: ${build.stderr?.slice(0, 400)}`);
     return null;
   }
   const sign = spawnSync2("codesign", ["-fs", "-", bin], { encoding: "utf8" });
   if (sign.status !== 0) {
-    log17.warn(`codesign failed: ${sign.stderr?.slice(0, 200)}`);
+    log19.warn(`codesign failed: ${sign.stderr?.slice(0, 200)}`);
     return null;
   }
   return bin;
@@ -8800,16 +9254,16 @@ var NodeMicSource = class {
       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");
-      log17.info("mic: raw capture (no AEC) \u2014 echo handled heuristically; headphones recommended");
+      log19.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) => log17.warn(`ffmpeg: ${String(d).trim()}`));
+      this.proc.stderr.on("data", (d) => log19.warn(`ffmpeg: ${String(d).trim()}`));
     }
     this.proc.on("exit", (c) => {
-      if (c && !this.stopped) log17.error(`mic capture exited (${c}) \u2014 check mic permission / MIC_DEVICE / MIC_AEC=0`);
+      if (c && !this.stopped) log19.error(`mic capture exited (${c}) \u2014 check mic permission / MIC_DEVICE / MIC_AEC=0`);
     });
     this.proc.stdout.on("data", (chunk) => onChunk(chunk));
   }
@@ -8875,7 +9329,7 @@ var AecDuplexAudio = class {
     this.proc.stdin.on("error", () => {
     });
     this.proc.on("exit", (c) => {
-      if (c && !this.stopped) log17.error(`aec duplex audio exited (${c}) \u2014 check mic permission / MIC_AEC=0`);
+      if (c && !this.stopped) log19.error(`aec duplex audio exited (${c}) \u2014 check mic permission / MIC_AEC=0`);
     });
     this.proc.stdout.on("data", (chunk) => {
       this.gotChunk = true;
@@ -8891,7 +9345,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 log17.debug(`mic-aec: ${s}`);
+        } else log19.debug(`mic-aec: ${s}`);
       }
     });
     if (!this.noVpio && !this.triedFallback) {
@@ -8900,7 +9354,7 @@ var AecDuplexAudio = class {
         this.triedFallback = true;
         this.noVpio = true;
         this._aec = false;
-        log17.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)");
+        log19.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();
@@ -9077,7 +9531,7 @@ function fakeVoiceParts(uttFile) {
       timer = setInterval(() => {
         let buf;
         try {
-          buf = readFileSync4(uttFile, "utf8");
+          buf = readFileSync5(uttFile, "utf8");
         } catch {
           return;
         }
@@ -9120,7 +9574,7 @@ function fakeVoiceParts(uttFile) {
 init_logging();
 import { appendFile, mkdirSync as mkdirSync6 } from "fs";
 import { dirname as dirname4 } from "path";
-var log18 = forComponent("VoiceDiag");
+var log20 = forComponent("VoiceDiag");
 var JsonlDiagSink = class {
   constructor(path) {
     this.path = path;
@@ -9161,7 +9615,7 @@ var JsonlDiagSink = class {
   disable(e) {
     this.disabled = true;
     this.queue.length = 0;
-    log18.debug(`voice diag sink disabled (${this.path}): ${e instanceof Error ? e.message : e}`);
+    log20.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() {
@@ -9175,7 +9629,7 @@ var JsonlDiagSink = class {
 
 // cli/config.ts
 import { homedir as homedir4 } from "os";
-import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync6 } from "fs";
 import { join as join7 } from "path";
 import { pathToFileURL } from "url";
 var FILES = ["config.ts", "config.js", "config.mjs", "config.json"];
@@ -9197,7 +9651,7 @@ function loadSettings(dir) {
   const p = join7(dir, ".agent", "settings.json");
   if (!existsSync5(p)) return {};
   try {
-    const raw = JSON.parse(readFileSync5(p, "utf8"));
+    const raw = JSON.parse(readFileSync6(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;
@@ -9231,7 +9685,7 @@ async function loadConfig(cwd) {
 
 // cli/hooks-config.ts
 import { spawnSync as spawnSync3 } from "child_process";
-var log19 = forComponent("hooks");
+var log21 = forComponent("hooks");
 var escapeRegex = (s) => s.replace(/[.+^${}()|[\]\\]/g, "\\$&");
 function ruleMatches(rule, toolName) {
   if (!rule.tool || rule.tool === "*") return true;
@@ -9248,7 +9702,7 @@ function runCmd(rule, env) {
     });
     return { code: r.status ?? 1, out: ((r.stdout ?? "") + (r.stderr ?? "")).trim() };
   } catch (e) {
-    log19.debug(`hook command failed: ${rule.command}`, e);
+    log21.debug(`hook command failed: ${rule.command}`, e);
     return { code: 1, out: String(e?.message ?? e) };
   }
 }
@@ -9352,10 +9806,10 @@ function formatDiff(ops, opts = {}) {
 }
 
 // cli/session.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync4, readdirSync, renameSync, symlinkSync as symlinkSync2, unlinkSync, readlinkSync } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync4, readdirSync, renameSync, symlinkSync as symlinkSync2, unlinkSync, readlinkSync } from "fs";
 import { homedir as homedir5 } from "os";
 import { join as join8 } from "path";
-var log20 = forComponent("session");
+var log22 = forComponent("session");
 var globalDir = () => join8(homedir5(), ".agent", "sessions");
 var SessionStore = class {
   dir;
@@ -9400,15 +9854,15 @@ var SessionStore = class {
   }
   load(id) {
     if (!this.safeId(id)) {
-      log20.debug(`rejecting unsafe session id: ${id}`);
+      log22.debug(`rejecting unsafe session id: ${id}`);
       return void 0;
     }
     const path = join8(this.dir, `${id}.json`);
     if (!existsSync6(path)) return void 0;
     try {
-      return JSON.parse(readFileSync6(path, "utf8"));
+      return JSON.parse(readFileSync7(path, "utf8"));
     } catch (e) {
-      log20.debug(`unreadable session ${id} \u2014 ignoring`, e);
+      log22.debug(`unreadable session ${id} \u2014 ignoring`, e);
       return void 0;
     }
   }
@@ -9419,9 +9873,9 @@ var SessionStore = class {
     for (const f of readdirSync(this.dir)) {
       if (!f.endsWith(".json")) continue;
       try {
-        metas.push(JSON.parse(readFileSync6(join8(this.dir, f), "utf8")).meta);
+        metas.push(JSON.parse(readFileSync7(join8(this.dir, f), "utf8")).meta);
       } catch (e) {
-        log20.debug(`skipping unreadable session file ${f}`, e);
+        log22.debug(`skipping unreadable session file ${f}`, e);
       }
     }
     return metas.sort((a, b) => b.updated - a.updated);
@@ -9442,7 +9896,7 @@ function globalSessionLoad(idOrPrefix) {
   if (existsSync6(exact)) {
     try {
       const target = readlinkSync(exact);
-      return JSON.parse(readFileSync6(target, "utf8"));
+      return JSON.parse(readFileSync7(target, "utf8"));
     } catch {
       return void 0;
     }
@@ -9453,7 +9907,7 @@ function globalSessionLoad(idOrPrefix) {
       const base = f.slice(0, -5);
       if (base.includes(idOrPrefix) || base.endsWith(idOrPrefix)) {
         const target = readlinkSync(join8(gd, f));
-        return JSON.parse(readFileSync6(target, "utf8"));
+        return JSON.parse(readFileSync7(target, "utf8"));
       }
     }
   } catch {
@@ -9475,7 +9929,7 @@ function globalSessionList() {
         }
         continue;
       }
-      metas.push(JSON.parse(readFileSync6(target, "utf8")).meta);
+      metas.push(JSON.parse(readFileSync7(target, "utf8")).meta);
     } catch {
     }
   }
@@ -9589,13 +10043,13 @@ import { execFile as execFile3 } from "child_process";
 import { promisify } from "util";
 import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync8 } from "fs";
 import { homedir as homedir6 } from "os";
-import { join as join9, resolve as resolve2, sep as sep2, parse as parsePath } from "path";
-var log21 = forComponent("checkpoints");
+import { join as join9, resolve as resolve3, sep as sep3, parse as parsePath } from "path";
+var log23 = forComponent("checkpoints");
 var exec = promisify(execFile3);
 var DEFAULT_EXCLUDE = [".agent/", ".git/", "node_modules/", "dist/", "build/", ".next/", "target/", ".venv/", "__pycache__/", "*.log"];
 function isBroadRoot(p) {
-  const abs = resolve2(p);
-  return abs === resolve2(homedir6()) || abs === parsePath(abs).root;
+  const abs = resolve3(p);
+  return abs === resolve3(homedir6()) || abs === parsePath(abs).root;
 }
 var ShadowRepo = class {
   // undefined = unprobed; false = git/this root unusable
@@ -9636,7 +10090,7 @@ var ShadowRepo = class {
       writeFileSync5(join9(this.gitDir, "info", "exclude"), this.exclude.join("\n") + "\n");
       this.ready = true;
     } catch (e) {
-      log21.debug(`git checkpoints unavailable for ${this.workTree}`, e);
+      log23.debug(`git checkpoints unavailable for ${this.workTree}`, e);
       this.ready = false;
     }
     return this.ready;
@@ -9647,7 +10101,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) => log21.debug(`force-add failed: ${p}`, e));
+    for (const p of forced) await this.run("add", "-f", "--", p).catch((e) => log23.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.
@@ -9655,8 +10109,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) => log21.debug(`force-capture failed: ${p}`, e));
-    await this.run("commit", "--amend", "--no-edit", "-q", "--allow-empty").catch((e) => log21.debug("amend failed", e));
+    for (const p of paths) await this.run("add", "-f", "--", p).catch((e) => log23.debug(`force-capture failed: ${p}`, e));
+    await this.run("commit", "--amend", "--no-edit", "-q", "--allow-empty").catch((e) => log23.debug("amend failed", e));
   }
   /** Commits on `ref`, oldest-first (canonical index space). */
   async log(ref) {
@@ -9716,7 +10170,7 @@ var ShadowRepo = class {
       await this.run("gc", "--auto", "-q").catch(() => {
       });
     } catch (e) {
-      log21.debug("checkpoint prune failed", e);
+      log23.debug("checkpoint prune failed", e);
     }
   }
 };
@@ -9742,12 +10196,12 @@ var GitCheckpoints = class {
   }
   /** cwd + any add-dir mounts that live OUTSIDE cwd (in-cwd mounts are already covered by the cwd root). */
   roots() {
-    const cwd = resolve2(this.options.workTree);
+    const cwd = resolve3(this.options.workTree);
     const out = [{ workTree: cwd, gitDir: this.options.gitDir }];
     for (const d of this.options.addDirs ?? []) {
-      const abs = resolve2(d);
-      if (abs === cwd || abs.startsWith(cwd + sep2)) continue;
-      if (cwd.startsWith(abs + sep2)) continue;
+      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") });
     }
     return out;
@@ -9784,7 +10238,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) => log21.debug("re-point failed", e));
+    if (this.started) for (const r of this.repos) void r.point(this.ref()).catch((e) => log23.debug("re-point failed", e));
   }
   async begin(label) {
     if (!await this.start()) return;
@@ -9804,7 +10258,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 {
-          log21.debug("checkpoint commit failed", e);
+          log23.debug("checkpoint commit failed", e);
           survivors.push(this.repos[i]);
           survivorCaches.push(this.caches[i] ?? []);
         }
@@ -9819,8 +10273,8 @@ var GitCheckpoints = class {
   repoIndexFor(abs) {
     let best = -1, bestLen = -1;
     this.repos.forEach((r, i) => {
-      const wt = r.root.endsWith(sep2) ? r.root.slice(0, -1) : r.root;
-      if ((abs === wt || abs.startsWith(wt + sep2)) && wt.length > bestLen) {
+      const wt = r.root.endsWith(sep3) ? r.root.slice(0, -1) : r.root;
+      if ((abs === wt || abs.startsWith(wt + sep3)) && wt.length > bestLen) {
         best = i;
         bestLen = wt.length;
       }
@@ -9835,11 +10289,11 @@ var GitCheckpoints = class {
       preToolUse: async (call) => {
         if (!this.snapshotted || !this.repos.length) return;
         for (const rel of mutatedPaths(call)) {
-          const abs = resolve2(this.options.workTree, rel);
+          const abs = resolve3(this.options.workTree, rel);
           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) => log21.debug("amendForced failed", e));
+          if (i >= 0) await this.repos[i].amendForced([abs]).catch((e) => log23.debug("amendForced failed", e));
         }
       }
     };
@@ -10039,7 +10493,7 @@ function completePath(listDir, ref) {
 // cli/lineEditor.ts
 import { emitKeypressEvents } from "readline";
 import { spawnSync as spawnSync4 } from "child_process";
-import { writeFileSync as writeFileSync7, readFileSync as readFileSync7, unlinkSync as unlinkSync2 } from "fs";
+import { writeFileSync as writeFileSync7, readFileSync as readFileSync8, unlinkSync as unlinkSync2 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
 import { join as join11 } from "path";
 
@@ -10635,7 +11089,8 @@ var EditorState = class _EditorState {
       const lines = text.split("\n").length;
       const id = ++this.pasteSeq;
       const measure = multiline ? `+${lines} line${lines === 1 ? "" : "s"}` : `+${text.length} chars`;
-      const placeholder = `[Pasted text #${id} ${measure}]`;
+      const preview = pastePreview(text);
+      const placeholder = `[Pasted #${id}${preview ? ` "${preview}"` : ""} ${measure}]`;
       this.pastes.set(placeholder, text);
       this.insert(placeholder);
     } else {
@@ -10914,6 +11369,12 @@ var EditorState = class _EditorState {
   }
 };
 var REWIND = "\0REWIND";
+var PASTE_PREVIEW_MAX = 40;
+function pastePreview(text) {
+  const line = text.split("\n").find((l) => l.trim()) ?? "";
+  const clean2 = line.replace(/[[\]]/g, "").replace(/\s+/g, " ").trim();
+  return clean2.length > PASTE_PREVIEW_MAX ? clean2.slice(0, PASTE_PREVIEW_MAX) + "\u2026" : clean2;
+}
 function applyVimNormal(s, key, str) {
   const k = key?.name;
   if (key?.ctrl || key?.meta) return "pass";
@@ -11228,7 +11689,7 @@ function createLineEditor(out, input = keyInput) {
       out.write("\x1B[?2004l");
       const r = spawnSync4(cmd, [...cargs, file], { stdio: "inherit" });
       if (r.status === 0) {
-        const text = readFileSync7(file, "utf8").replace(/\n$/, "");
+        const text = readFileSync8(file, "utf8").replace(/\n$/, "");
         s.reset();
         if (text) s.insert(text);
       }
@@ -11264,10 +11725,10 @@ function createLineEditor(out, input = keyInput) {
       render(s, promptOf(), maxVisible, opts.status);
     };
     process.on("SIGWINCH", onResize);
-    return new Promise((resolve4) => {
+    return new Promise((resolve5) => {
       activeAbort = () => {
         finish();
-        resolve4(null);
+        resolve5(null);
       };
       const redraw = () => render(s, promptOf(), maxVisible, opts.status);
       let lastStatus = opts.status?.() ?? "";
@@ -11347,20 +11808,20 @@ function createLineEditor(out, input = keyInput) {
         if (action === "submit") {
           finish();
           opts.onSubmit?.();
-          return resolve4(s.expand());
+          return resolve5(s.expand());
         }
         if (action === "eof") {
           finish();
-          return resolve4(null);
+          return resolve5(null);
         }
         if (action === "rewind") {
           finish();
-          return resolve4(REWIND);
+          return resolve5(REWIND);
         }
         if (action === "cancel") {
           if (s.buf.length === 0) {
             finish();
-            return resolve4(null);
+            return resolve5(null);
           }
           s.reset();
           s.refresh();
@@ -11473,7 +11934,7 @@ function selectMenu(out, opts) {
     out.write(dim2(`  ${filterHint}\u2191/\u2193 select \xB7 ${back}\u23CE choose \xB7 esc cancel${more}`));
     prevLines++;
   };
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const wasRaw = !!keyInput.isRaw;
     menusOpen++;
     emitKeypressEvents(keyInput);
@@ -11491,7 +11952,7 @@ function selectMenu(out, opts) {
         } catch {
         }
       }
-      resolve4(val);
+      resolve5(val);
     };
     const drillIn = () => {
       const it = items[sel];
@@ -11612,19 +12073,19 @@ function windowAround(count, sel, max) {
 var plainBuf = "";
 var plainEnded = false;
 function readPlainLine() {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const emit = () => {
       const nl = plainBuf.indexOf("\n");
       if (nl >= 0) {
         const line = plainBuf.slice(0, nl);
         plainBuf = plainBuf.slice(nl + 1);
-        resolve4(line);
+        resolve5(line);
         return true;
       }
       if (plainEnded) {
         const rest = plainBuf;
         plainBuf = "";
-        resolve4(rest.length ? rest : null);
+        resolve5(rest.length ? rest : null);
         return true;
       }
       return false;
@@ -11655,7 +12116,7 @@ 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 { homedir as homedir8 } from "os";
 import { join as join12 } from "path";
-var log22 = forComponent("os-sched");
+var log24 = forComponent("os-sched");
 var OsScheduler = class {
   options;
   constructor(options) {
@@ -11717,7 +12178,7 @@ var OsScheduler = class {
         }
       }
     } catch (e) {
-      log22.debug(`cancel ${id}`, e);
+      log24.debug(`cancel ${id}`, e);
     }
     for (const f of [`${id}.json`, `${id}.sh`]) {
       try {
@@ -11834,7 +12295,7 @@ 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 log23 = forComponent("remote-trigger");
+var log25 = forComponent("remote-trigger");
 var TRIGGER_DIR = () => join13(homedir9(), ".agent", "triggers");
 var sockPath = (sessionId, dir = TRIGGER_DIR()) => join13(dir, `${sessionId}.sock`);
 var TriggerServer = class {
@@ -11872,13 +12333,13 @@ var TriggerServer = class {
             conn.end(JSON.stringify({ ok: false, error: String(e) }) + "\n");
           }
         });
-        conn.on("error", (e) => log23.debug("trigger conn error", e));
+        conn.on("error", (e) => log25.debug("trigger conn error", e));
       });
-      this.server.on("error", (e) => log23.debug("trigger server error", e));
+      this.server.on("error", (e) => log25.debug("trigger server error", e));
       this.server.listen(p);
       this.path = p;
     } catch (e) {
-      log23.debug("trigger server unavailable", e);
+      log25.debug("trigger server unavailable", e);
     }
   }
   /** Re-bind on /resume (the session id changed). */
@@ -12000,10 +12461,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 log24 = forComponent("cli");
+var log26 = forComponent("cli");
 var VERSION = (() => {
   try {
-    return JSON.parse(readFileSync8(new URL("../package.json", import.meta.url), "utf8")).version ?? "?";
+    return JSON.parse(readFileSync9(new URL("../package.json", import.meta.url), "utf8")).version ?? "?";
   } catch {
     return "?";
   }
@@ -12255,7 +12716,7 @@ REPL multi-line: Option/Alt+Enter inserts a newline, or end a line with \\ to co
 REPL shortcuts: Shift+Tab cycles permission posture (ask \u2192 accept-edits \u2192 plan) \xB7 Alt+T toggles reasoning \xB7 Alt+P switches model \xB7 Ctrl+O toggles verbose tool output \xB7 Ctrl+X Ctrl+E edits the buffer in $EDITOR \xB7 \u2192 or Tab accepts the dim history ghost-suggestion \xB7 Alt+S/Ctrl+S stash/unstash.
 REPL steer/stash: type while a turn is running \u2192 Enter STEERS it (the text reaches the model at its next step, alongside the next tool result). Alt+S (or Ctrl+S) with text stashes it for AFTER the turn instead; on an empty prompt pops the next stashed entry for editing.
 REPL editing (emacs/readline): Ctrl-A/E line start/end \xB7 Ctrl-B/F char \xB7 Alt-B/F or Alt/Ctrl-\u2190/\u2192 word \xB7 Ctrl-W kill word \xB7 Ctrl-U/K kill to start/end \xB7 Ctrl-Y yank \xB7 Ctrl-_ undo \xB7 Alt-D kill word fwd \xB7 Ctrl-L clear screen. Set editorMode:'vim' (or /config) for modal vim editing.
-REPL paste: large/multi-line pastes collapse to a [Pasted text +N lines] preview (expands on send); a pasted image/file path attaches as [Image]/[File]; Ctrl-V or /paste grabs a clipboard image (macOS).`;
+REPL paste: large/multi-line pastes collapse to a [Pasted #N "\u2026" +N lines] preview (expands on send); a pasted image/file path attaches as [Image]/[File]; Ctrl-V or /paste grabs a clipboard image (macOS).`;
 function newestModel() {
   return listModels().slice().sort((a, b) => (getModelInfo(b)?.releaseDate ?? "").localeCompare(getModelInfo(a)?.releaseDate ?? ""))[0] ?? "";
 }
@@ -12290,7 +12751,7 @@ function resolveModelOrNewest(model) {
 var ENV_KEY_ALIASES = { google: ["GEMINI_API_KEY"] };
 function loadEnvFile(file) {
   if (!existsSync9(file)) return;
-  for (const line of readFileSync8(file, "utf8").split("\n")) {
+  for (const line of readFileSync9(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();
@@ -12745,7 +13206,7 @@ function costOf(pricing, promptTokens = 0, completionTokens = 0, cacheCreationTo
 function turnCost(model, usage) {
   return costOf(getModelInfo(model)?.pricing, usage?.promptTokens ?? 0, usage?.completionTokens ?? 0, usage?.cacheCreationTokens ?? 0, usage?.cacheReadTokens ?? 0, model);
 }
-async function evaluateGoal(ai, condition, transcript, log25) {
+async function evaluateGoal(ai, condition, transcript, log27) {
   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);
@@ -12765,7 +13226,7 @@ ${recent}` }
     const match = r.content.match(/\{[\s\S]*\}/);
     if (match) return JSON.parse(match[0]);
   } catch (e) {
-    log25(dim(`  (goal evaluator error: ${e?.message ?? e})
+    log27(dim(`  (goal evaluator error: ${e?.message ?? e})
 `));
   }
   return { met: false, reason: "evaluation unclear" };
@@ -12776,10 +13237,8 @@ function errInfo(e) {
 function fmtUsd(n) {
   return n >= 1 ? `$${n.toFixed(2)}` : `$${n.toFixed(4)}`;
 }
-function estimateTranscriptTokens(messages) {
-  let chars = 0;
-  for (const m of messages) chars += (m.content?.length ?? 0) + (m.tool_calls ? JSON.stringify(m.tool_calls).length : 0);
-  return Math.ceil(chars / 4);
+function estimateTranscriptTokens(messages, keepRecentImages = 1) {
+  return estimateTokens(messages, keepRecentImages);
 }
 function formatStatus(s) {
   const L = (k, v) => `  ${k.padEnd(12)} ${v}
@@ -12891,9 +13350,12 @@ function optsFor(args, ai, cfg = {}, extraTools = []) {
   const rules = [...flagRules, ...configRules, ...askRules];
   if (configRules.length) err(dim(`  \u2295 ${configRules.length} permission rule(s) from config
 `));
+  const model = resolveModelOrNewest(args.model ?? cfg.model);
   return {
     ai,
-    model: resolveModelOrNewest(args.model ?? cfg.model),
+    model,
+    // The real context window drives the context % and `/compact`'s budget (never `maxTokens` — that's spend).
+    contextWindow: getModelInfo(model)?.contextWindow ?? 0,
     cwd: args.cwd,
     tools: cfg.tools,
     extraTools,
@@ -12909,7 +13371,7 @@ function optsFor(args, ai, cfg = {}, extraTools = []) {
     stream: args.stream,
     host: makeHost(args.outputFormat, { stream: true }),
     planMode: args.plan || cfg.planMode || false,
-    permissions: rules.length ? new PermissionPolicy({ rules, default: "allow", host: makeHost(), ask: makeAskResolver(resolve3(args.cwd ?? process.cwd())) }) : void 0,
+    permissions: rules.length ? new PermissionPolicy({ rules, default: "allow", host: makeHost(), ask: makeAskResolver(resolve4(args.cwd ?? process.cwd())) }) : void 0,
     subagents: args.subagents || cfg.subagents || false,
     maxSteps: args.maxSteps ?? cfg.maxSteps,
     reasoning: args.reasoning ?? cfg.reasoning,
@@ -12985,7 +13447,7 @@ function mcpAgentTools(mounted, opts) {
   return tools;
 }
 async function closeMcp(mounted) {
-  await Promise.all(mounted.map((m) => m.client.close().catch((e) => log24.debug("mcp close failed", e))));
+  await Promise.all(mounted.map((m) => m.client.close().catch((e) => log26.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) {
@@ -12998,11 +13460,13 @@ function readImageParts(cwd, line) {
   for (const ref of refs) {
     const mime = IMG_EXT[extname(ref).toLowerCase()];
     if (!mime) continue;
-    const abs = ref.startsWith("~/") ? untilde(ref) : resolve3(cwd, ref);
+    const abs = ref.startsWith("~/") ? untilde(ref) : resolve4(cwd, ref);
     try {
-      parts.push(imagePart(`data:${mime};base64,${readFileSync8(abs).toString("base64")}`));
+      statSync5(abs);
     } catch {
+      continue;
     }
+    parts.push(imageRefPart(abs, mime));
   }
   return parts;
 }
@@ -13012,9 +13476,9 @@ function pastePathClassifier(cwd) {
     if (!t || t.includes("\n")) return null;
     t = t.replace(/\\ /g, " ").replace(/^['"]|['"]$/g, "");
     if (!/^(\/|~\/|\.\/|\.\.\/)/.test(t)) return null;
-    const abs = t.startsWith("~/") ? untilde(t) : resolve3(cwd, t);
+    const abs = t.startsWith("~/") ? untilde(t) : resolve4(cwd, t);
     try {
-      if (!statSync4(abs).isFile()) return null;
+      if (!statSync5(abs).isFile()) return null;
     } catch {
       return null;
     }
@@ -13035,7 +13499,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) => {
-        log24.debug("mcp mention resolve failed", e);
+        log26.debug("mcp mention resolve failed", e);
         return null;
       });
       if (body != null) {
@@ -13121,7 +13585,7 @@ async function runTurn(agent, store, session, task, cp, cwd = process.cwd(), sen
       try {
         store.save(session);
       } catch (ex) {
-        log24.debug("mid-turn session flush failed", ex);
+        log26.debug("mid-turn session flush failed", ex);
       }
     }
     return origNotify(e);
@@ -13152,9 +13616,8 @@ async function runTurn(agent, store, session, task, cp, cwd = process.cwd(), sen
   const cost = turnCost(agent.options.model, res.usage);
   const m = res.usageEstimated ? "~" : "";
   const tok = res.usage?.totalTokens ? `${m}${(res.usage.totalTokens / 1e3).toFixed(1)}k tok \xB7 ${cost > 0 ? m + fmtUsd(cost) + " \xB7 " : ""}` : "";
-  const lastUser = res.messages.map((m2) => m2.role).lastIndexOf("user");
   agent.options.host?.takeToolCount?.();
-  const tools = res.messages.slice(lastUser).filter((m2) => m2.role === "tool").length;
+  const tools = res.messages.slice(msgsBefore).filter((m2) => m2.role === "tool").length;
   const ok = res.finishReason === "stop";
   const shortId = session.meta.id.replace(/^\d{8}-/, "");
   const didWork = agent.transcript.slice(msgsBefore).some((m2) => m2.role === "assistant" || m2.role === "tool");
@@ -13190,10 +13653,12 @@ 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]);
 function startSession(args, store, agent, cwd) {
   if (args.resume || args.cont) {
     const data = args.resume ? store.load(args.resume) ?? globalSessionLoad(args.resume) : store.latestData();
     if (data) {
+      data.messages = elideStaleImages(remintSessionImages(data, store, cwd), 1);
       agent.transcript = data.messages;
       if (args.fork) {
         const now5 = Date.now();
@@ -13249,7 +13714,7 @@ function initInstructions(cwd) {
 function persistSetting(cwd, key, value) {
   const path = join14(cwd, ".agent", "settings.json");
   try {
-    const obj = existsSync9(path) ? JSON.parse(readFileSync8(path, "utf8")) : {};
+    const obj = existsSync9(path) ? JSON.parse(readFileSync9(path, "utf8")) : {};
     if (obj[key] === value) return;
     obj[key] = value;
     mkdirSync12(dirname5(path), { recursive: true });
@@ -13269,14 +13734,14 @@ var isCancelTeardown = (e) => {
 function installCancelGuards(mounted) {
   process.on("unhandledRejection", (e) => {
     if (isCancelTeardown(e)) {
-      log24.debug("suppressed unhandledRejection (cursor stream cancel)", e);
+      log26.debug("suppressed unhandledRejection (cursor stream cancel)", e);
       return;
     }
-    log24.error("unhandledRejection", e);
+    log26.error("unhandledRejection", e);
   });
   process.on("uncaughtException", (e) => {
     if (isCancelTeardown(e)) {
-      log24.debug("suppressed uncaughtException (cursor stream cancel)", e);
+      log26.debug("suppressed uncaughtException (cursor stream cancel)", e);
       return;
     }
     console.error(e);
@@ -13308,7 +13773,7 @@ async function repl(args, ai, cfg, cwd) {
     },
     tickMs: 15e3
   });
-  const agentxInvocation = () => process.argv[1] ? `${process.execPath} ${resolve3(process.argv[1])}` : "agentx";
+  const agentxInvocation = () => process.argv[1] ? `${process.execPath} ${resolve4(process.argv[1])}` : "agentx";
   const osSched = new OsScheduler({ agentx: agentxInvocation() });
   const osBackend = osSched.available() ? {
     get sessionId() {
@@ -13547,7 +14012,7 @@ async function repl(args, ai, cfg, cwd) {
       quickLook: {
         branch: () => {
           try {
-            const head = readFileSync8(join14(cwd, ".git", "HEAD"), "utf8").trim();
+            const head = readFileSync9(join14(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";
@@ -13613,6 +14078,7 @@ async function repl(args, ai, cfg, cwd) {
   };
   const setModel = (m) => {
     work.model = m;
+    work.contextWindow = getModelInfo(m)?.contextWindow ?? 0;
     work.providerOptions = providerOptionsFor(m, cwd, cfg.mcpServers);
     if (dx) dx.options.actModel = m;
     persistModel(cwd, m);
@@ -13676,10 +14142,11 @@ async function repl(args, ai, cfg, cwd) {
   const pendingImages = [];
   const bangContext = [];
   const grabClipboardAttachment = () => {
-    const dir = join14(tmpdir3(), "agentx-pasted");
+    const dir = join14(store.dir, `${session.meta.id}.images`);
     try {
       mkdirSync12(dir, { recursive: true });
-    } catch {
+    } catch (e) {
+      log26.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;
@@ -13786,13 +14253,13 @@ Added entries are loadable now via the Skill/SlashCommand tools; removed ones ar
 </system-reminder>`;
   };
   const histPath = join14(cwd, ".agent", "history");
-  const history = existsSync9(histPath) ? readFileSync8(histPath, "utf8").split("\n").filter(Boolean).reverse().slice(0, 500) : [];
+  const history = existsSync9(histPath) ? readFileSync9(histPath, "utf8").split("\n").filter(Boolean).reverse().slice(0, 500) : [];
   const remember = (line) => {
     try {
       mkdirSync12(join14(cwd, ".agent"), { recursive: true });
       appendFileSync(histPath, line + "\n");
     } catch (e) {
-      log24.debug("history write failed", e);
+      log26.debug("history write failed", e);
     }
   };
   const ago = (t) => {
@@ -13800,6 +14267,7 @@ Added entries are loadable now via the Skill/SlashCommand tools; removed ones ar
     return s < 60 ? "just now" : s < 3600 ? `${Math.floor(s / 60)}m ago` : s < 86400 ? `${Math.floor(s / 3600)}h ago` : `${Math.floor(s / 86400)}d ago`;
   };
   const resumeInto = (data) => {
+    data.messages = elideStaleImages(remintSessionImages(data, store, cwd), 1);
     face.transcript = data.messages;
     session = data;
     checkpoints.use?.(data.meta.id);
@@ -13863,7 +14331,7 @@ Added entries are loadable now via the Skill/SlashCommand tools; removed ones ar
       try {
         store.save(session);
       } catch (e) {
-        log24.debug("session save after rewind failed", e);
+        log26.debug("session save after rewind failed", e);
       }
       err(green("  \u27F2 jumped back") + dim(` \u2014 ${face.transcript.length} message(s) kept; edit + resend
 `));
@@ -13897,7 +14365,7 @@ ${task}`;
       bangContext.length = 0;
     }
     const delta = await refreshCatalogs().catch((e) => {
-      log24.debug("catalog refresh failed", e);
+      log26.debug("catalog refresh failed", e);
       return "";
     });
     if (delta) {
@@ -14075,8 +14543,8 @@ ${task}`;
     context: {
       desc: "context-window usage (messages + estimated tokens)",
       run: () => {
-        const est = estimateTranscriptTokens(face.transcript);
-        const cap = face.options.maxTokens || 2e5;
+        const est = estimateTranscriptTokens(face.transcript, face.options.keepRecentImages);
+        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)
 `));
       }
@@ -14161,7 +14629,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) => {
-          log24.debug("catalog refresh failed", e);
+          log26.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
@@ -14454,13 +14922,21 @@ ${task}`;
       desc: "summarize older context to free up the window \u2014 /compact [what to preserve]",
       run: (a) => {
         const focus = a.join(" ").trim() || void 0;
-        const n = face.compactNow(12, focus);
+        const r = face.compactNow(12, focus);
         session.messages = face.transcript;
         try {
           store.save(session);
         } catch {
         }
-        err(dim(`  compacted \u2014 folded ${n} message(s)${focus && n ? ` (preserving: ${focus})` : ""}
+        const pct = (t) => `${Math.round(t / r.cap * 100)}%`;
+        const k = (t) => `${(t / 1e3).toFixed(1)}k`;
+        const freed = r.tokensBefore - r.tokensAfter;
+        if (freed <= 0) {
+          err(dim(`  nothing to compact \u2014 ~${k(r.tokensAfter)} tok (${pct(r.tokensAfter)} of window) is already at the floor
+`));
+          return;
+        }
+        err(dim(`  compacted \u2014 ~${k(r.tokensBefore)} \u2192 ~${k(r.tokensAfter)} tok (${pct(r.tokensBefore)} \u2192 ${pct(r.tokensAfter)} of window), freed ~${k(freed)}; folded ${r.removed} message(s)${focus ? ` (preserving: ${focus})` : ""}
 `));
       }
     },
@@ -14655,7 +15131,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) {
-            log24.debug(`loadAgents(${d}) failed`, e);
+            log26.debug(`loadAgents(${d}) failed`, e);
           }
         }
         if (!seen.size) {
@@ -14743,7 +15219,7 @@ ${task}`;
           }
           if (idx >= 0) {
             const old = mounted.splice(idx, 1)[0];
-            await old.client.close().catch((e) => log24.debug("mcp close failed", e));
+            await old.client.close().catch((e) => log26.debug("mcp close failed", e));
           }
           try {
             const m = await mountMcpServer(name, conf);
@@ -14771,7 +15247,7 @@ ${task}`;
           }
           const m = mounted.splice(idx, 1)[0];
           remountMcpTools();
-          await m.client.close().catch((e) => log24.debug("mcp close failed", e));
+          await m.client.close().catch((e) => log26.debug("mcp close failed", e));
           err(dim(`  removed "${name}"
 `));
           return;
@@ -14887,7 +15363,7 @@ ${task}`;
         }
         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 path = resolve3(cwd, name);
+        const path = resolve4(cwd, name);
         try {
           mkdirSync12(dirname5(path), { recursive: true });
           writeFileSync9(path, md);
@@ -14974,7 +15450,7 @@ ${task}`;
     try {
       return readdirSync4(join14(cwd, absDir.replace(/^\/+/, "")), { withFileTypes: true }).map((d) => ({ name: d.name, dir: d.isDirectory() }));
     } catch (e) {
-      log24.debug("completion readdir failed", absDir, e);
+      log26.debug("completion readdir failed", absDir, e);
       return null;
     }
   };
@@ -15110,7 +15586,7 @@ ${out}
         return;
       }
       await refreshCatalogs().catch((e) => {
-        log24.debug("catalog refresh failed", e);
+        log26.debug("catalog refresh failed", e);
       });
       const sk = skills.find((x) => x.name === name);
       if (sk) {
@@ -15326,8 +15802,8 @@ ${out}
     err("\n");
     const initial = prefill ?? (carry || void 0);
     prefill = void 0;
-    const ctxTok = estimateTranscriptTokens(face.transcript);
-    const ctxCap = face.options.maxTokens || 2e5;
+    const ctxTok = estimateTranscriptTokens(face.transcript, face.options.keepRecentImages);
+    const ctxCap = Agent.contextCap(face.options);
     {
       const pct = Math.round(ctxTok / ctxCap * 100);
       const step = pct >= 90 ? 90 : pct >= 80 ? 80 : 0;
@@ -15541,7 +16017,7 @@ async function main() {
   let worktreeCleanup;
   if (args.worktree) {
     const { enterWorktree: enterWorktree2, exitWorktree: exitWorktree2 } = await Promise.resolve().then(() => (init_worktree(), worktree_exports));
-    const session = enterWorktree2(args.worktree, resolve3(args.cwd ?? process.cwd()));
+    const session = enterWorktree2(args.worktree, resolve4(args.cwd ?? process.cwd()));
     err(dim(`  \u2295 worktree: ${session.worktreePath} (branch ${session.branch})
 `));
     worktreeCleanup = () => {
@@ -15551,7 +16027,7 @@ async function main() {
 `));
     };
   }
-  const cwd = resolve3(args.cwd ?? process.cwd());
+  const cwd = resolve4(args.cwd ?? process.cwd());
   const cfg = await loadConfig(cwd);
   cfg.permissions = mergePerms(loadClaudeSettings(cwd), mergePerms(loadPersistedRules(cwd), cfg.permissions));
   if (canPrompt && !args.yes && !isTrusted(cwd)) {