agent.libx.js 0.86.0

package/dist/index.js

@@ -0,0 +1,3605 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/redact.ts
+function redactSecrets(text) {
+  if (!text) return text;
+  return text.replace(SECRET_PAIR, (_m, head, quote, _val) => `${head}${quote}${REDACTED}`).replace(SECRET_TOKEN, REDACTED);
+}
+var REDACTED, CONFIG_FILE_RE, SECRET_PAIR, SECRET_TOKEN;
+var init_redact = __esm({
+  "src/redact.ts"() {
+    "use strict";
+    REDACTED = "\u2039redacted\u203A";
+    CONFIG_FILE_RE = /(^|\/)\.(agent|claude)\/(settings(\.[\w-]+)?\.json|config\.(json|js|mjs|cjs|ts))$/i;
+    SECRET_PAIR = /((?:^|[\s,{[])(?:export\s+)?["']?[\w.\-]*(?:KEY|TOKEN|SECRET|PASSWORD|PASSWD|CREDENTIAL|PRIVATE_KEY|ACCESS_?KEY|AUTH(?:_?TOKEN)?|BEARER)[\w.\-]*["']?\s*[:=]\s*)(["']?)([^\s"',{}\]]+)/gi;
+    SECRET_TOKEN = /\b(sk-ant-[\w-]{12,}|sk-[A-Za-z0-9]{20,}|ghp_[A-Za-z0-9]{20,}|gho_[A-Za-z0-9]{20,}|github_pat_[\w]{20,}|xox[baprs]-[\w-]{10,}|AKIA[0-9A-Z]{12,}|AIza[\w-]{20,}|eyJ[\w-]{8,}\.[\w-]{8,}\.[\w-]{8,})\b/g;
+  }
+});
+
+// src/tools.structured.ts
+async function walkFiles(fs, dir, out = []) {
+  let entries;
+  try {
+    entries = await fs.readDir(dir);
+  } catch {
+    return out;
+  }
+  for (const name of entries.sort()) {
+    const p = dir === "/" ? `/${name}` : `${dir}/${name}`;
+    if (await fs.isDirectory(p)) await walkFiles(fs, p, out);
+    else out.push(p);
+  }
+  return out;
+}
+function globToRegExp(glob, caseInsensitive = false) {
+  const g = glob.startsWith("/") ? glob : `/${glob}`;
+  let re = "";
+  for (let i = 0; i < g.length; i++) {
+    const c = g[i];
+    if (c === "*") {
+      if (g[i + 1] === "*") {
+        re += ".*";
+        i++;
+        if (g[i + 1] === "/") i++;
+      } else re += "[^/]*";
+    } else if (c === "?") re += "[^/]";
+    else re += c.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  }
+  return new RegExp(`^${re}$`, caseInsensitive ? "i" : "");
+}
+function anchoredGlob(fs, glob) {
+  const cwd = fsCwd(fs);
+  const base = cwd === "/" ? "" : cwd;
+  return globToRegExp(glob.startsWith("/") ? glob : `${base}/${glob}`);
+}
+function docOutlineOf(content, cap = 20) {
+  const out = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length && out.length < cap; i++) {
+    const hm = lines[i].match(/^(#{1,4})\s+(.+)/);
+    if (hm) {
+      out.push(hm[0].slice(0, 120));
+      for (let j = i + 1; j < lines.length; j++) {
+        const l = lines[j].trim();
+        if (!l) continue;
+        if (l.startsWith("#")) break;
+        out.push("  " + l.slice(0, 120));
+        break;
+      }
+    }
+  }
+  return out;
+}
+function signaturesOf(content, cap = 40) {
+  const out = [];
+  for (const line of content.split("\n")) {
+    if (!SIG_RE.test(line)) continue;
+    let sig = line.trim();
+    const brace = sig.indexOf("{");
+    if (brace > 0) sig = sig.slice(0, brace).trim();
+    sig = sig.replace(/\s*=>?\s*$/, "").replace(/=\s*$/, "").slice(0, 120);
+    if (sig && !out.includes(sig)) out.push(sig);
+    if (out.length >= cap) break;
+  }
+  return out;
+}
+async function repoIndex(fs, glob, mode = "code") {
+  const scope = glob ? anchoredGlob(fs, String(glob)) : null;
+  const filter = mode === "code" ? isCode : mode === "docs" ? isDoc : (p) => isCode(p) || isDoc(p);
+  const files = (await walkFiles(fs, fsCwd(fs))).filter((p) => scope ? scope.test(p) : filter(p));
+  const blocks = [];
+  let shown = 0;
+  for (const path of files) {
+    let content;
+    try {
+      content = await fs.readFile(path);
+    } catch {
+      continue;
+    }
+    const entries = isDoc(path) ? docOutlineOf(content) : signaturesOf(content);
+    if (entries.length) {
+      blocks.push(`${path}
+${entries.map((s) => "  " + s).join("\n")}`);
+      shown += entries.length;
+    }
+    if (shown >= 400) {
+      blocks.push("\u2026 (map truncated; narrow with `glob`)");
+      break;
+    }
+  }
+  const label = mode === "code" ? "code signatures" : mode === "docs" ? "document outlines" : "entries";
+  return blocks.length ? blocks.join("\n") : `(no ${label} found)`;
+}
+function fuzzyLineReplace(content, oldStr, newStr) {
+  const norm2 = (s) => s.trim();
+  const cl = content.split("\n");
+  const ol = oldStr.split("\n").map(norm2);
+  while (ol.length && ol[ol.length - 1] === "") ol.pop();
+  while (ol.length && ol[0] === "") ol.shift();
+  if (!ol.length) return null;
+  const matches = [];
+  for (let i2 = 0; i2 + ol.length <= cl.length; i2++) {
+    let ok = true;
+    for (let j = 0; j < ol.length; j++) if (norm2(cl[i2 + j]) !== ol[j]) {
+      ok = false;
+      break;
+    }
+    if (ok) matches.push(i2);
+  }
+  if (matches.length !== 1) return null;
+  const i = matches[0];
+  return [...cl.slice(0, i), ...newStr.split("\n"), ...cl.slice(i + ol.length)].join("\n");
+}
+function parentDir(abs) {
+  const i = abs.lastIndexOf("/");
+  return i <= 0 ? "/" : abs.slice(0, i);
+}
+async function mkdirp(fs, dir) {
+  if (dir === "/" || await fs.exists(dir)) return;
+  await mkdirp(fs, parentDir(dir));
+  if (!await fs.exists(dir)) await fs.createDir(dir);
+}
+function reviewTool() {
+  return {
+    name: "Review",
+    description: 'Critically review your changes before finishing (verification without running code). Pass the task and the paths you changed; a fresh-context senior reviewer reads them COLD and returns concrete issues or "LGTM". Fix what it raises, then finish. Optional `notes` feeds the reviewer extra context.',
+    parameters: {
+      type: "object",
+      required: ["task", "paths"],
+      properties: {
+        task: { type: "string", description: "what was asked \u2014 the spec/requirements to check the changes against" },
+        paths: { type: "array", items: { type: "string" }, description: "the files you changed/created, to be reviewed" },
+        notes: { type: "string", description: "OPTIONAL extra context for the reviewer (rationale, constraints). Omit for a pure cold review." }
+      }
+    },
+    async run({ task, paths, notes }, ctx) {
+      if (!ctx.ai || !ctx.model) return "[Review] no model handle wired \u2014 skipped.";
+      const list = Array.isArray(paths) ? paths.map(String) : [];
+      if (!list.length) return "Error: pass the paths you changed in `paths`.";
+      const files = [];
+      for (const p of list.slice(0, 12)) {
+        try {
+          const body = await ctx.fs.readFile(p);
+          files.push(`--- ${p} ---
+${body.length > 4e3 ? body.slice(0, 4e3) + "\n\u2026(truncated)" : body}`);
+        } catch {
+          files.push(`--- ${p} ---
+[could not read]`);
+        }
+      }
+      const prompt = `You are a senior engineer doing a critical code review. Review the changes below AGAINST THE TASK with deep, skeptical thinking \u2014 default to finding problems.
+Focus on: correctness, edge cases (empty/boundary/negative inputs), unstated-but-implied requirements, and subtle logic bugs. Do NOT comment on style.
+
+TASK:
+${String(task ?? "").trim()}
+
+` + (notes ? `CONTEXT FROM THE AUTHOR:
+${String(notes).trim()}
+
+` : "") + `CHANGED FILES:
+${files.join("\n\n")}
+
+Reply with a short numbered list of concrete, actionable issues. If the changes correctly and completely satisfy the task with no edge cases missed, reply with exactly: LGTM`;
+      try {
+        const r = await ctx.ai.chat({ model: ctx.model, messages: [{ role: "user", content: prompt }], stream: false });
+        const text = (r?.content ?? "").trim();
+        return text || "LGTM";
+      } catch (e) {
+        return `[Review] model error: ${e?.message ?? e} \u2014 skipped.`;
+      }
+    }
+  };
+}
+var fsCwd, globTool, grepTool, SIG_RE, isCode, isDoc, repoMapTool, writeTool, multiEditTool, applyEditsTool;
+var init_tools_structured = __esm({
+  "src/tools.structured.ts"() {
+    "use strict";
+    init_redact();
+    fsCwd = (fs) => fs.getCwd();
+    globTool = {
+      name: "Glob",
+      description: 'Find files by glob pattern (e.g. "**/*.ts", "src/**/*.test.ts"). Returns sorted paths, one per line. Space-separated patterns combine; `!`-prefix excludes (e.g. "**/*.ts !**/*.test.ts"). Prefer over `bash find` for locating files \u2014 one call, structured output.',
+      parameters: {
+        type: "object",
+        required: ["pattern"],
+        properties: { pattern: { type: "string", description: "glob pattern(s); ** matches across directories; prefix a pattern with ! to exclude" } }
+      },
+      async run({ pattern }, ctx) {
+        const pats = String(pattern ?? "").trim().split(/\s+/).filter(Boolean);
+        const include = pats.filter((p) => !p.startsWith("!")).map((p) => anchoredGlob(ctx.fs, p));
+        const exclude = pats.filter((p) => p.startsWith("!")).map((p) => anchoredGlob(ctx.fs, p.slice(1)));
+        const includes = include.length ? include : [anchoredGlob(ctx.fs, "**")];
+        const hits = (await walkFiles(ctx.fs, fsCwd(ctx.fs))).filter(
+          (p) => includes.some((re) => re.test(p)) && !exclude.some((re) => re.test(p))
+        );
+        return hits.length ? hits.join("\n") : "(no matches)";
+      }
+    };
+    grepTool = {
+      name: "Grep",
+      description: "Search file contents by regex. Returns `path:line: text` hits. Optional `glob` to scope files, `context` for surrounding lines, `filesOnly` for matching paths only. Prefer over `bash grep` for file content search \u2014 structured results, no re-parse needed. Use `bash` instead for running commands, tests, or piped workflows.",
+      parameters: {
+        type: "object",
+        required: ["pattern"],
+        properties: {
+          pattern: { type: "string", description: "JS regular expression" },
+          glob: { type: "string", description: "optional file glob to restrict the search" },
+          context: { type: "number", description: "lines of context before/after each hit" },
+          filesOnly: { type: "boolean", description: "only list matching file paths" }
+        }
+      },
+      async run({ pattern, glob, context, filesOnly }, ctx) {
+        let re;
+        try {
+          re = new RegExp(String(pattern ?? ""));
+        } catch (e) {
+          throw new Error(`invalid regex: ${String(e)}`);
+        }
+        const scope = glob ? anchoredGlob(ctx.fs, String(glob)) : null;
+        const files = (await walkFiles(ctx.fs, fsCwd(ctx.fs))).filter((p) => !scope || scope.test(p));
+        const ctxN = Math.max(0, Number(context ?? 0));
+        const out = [];
+        const matched = [];
+        for (const path of files) {
+          let content;
+          try {
+            content = await ctx.fs.readFile(path);
+          } catch {
+            continue;
+          }
+          const lines = content.split("\n");
+          const mask = CONFIG_FILE_RE.test(path);
+          let fileHit = false;
+          for (let i = 0; i < lines.length; i++) {
+            if (!re.test(lines[i])) continue;
+            fileHit = true;
+            if (filesOnly) break;
+            const lo = Math.max(0, i - ctxN), hi = Math.min(lines.length - 1, i + ctxN);
+            for (let j = lo; j <= hi; j++) out.push(`${path}:${j + 1}: ${mask ? redactSecrets(lines[j]) : lines[j]}`);
+          }
+          if (fileHit) matched.push(path);
+        }
+        if (filesOnly) return matched.length ? matched.join("\n") : "(no matches)";
+        return out.length ? out.join("\n") : "(no matches)";
+      }
+    };
+    SIG_RE = /^\s*(export\b|(?:export\s+)?(?:async\s+)?function\s+\*?\w|(?:export\s+)?(?:abstract\s+)?class\s+\w|(?:export\s+)?interface\s+\w|(?:export\s+)?type\s+\w|(?:export\s+)?enum\s+\w)/;
+    isCode = (p) => /\.(ts|tsx|js|jsx|mjs|cjs)$/.test(p);
+    isDoc = (p) => /\.(md|mdx|txt)$/.test(p);
+    repoMapTool = {
+      name: "RepoMap",
+      description: 'Get a compact map of the workspace: code signatures and/or document outlines in ONE call. `scope`: "code" (default) = functions/classes/types; "docs" = markdown headings + summaries; "all" = both. Call once to orient before diving into specific files \u2014 avoids many exploratory Glob/Read calls.',
+      parameters: {
+        type: "object",
+        properties: {
+          glob: { type: "string", description: "optional file glob to scope (default: all matching files)" },
+          scope: { type: "string", enum: ["code", "docs", "all"], description: 'what to map: "code" (default), "docs", or "all"' }
+        }
+      },
+      run: ({ glob, scope }, ctx) => repoIndex(ctx.fs, glob, scope || "code")
+    };
+    writeTool = {
+      name: "Write",
+      description: "Create or overwrite a file with the given contents, creating parent directories as needed. Use for new files instead of `bash echo >`.",
+      parameters: {
+        type: "object",
+        required: ["path", "content"],
+        properties: { path: { type: "string" }, content: { type: "string" } }
+      },
+      async run({ path, content }, ctx) {
+        const body = String(content ?? "");
+        if (ctx.lint) {
+          const err = ctx.lint(path, body);
+          if (err) throw new Error(err);
+        }
+        await mkdirp(ctx.fs, parentDir(ctx.fs.resolvePath(path)));
+        await ctx.fs.writeFile(path, body);
+        ctx.readState.set(ctx.fs.resolvePath(path), body);
+        return `Wrote ${path}`;
+      }
+    };
+    multiEditTool = {
+      name: "MultiEdit",
+      description: "Apply several exact-substring replacements to one file in order, in a single call. Requires a prior Read. Each `old_string` must be unique at the time it is applied. All-or-nothing: if any edit fails, none are written.",
+      parameters: {
+        type: "object",
+        required: ["path", "edits"],
+        properties: {
+          path: { type: "string" },
+          edits: {
+            type: "array",
+            items: {
+              type: "object",
+              required: ["old_string", "new_string"],
+              properties: { old_string: { type: "string" }, new_string: { type: "string" } }
+            }
+          }
+        }
+      },
+      async run({ path, edits }, ctx) {
+        const key = ctx.fs.resolvePath(path);
+        const snapshot = ctx.readState.get(key);
+        if (snapshot == null) throw new Error(`File has not been read yet: ${path}. Read it before editing.`);
+        let current = await ctx.fs.readFile(path);
+        if (current !== snapshot) throw new Error(`File ${path} changed since it was read (stale). Re-read before editing.`);
+        const list = Array.isArray(edits) ? edits : [];
+        if (!list.length) throw new Error("edits must be a non-empty array");
+        for (const [i, e] of list.entries()) {
+          const count = e.old_string === "" ? 0 : current.split(e.old_string).length - 1;
+          if (count === 0) throw new Error(`edit ${i}: old_string not found in ${path}.`);
+          if (count > 1) throw new Error(`edit ${i}: old_string is not unique in ${path} (${count} matches).`);
+          current = current.replace(e.old_string, () => e.new_string);
+        }
+        if (ctx.lint) {
+          const err = ctx.lint(path, current);
+          if (err) throw new Error(err);
+        }
+        await ctx.fs.writeFile(path, current);
+        ctx.readState.set(key, current);
+        return `Applied ${list.length} edit(s) to ${path}`;
+      }
+    };
+    applyEditsTool = {
+      name: "ApplyEdits",
+      description: "Apply edits across one or MORE files in a single call \u2014 for cross-file refactors (rename/extract/move). edits=[{path, old_string?, new_string}]. WITH old_string: replace that exact substring (must be UNIQUE in the file \u2014 add surrounding context; read fresh + verified, no prior Read needed). WITHOUT old_string: write new_string as the whole file (creates it + parent dirs). Locate sites first with Grep (its output shows the exact text). Atomic: validated across all files before any write.",
+      parameters: {
+        type: "object",
+        required: ["edits"],
+        properties: {
+          edits: {
+            type: "array",
+            items: {
+              type: "object",
+              required: ["path", "new_string"],
+              properties: { path: { type: "string" }, old_string: { type: "string" }, new_string: { type: "string" } }
+            }
+          }
+        }
+      },
+      async run({ edits }, ctx) {
+        const list = Array.isArray(edits) ? edits : [];
+        if (!list.length) throw new Error("edits must be a non-empty array of {path, old_string?, new_string}");
+        const planned = /* @__PURE__ */ new Map();
+        for (const [i, e] of list.entries()) {
+          const p = ctx.fs.resolvePath(String(e.path));
+          const old = e.old_string == null ? "" : String(e.old_string);
+          const neu = String(e.new_string ?? "");
+          if (old === "") {
+            planned.set(p, neu);
+            continue;
+          }
+          let cur = planned.has(p) ? planned.get(p) : await ctx.fs.readFile(p).catch(() => {
+            throw new Error(`edit ${i}: file not found: ${e.path}`);
+          });
+          const count = cur.split(old).length - 1;
+          if (count > 1) throw new Error(`edit ${i}: old_string is not unique in ${e.path} (${count} matches) \u2014 add more context`);
+          if (count === 1) cur = cur.replace(old, () => neu);
+          else {
+            const fz = fuzzyLineReplace(cur, old, neu);
+            if (fz == null) throw new Error(`edit ${i}: old_string not found in ${e.path}`);
+            cur = fz;
+          }
+          planned.set(p, cur);
+        }
+        if (ctx.lint) for (const [p, content] of planned) {
+          const err = ctx.lint(p, content);
+          if (err) throw new Error(err);
+        }
+        for (const [p, content] of planned) {
+          await mkdirp(ctx.fs, parentDir(p));
+          await ctx.fs.writeFile(p, content);
+          ctx.readState.set(p, content);
+        }
+        return `Applied ${list.length} edit(s) across ${planned.size} file(s): ${[...planned.keys()].join(", ")}`;
+      }
+    };
+  }
+});
+
+// src/todo.ts
+function renderTodos(todos) {
+  if (todos.length === 0) return "Todo list cleared (no items).";
+  return todos.map((t) => `${MARK[t.status]} ${t.content}`).join("\n");
+}
+var MARK, todoWriteTool;
+var init_todo = __esm({
+  "src/todo.ts"() {
+    "use strict";
+    MARK = {
+      pending: "[ ]",
+      in_progress: "[~]",
+      completed: "[x]"
+    };
+    todoWriteTool = {
+      name: "TodoWrite",
+      description: "Maintain a todo list to plan and track a multi-step task. Replaces the current list with the provided todos and returns the rendered checklist. Mark exactly one item in_progress at a time; flip items to completed as you finish them.",
+      parameters: {
+        type: "object",
+        required: ["todos"],
+        properties: {
+          todos: {
+            type: "array",
+            items: {
+              type: "object",
+              required: ["content", "status"],
+              properties: {
+                content: { type: "string", description: "the step to do" },
+                status: { type: "string", enum: ["pending", "in_progress", "completed"] }
+              }
+            }
+          }
+        }
+      },
+      async run({ todos }, ctx) {
+        if (!Array.isArray(todos)) throw new Error("todos must be an array of { content, status } items.");
+        const next = todos.map((t, i) => {
+          const content = String(t?.content ?? "").trim();
+          if (!content) throw new Error(`todos[${i}].content is required.`);
+          const status = t?.status;
+          if (status !== "pending" && status !== "in_progress" && status !== "completed") {
+            throw new Error(`todos[${i}].status must be one of pending|in_progress|completed (got ${JSON.stringify(status)}).`);
+          }
+          return { content, status };
+        });
+        ctx.todos = next;
+        return renderTodos(next);
+      }
+    };
+  }
+});
+
+// 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, " ");
+  s = s.replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#0?39;/g, "'").replace(/&#x27;/gi, "'");
+  return s.replace(/[ \t\f\v]+/g, " ").split("\n").map((l) => l.trim()).join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+function isPrivateHost(host) {
+  const h = host.toLowerCase().replace(/^\[|\]$/g, "");
+  if (h === "" || h === "localhost" || h.endsWith(".localhost") || h.endsWith(".internal")) return true;
+  if (h === "::1" || h === "::" || h.startsWith("fe80:") || h.startsWith("fc") || h.startsWith("fd")) return true;
+  const m = h.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
+  if (m) {
+    const a = +m[1], b = +m[2];
+    return a === 0 || a === 127 || a === 10 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168 || a === 100 && b >= 64 && b <= 127;
+  }
+  return false;
+}
+async function resolveIps(host) {
+  if (_dnsLookup === void 0) {
+    try {
+      _dnsLookup = (await import("dns/promises")).lookup;
+    } catch {
+      _dnsLookup = null;
+    }
+  }
+  if (!_dnsLookup) return null;
+  try {
+    return (await _dnsLookup(host, { all: true })).map((a) => a.address);
+  } catch {
+    return null;
+  }
+}
+async function readCapped(res, maxBytes) {
+  const reader = res.body?.getReader?.();
+  if (!reader) {
+    const t = await res.text();
+    return t.length > maxBytes ? t.slice(0, maxBytes) : t;
+  }
+  const chunks = [];
+  let total = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    if (value) {
+      chunks.push(value);
+      total += value.length;
+    }
+    if (total >= maxBytes) {
+      try {
+        await reader.cancel();
+      } catch {
+      }
+      break;
+    }
+  }
+  const out = new Uint8Array(Math.min(total, maxBytes));
+  let off = 0;
+  for (const c of chunks) {
+    if (off >= out.length) break;
+    const take = Math.min(c.length, out.length - off);
+    out.set(c.subarray(0, take), off);
+    off += take;
+  }
+  return new TextDecoder().decode(out);
+}
+function makeWebFetchTool(options = {}) {
+  const maxBytes = options.maxBytes ?? 2e6;
+  const maxChars = options.maxChars ?? 1e5;
+  const timeoutMs = options.timeoutMs ?? 15e3;
+  return {
+    name: "WebFetch",
+    description: "Fetch an http/https URL and return its readable text (HTML is stripped to text). Use to read docs or web pages. Returns the status line then up to ~100k chars of content.",
+    parameters: { type: "object", required: ["url"], properties: { url: { type: "string", description: "absolute http(s) URL" } } },
+    async run({ url }) {
+      const doFetch = options.fetch ?? globalThis.fetch;
+      const customFetch = !!options.fetch;
+      const u = String(url ?? "");
+      try {
+        new URL(u);
+      } catch {
+        return `Error: invalid URL: ${u}`;
+      }
+      if (!doFetch) return "Error: no network (fetch) available in this runtime";
+      const hostBlock = async (hostname) => {
+        if (options.allowPrivateHosts) return null;
+        if (isPrivateHost(hostname)) return hostname;
+        if (!customFetch) {
+          const ips = await resolveIps(hostname);
+          if (ips) {
+            for (const ip of ips) if (isPrivateHost(ip)) return `${hostname} \u2192 ${ip}`;
+          }
+        }
+        return null;
+      };
+      const ctl = new AbortController();
+      const timer = setTimeout(() => ctl.abort(), timeoutMs);
+      try {
+        let current = u;
+        let res;
+        for (let hop = 0; ; hop++) {
+          const pu = new URL(current);
+          if (pu.protocol !== "http:" && pu.protocol !== "https:") return `Error: only http/https URLs are allowed (got "${pu.protocol}")`;
+          const blocked = await hostBlock(pu.hostname);
+          if (blocked) return `Error: refusing to fetch a private/internal address (${blocked}) \u2014 set allowPrivateHosts to override`;
+          res = await doFetch(current, { signal: ctl.signal, redirect: "manual", headers: { "user-agent": "agentx (+https://github.com/Livshitz/agent.libx.js)" } });
+          if (res.status >= 300 && res.status < 400 && res.headers.get("location")) {
+            if (hop >= 5) return `Error fetching ${u}: too many redirects`;
+            current = new URL(res.headers.get("location"), current).toString();
+            continue;
+          }
+          break;
+        }
+        const type = res.headers.get("content-type") ?? "";
+        const body = await readCapped(res, maxBytes);
+        const text = /html/i.test(type) || /^\s*<(?:!doctype|html)/i.test(body) ? htmlToText(body) : body.trim();
+        const capped = text.length > maxChars ? text.slice(0, maxChars) + `
+\u2026 [truncated at ${maxChars} chars]` : text;
+        return `${res.status} ${res.statusText} \xB7 ${new URL(current).host}
+
+${capped}`;
+      } catch (e) {
+        log2.debug(`WebFetch ${u} failed`, e);
+        return `Error fetching ${u}: ${e?.name === "AbortError" ? `timed out after ${timeoutMs}ms` : e?.message ?? e}`;
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+  };
+}
+function makeWebSearchTool(options = {}) {
+  const endpoint = options.endpoint ?? "https://api.tavily.com/search";
+  const maxResults = options.maxResults ?? 5;
+  const timeoutMs = options.timeoutMs ?? 15e3;
+  return {
+    name: "WebSearch",
+    description: "Search the web; returns ranked results (title, URL, snippet). Requires a configured provider \u2014 set TAVILY_API_KEY to enable.",
+    parameters: { type: "object", required: ["query"], properties: { query: { type: "string" } } },
+    async run({ query }) {
+      const doFetch = options.fetch ?? globalThis.fetch;
+      const key = options.apiKey ?? process.env.TAVILY_API_KEY;
+      if (!key) return "Error: WebSearch is not configured. Set TAVILY_API_KEY (https://tavily.com) to enable web search.";
+      if (!doFetch) return "Error: no network (fetch) available in this runtime";
+      const ctl = new AbortController();
+      const timer = setTimeout(() => ctl.abort(), timeoutMs);
+      try {
+        const res = await doFetch(endpoint, {
+          method: "POST",
+          signal: ctl.signal,
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({ api_key: key, query: String(query ?? ""), max_results: maxResults })
+        });
+        if (!res.ok) return `Error: search provider returned ${res.status} ${res.statusText}`;
+        const data = await res.json();
+        const results = Array.isArray(data?.results) ? data.results.slice(0, maxResults) : [];
+        if (!results.length) return "(no results)";
+        return results.map((r, i) => `${i + 1}. ${r.title ?? "(untitled)"}
+   ${r.url ?? ""}
+   ${String(r.content ?? "").replace(/\s+/g, " ").slice(0, 240)}`).join("\n\n");
+      } catch (e) {
+        log2.debug("WebSearch failed", e);
+        return `Error searching: ${e?.name === "AbortError" ? `timed out after ${timeoutMs}ms` : e?.message ?? e}`;
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+  };
+}
+var log2, _dnsLookup, webFetchTool, webSearchTool;
+var init_tools_web = __esm({
+  "src/tools.web.ts"() {
+    "use strict";
+    init_logging();
+    log2 = forComponent("web");
+    webFetchTool = makeWebFetchTool();
+    webSearchTool = makeWebSearchTool();
+  }
+});
+
+// src/OverlayFilesystem.ts
+var OverlayFilesystem, asCheckpointable, NEEDS_OVERLAY, checkpointTool, rollbackTool, checkpointTools;
+var init_OverlayFilesystem = __esm({
+  "src/OverlayFilesystem.ts"() {
+    "use strict";
+    OverlayFilesystem = class {
+      constructor(base) {
+        this.base = base;
+      }
+      base;
+      st = { writes: /* @__PURE__ */ new Map(), deletes: /* @__PURE__ */ new Set(), dirs: /* @__PURE__ */ new Set() };
+      snapshots = /* @__PURE__ */ new Map();
+      seq = 0;
+      // ---- path plumbing: delegate to the base so normalization/cwd are identical ----
+      resolvePath(path, cwd) {
+        return this.base.resolvePath(path, cwd ?? this.base.getCwd());
+      }
+      getCwd() {
+        return this.base.getCwd();
+      }
+      setCwd(path) {
+        this.base.setCwd(path);
+      }
+      abs(p) {
+        return this.resolvePath(p);
+      }
+      parent(abs) {
+        const i = abs.lastIndexOf("/");
+        return i <= 0 ? "/" : abs.slice(0, i);
+      }
+      name(abs) {
+        return abs.slice(abs.lastIndexOf("/") + 1);
+      }
+      // ---- reads (overlay wins; tombstones hide the base) ----
+      async readFile(path) {
+        const p = this.abs(path);
+        if (this.st.deletes.has(p)) throw new Error(`File not found: ${path}`);
+        if (this.st.writes.has(p)) return this.st.writes.get(p);
+        return this.base.readFile(p);
+      }
+      async exists(path) {
+        const p = this.abs(path);
+        if (this.st.deletes.has(p)) return false;
+        if (this.st.writes.has(p) || this.st.dirs.has(p)) return true;
+        return this.base.exists(p);
+      }
+      async isFile(path) {
+        const p = this.abs(path);
+        if (this.st.deletes.has(p)) return false;
+        if (this.st.writes.has(p)) return true;
+        if (this.st.dirs.has(p)) return false;
+        return this.base.isFile(p);
+      }
+      async isDirectory(path) {
+        const p = this.abs(path);
+        if (this.st.deletes.has(p)) return false;
+        if (this.st.dirs.has(p)) return true;
+        if (this.st.writes.has(p)) return false;
+        return this.base.isDirectory(p);
+      }
+      async stat(path) {
+        const p = this.abs(path);
+        if (this.st.deletes.has(p)) throw new Error(`File not found: ${path}`);
+        if (this.st.writes.has(p)) {
+          const size = this.st.writes.get(p).length;
+          return { created: /* @__PURE__ */ new Date(0), modified: /* @__PURE__ */ new Date(0), size, permissions: "-rw-r--r--", isExecutable: false };
+        }
+        if (this.st.dirs.has(p)) return { created: /* @__PURE__ */ new Date(0), modified: /* @__PURE__ */ new Date(0), size: 0, permissions: "drwxr-xr-x", isExecutable: false };
+        return this.base.stat(p);
+      }
+      /** Merge base entries (minus tombstones) with overlay-created children of `path`. */
+      async readDir(path) {
+        const p = this.abs(path);
+        if (await this.isFile(p)) throw new Error(`Not a directory: ${path}`);
+        const names = /* @__PURE__ */ new Set();
+        try {
+          for (const n of await this.base.readDir(p)) names.add(n);
+        } catch {
+        }
+        for (const w of [...this.st.writes.keys(), ...this.st.dirs]) if (this.parent(w) === p) names.add(this.name(w));
+        for (const d of this.st.deletes) if (this.parent(d) === p) names.delete(this.name(d));
+        if (names.size === 0 && !await this.exists(p) && p !== "/") throw new Error(`Directory not found: ${path}`);
+        return [...names].sort();
+      }
+      // ---- writes (recorded in the overlay; base untouched until commit) ----
+      async writeFile(path, content) {
+        const p = this.abs(path);
+        if (!await this.exists(this.parent(p))) throw new Error(`Parent directory does not exist: ${path}`);
+        this.st.deletes.delete(p);
+        this.st.writes.set(p, content);
+      }
+      async createDir(path) {
+        const p = this.abs(path);
+        if (await this.exists(p)) throw new Error(`File or directory already exists: ${path}`);
+        if (!await this.exists(this.parent(p))) throw new Error(`Parent directory does not exist: ${path}`);
+        this.st.deletes.delete(p);
+        this.st.dirs.add(p);
+      }
+      async deleteFile(path) {
+        const p = this.abs(path);
+        if (!await this.exists(p)) throw new Error(`File not found: ${path}`);
+        if (await this.isDirectory(p) && (await this.readDir(p)).length > 0) throw new Error(`Directory not empty: ${path}`);
+        this.st.writes.delete(p);
+        this.st.dirs.delete(p);
+        this.st.deletes.add(p);
+      }
+      // ---- checkpointing ----
+      clone(s) {
+        return { writes: new Map(s.writes), deletes: new Set(s.deletes), dirs: new Set(s.dirs) };
+      }
+      /** Capture the current overlay; returns a token to `rollback(token)` to. */
+      snapshot(label) {
+        const token = label ?? `snap-${++this.seq}`;
+        this.snapshots.set(token, this.clone(this.st));
+        return token;
+      }
+      /** Discard all changes since the named snapshot (or the most recent if omitted). */
+      rollback(token) {
+        const key = token ?? [...this.snapshots.keys()].pop();
+        if (key == null || !this.snapshots.has(key)) throw new Error(`No snapshot '${token ?? "(latest)"}'`);
+        this.st = this.clone(this.snapshots.get(key));
+      }
+      /** Paths changed vs the base since this overlay was created (added = not in base, modified = was). */
+      async diff() {
+        const added = [], modified = [];
+        for (const p of this.st.writes.keys()) (await this.base.exists(p) ? modified : added).push(p);
+        return { added: added.sort(), modified: modified.sort(), deleted: [...this.st.deletes].sort() };
+      }
+      /** Flush the overlay into the base (writes, mkdirs, deletes), then clear the overlay. */
+      async commit() {
+        for (const d of this.st.dirs) if (!await this.base.exists(d)) await this.base.createDir(d).catch(() => {
+        });
+        for (const [p, c] of this.st.writes) await this.base.writeFile(p, c);
+        for (const p of this.st.deletes) if (await this.base.exists(p)) await this.base.deleteFile(p).catch(() => {
+        });
+        this.st = { writes: /* @__PURE__ */ new Map(), deletes: /* @__PURE__ */ new Set(), dirs: /* @__PURE__ */ new Set() };
+        this.snapshots.clear();
+      }
+    };
+    asCheckpointable = (fs) => typeof fs?.snapshot === "function" && typeof fs?.rollback === "function" ? fs : null;
+    NEEDS_OVERLAY = "Error: checkpointing requires an OverlayFilesystem (run with `checkpoints: true` over one).";
+    checkpointTool = {
+      name: "Checkpoint",
+      description: "Snapshot the filesystem before a risky or exploratory multi-step change, so you can undo it. Returns a token to pass to Rollback if you need to revert.",
+      parameters: { type: "object", properties: { label: { type: "string", description: "optional name for the checkpoint" } } },
+      async run({ label }, ctx) {
+        const fs = asCheckpointable(ctx.fs);
+        if (!fs) return NEEDS_OVERLAY;
+        return `Checkpoint '${fs.snapshot(label ? String(label) : void 0)}' created \u2014 call Rollback with it to undo everything since.`;
+      }
+    };
+    rollbackTool = {
+      name: "Rollback",
+      description: "Undo ALL filesystem changes made since a Checkpoint. Pass the token from Checkpoint, or omit to revert to the most recent one. Use when an approach went wrong.",
+      parameters: { type: "object", properties: { to: { type: "string", description: "checkpoint token (omit for most recent)" } } },
+      async run({ to }, ctx) {
+        const fs = asCheckpointable(ctx.fs);
+        if (!fs) return NEEDS_OVERLAY;
+        try {
+          fs.rollback(to ? String(to) : void 0);
+          return `Rolled back to checkpoint '${to ?? "(latest)"}'.`;
+        } catch (e) {
+          return `Error: ${e?.message ?? e}`;
+        }
+      }
+    };
+    checkpointTools = () => [checkpointTool, rollbackTool];
+  }
+});
+
+// src/tools.ts
+import { CommandExecutor, registerHeadlessCommands } from "@livx.cc/wcli/core";
+function makeContext(fs, host) {
+  const exec = new CommandExecutor(fs);
+  registerHeadlessCommands(exec);
+  return { fs, exec, readState: /* @__PURE__ */ new Map(), host, todos: [] };
+}
+function toWireTools(tools) {
+  return tools.map((t) => ({
+    type: "function",
+    function: { name: t.name, description: t.description, parameters: t.parameters }
+  }));
+}
+function truncateOutput(s, headLines = 80, tailLines = 20) {
+  const lines = s.split("\n");
+  if (lines.length <= headLines + tailLines + 1) return s;
+  const omitted = lines.length - headLines - tailLines;
+  return [...lines.slice(0, headLines), `\u2026 (${omitted} lines omitted \u2014 narrow the command to see more) \u2026`, ...lines.slice(-tailLines)].join("\n");
+}
+function startBashJob(command, ctx) {
+  const baseFs = ctx.fs;
+  const id = ctx.jobs.start(
+    async ({ signal }) => {
+      const overlay = new OverlayFilesystem(baseFs);
+      const exec = new CommandExecutor(overlay);
+      registerHeadlessCommands(exec);
+      const r = await exec.execute(command);
+      if (signal.aborted) return "[killed before commit]";
+      await overlay.commit();
+      const out = truncateOutput((r.output ?? "").replace(/\n+$/, ""));
+      return r.exitCode !== 0 ? `[exit ${r.exitCode}] ${(r.error ?? "").trim()}
+${out}`.trim() : out || "(command succeeded, no output)";
+    },
+    { kind: "bash", label: command.slice(0, 60) }
+  );
+  return `Started background job ${id} \u2014 poll with JobOutput({id:"${id}"}) / JobStatus, stop with JobKill.`;
+}
+function defaultTools() {
+  return [bashTool, readTool, editTool];
+}
+function toolRegistry() {
+  const all = [bashTool, readTool, editTool, grepTool, globTool, writeTool, multiEditTool, applyEditsTool, repoMapTool, reviewTool(), todoWriteTool, webFetchTool, webSearchTool];
+  return Object.fromEntries(all.map((t) => [t.name, t]));
+}
+function toolsByName(names) {
+  const reg = toolRegistry();
+  return names.map((n) => {
+    const t = reg[n];
+    if (!t) throw new Error(`unknown tool '${n}'. Known: ${Object.keys(reg).join(", ")}`);
+    return t;
+  });
+}
+var numberLines, bashTool, IMG_MIME, readTool, editTool;
+var init_tools = __esm({
+  "src/tools.ts"() {
+    "use strict";
+    init_tools_structured();
+    init_todo();
+    init_tools_web();
+    init_OverlayFilesystem();
+    init_redact();
+    numberLines = (content, offset = 0, limit) => {
+      const lines = content.split("\n");
+      const start = Math.max(0, offset);
+      const end = limit != null ? start + limit : lines.length;
+      return lines.slice(start, end).map((l, i) => `${start + i + 1}	${l}`).join("\n");
+    };
+    bashTool = {
+      name: "bash",
+      description: "Run a shell command. Supports ls, cat, grep, find, head, tail, echo, mkdir, rm, mv, cp, wc, pipes (|), redirects (>, >>), and chaining (&&, ||, ;). Best for: running tests/builds, file operations (mkdir/mv/rm), and piped workflows. For searching file contents, prefer `Grep` (structured results, no re-parse). For finding files by name, prefer `Glob`.",
+      parameters: {
+        type: "object",
+        required: ["command"],
+        properties: {
+          command: { type: "string", description: "the command line to execute" },
+          background: { type: "boolean", description: "run detached over an isolated overlay (writes commit when it finishes); returns a job id to poll with JobOutput. Only worth it for slow work (remote VFS / long pipelines)." }
+        }
+      },
+      async run({ command, background }, ctx) {
+        if (background && ctx.jobs) return startBashJob(String(command ?? ""), ctx);
+        const r = await ctx.exec.execute(String(command ?? ""));
+        const out = truncateOutput((r.output ?? "").replace(/\n+$/, ""));
+        if (r.exitCode !== 0) {
+          const err = (r.error ?? "").trim();
+          return `[exit ${r.exitCode}]${err ? " " + err : ""}${out ? "\n" + out : ""}`;
+        }
+        return out || "(command succeeded, no output)";
+      }
+    };
+    IMG_MIME = { png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", gif: "image/gif", webp: "image/webp" };
+    readTool = {
+      name: "Read",
+      description: "Read a file. Text files return 1-indexed numbered lines (with optional `offset`/`limit` and a re-Read pointer for partial reads). Image files (png/jpg/jpeg/gif/webp) return the picture itself so you can SEE it. Always Read a file before Editing it.",
+      parameters: {
+        type: "object",
+        required: ["path"],
+        properties: {
+          path: { type: "string" },
+          offset: { type: "number" },
+          limit: { type: "number" }
+        }
+      },
+      async run({ path, offset, limit }, ctx) {
+        const ext = String(path).toLowerCase().split(".").pop() ?? "";
+        if (IMG_MIME[ext]) {
+          const fs = ctx.fs;
+          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 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);
+        ctx.readState.set(ctx.fs.resolvePath(path), raw);
+        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);
+        const body = numberLines(content, start, limit);
+        const shownEnd = limit != null ? Math.min(start + limit, total) : total;
+        const shownCount = Math.max(0, shownEnd - start);
+        if (shownCount >= total) return body;
+        if (shownCount === 0) return `[no lines in range (offset ${start}${limit != null ? `, limit ${limit}` : ""}) \u2014 file has ${total} line(s)]`;
+        return `${body}
+
+[lines ${start + 1}\u2013${shownEnd} of ${total} \xB7 re-Read with offset/limit for the rest]`;
+      }
+    };
+    editTool = {
+      name: "Edit",
+      description: "Replace an exact substring in a file. Requires a prior Read of the same file. `old_string` must occur exactly once \u2014 include surrounding context to disambiguate.",
+      parameters: {
+        type: "object",
+        required: ["path", "old_string", "new_string"],
+        properties: {
+          path: { type: "string" },
+          old_string: { type: "string" },
+          new_string: { type: "string" }
+        }
+      },
+      async run({ path, old_string, new_string }, ctx) {
+        const key = ctx.fs.resolvePath(path);
+        const snapshot = ctx.readState.get(key);
+        if (snapshot == null) throw new Error(`File has not been read yet: ${path}. Read it before editing.`);
+        const current = await ctx.fs.readFile(path);
+        if (current !== snapshot) throw new Error(`File ${path} changed since it was read (stale). Re-read before editing.`);
+        const count = old_string === "" ? 0 : current.split(old_string).length - 1;
+        if (count > 1) throw new Error(`old_string is not unique in ${path} (${count} matches). Provide more surrounding context.`);
+        let next, note = "";
+        if (count === 1) {
+          next = current.replace(old_string, () => new_string);
+        } else {
+          const fuzzy = fuzzyLineReplace(current, old_string, new_string);
+          if (fuzzy == null) throw new Error(`old_string not found in ${path}.`);
+          next = fuzzy;
+          note = " (whitespace-tolerant match)";
+        }
+        if (ctx.lint) {
+          const err = ctx.lint(path, next);
+          if (err) throw new Error(err);
+        }
+        await ctx.fs.writeFile(path, next);
+        ctx.readState.set(key, next);
+        return `Edited ${path}${note}`;
+      }
+    };
+  }
+});
+
+// src/NodeDiskFilesystem.ts
+var NodeDiskFilesystem_exports = {};
+__export(NodeDiskFilesystem_exports, {
+  NodeDiskFilesystem: () => NodeDiskFilesystem
+});
+import { promises as fsp } from "fs";
+import * as np from "path";
+import { PathResolver } from "@livx.cc/wcli/core";
+var NodeDiskFilesystem;
+var init_NodeDiskFilesystem = __esm({
+  "src/NodeDiskFilesystem.ts"() {
+    "use strict";
+    NodeDiskFilesystem = class {
+      constructor(baseDir, opts = {}) {
+        this.baseDir = baseDir;
+        this.opts = { denySymlinks: true, ...opts };
+      }
+      baseDir;
+      cwd = "/";
+      opts;
+      /** Ensure the root dir exists. */
+      async init() {
+        await fsp.mkdir(this.baseDir, { recursive: true });
+      }
+      real(vpath) {
+        return np.join(this.baseDir, "." + vpath);
+      }
+      /** Throw if any existing component of `real` is a symlink (escape vector). */
+      async assertNoSymlink(real) {
+        if (!this.opts.denySymlinks) return;
+        const rel = np.relative(this.baseDir, real);
+        if (rel === "" || rel.startsWith("..")) return;
+        let cur = this.baseDir;
+        for (const part of rel.split(np.sep)) {
+          cur = np.join(cur, part);
+          let st;
+          try {
+            st = await fsp.lstat(cur);
+          } catch {
+            return;
+          }
+          if (st.isSymbolicLink()) throw new Error("File not found: symlink not permitted");
+        }
+      }
+      resolvePath(path, cwd) {
+        return PathResolver.resolve(path, cwd || this.cwd);
+      }
+      getCwd() {
+        return this.cwd;
+      }
+      setCwd(path) {
+        this.cwd = PathResolver.normalize(path);
+      }
+      async readFile(path) {
+        const r = this.real(this.resolvePath(path));
+        try {
+          await this.assertNoSymlink(r);
+          const st = await fsp.stat(r);
+          if (st.isDirectory()) throw new Error(`Not a file: ${path}`);
+          return await fsp.readFile(r, "utf8");
+        } catch (e) {
+          if (e instanceof Error && /Not a file/.test(e.message)) throw e;
+          throw new Error(`File not found: ${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) {
+        const r = this.real(this.resolvePath(path));
+        try {
+          await this.assertNoSymlink(r);
+          const st = await fsp.stat(r);
+          if (st.isDirectory()) throw new Error(`Not a file: ${path}`);
+          return await fsp.readFile(r);
+        } catch (e) {
+          if (e instanceof Error && /Not a file/.test(e.message)) throw e;
+          throw new Error(`File not found: ${path}`);
+        }
+      }
+      async writeFile(path, content) {
+        const r = this.real(this.resolvePath(path));
+        await this.assertNoSymlink(r);
+        const parent = np.dirname(r);
+        try {
+          if (!(await fsp.stat(parent)).isDirectory()) throw 0;
+        } catch {
+          throw new Error(`Parent directory does not exist: ${path}`);
+        }
+        await fsp.writeFile(r, content, "utf8");
+      }
+      async deleteFile(path) {
+        const r = this.real(this.resolvePath(path));
+        await this.assertNoSymlink(r);
+        let st;
+        try {
+          st = await fsp.stat(r);
+        } catch {
+          throw new Error(`File not found: ${path}`);
+        }
+        if (st.isDirectory()) {
+          if ((await fsp.readdir(r)).length > 0) throw new Error(`Directory not empty: ${path}`);
+          await fsp.rmdir(r);
+        } else {
+          await fsp.unlink(r);
+        }
+      }
+      async readDir(path) {
+        const r = this.real(this.resolvePath(path));
+        try {
+          await this.assertNoSymlink(r);
+          return await fsp.readdir(r);
+        } catch {
+          throw new Error(`Directory not found: ${path}`);
+        }
+      }
+      async createDir(path) {
+        if (await this.exists(path)) throw new Error(`File or directory already exists: ${path}`);
+        const r = this.real(this.resolvePath(path));
+        await this.assertNoSymlink(r);
+        const parent = np.dirname(r);
+        try {
+          if (!(await fsp.stat(parent)).isDirectory()) throw 0;
+        } catch {
+          throw new Error(`Parent directory does not exist: ${path}`);
+        }
+        await fsp.mkdir(r);
+      }
+      async exists(path) {
+        const r = this.real(this.resolvePath(path));
+        try {
+          await this.assertNoSymlink(r);
+          await fsp.stat(r);
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      async stat(path) {
+        let s;
+        const r = this.real(this.resolvePath(path));
+        try {
+          await this.assertNoSymlink(r);
+          s = await fsp.stat(r);
+        } catch {
+          throw new Error(`File not found: ${path}`);
+        }
+        return {
+          created: s.birthtime,
+          modified: s.mtime,
+          size: s.size,
+          permissions: s.isDirectory() ? "drwxr-xr-x" : "-rw-r--r--",
+          isExecutable: false
+        };
+      }
+      async isDirectory(path) {
+        const r = this.real(this.resolvePath(path));
+        try {
+          await this.assertNoSymlink(r);
+          return (await fsp.stat(r)).isDirectory();
+        } catch {
+          return false;
+        }
+      }
+      async isFile(path) {
+        const r = this.real(this.resolvePath(path));
+        try {
+          await this.assertNoSymlink(r);
+          return (await fsp.stat(r)).isFile();
+        } catch {
+          return false;
+        }
+      }
+    };
+  }
+});
+
+// src/JailedFilesystem.ts
+var JailedFilesystem_exports = {};
+__export(JailedFilesystem_exports, {
+  DEFAULT_DENY: () => DEFAULT_DENY,
+  JailOptions: () => JailOptions,
+  JailedFilesystem: () => JailedFilesystem
+});
+var JailedFilesystem, DEFAULT_DENY, JailOptions;
+var init_JailedFilesystem = __esm({
+  "src/JailedFilesystem.ts"() {
+    "use strict";
+    init_tools_structured();
+    JailedFilesystem = class {
+      constructor(inner, options) {
+        this.inner = inner;
+        this.options = { ...new JailOptions(), ...options };
+        this.denyRe = this.options.deny.map((g) => globToRegExp(g, true));
+        this.roRe = this.options.readonly.map((g) => globToRegExp(g, true));
+        this.confineRe = this.options.confineTo?.map((g) => globToRegExp(g, true));
+      }
+      inner;
+      options;
+      denyRe;
+      roRe;
+      confineRe;
+      abs(path) {
+        return this.inner.resolvePath(path, this.inner.getCwd());
+      }
+      /** Throw if reading `path` is not permitted (denied or out of confinement). */
+      guardRead(op, path) {
+        const abs = this.abs(path);
+        if (this.confineRe && !this.confineRe.some((r) => r.test(abs))) return this.violate(op, abs, "confine");
+        if (this.denyRe.some((r) => r.test(abs))) return this.violate(op, abs, "deny");
+        return abs;
+      }
+      /** Throw if writing/deleting `path` is not permitted (denied, readonly, or out of confinement). */
+      guardWrite(op, path) {
+        const abs = this.guardRead(op, path);
+        if (this.roRe.some((r) => r.test(abs))) return this.violate(op, abs, "readonly");
+        return abs;
+      }
+      violate(op, abs, rule) {
+        this.note(op, abs, rule);
+        if (rule === "deny" || rule === "confine") throw new Error(`File not found: ${abs}`);
+        throw new Error(`Blocked by filesystem jail (${rule}): ${abs}`);
+      }
+      /** Fire the audit hook without throwing (for boolean probes that must still return false). */
+      note(op, abs, rule) {
+        this.options.onViolation?.({ op, path: abs, rule });
+      }
+      /** Is `abs` (already-resolved) visible? If not, fire the audit hook (op given) and return false. */
+      visible(abs, op) {
+        if (this.confineRe && !this.confineRe.some((r) => r.test(abs))) {
+          if (op) this.note(op, abs, "confine");
+          return false;
+        }
+        if (this.denyRe.some((r) => r.test(abs))) {
+          if (op) this.note(op, abs, "deny");
+          return false;
+        }
+        return true;
+      }
+      async readFile(path) {
+        return this.inner.readFile(this.guardRead("readFile", path));
+      }
+      /** Forward the optional binary-read capability (if the inner fs has it), jailed like readFile. */
+      async readFileBytes(path) {
+        const inner = this.inner;
+        if (typeof inner.readFileBytes !== "function") throw new Error("binary read not supported by this filesystem");
+        return inner.readFileBytes(this.guardRead("readFileBytes", path));
+      }
+      async writeFile(path, content) {
+        return this.inner.writeFile(this.guardWrite("writeFile", path), content);
+      }
+      async deleteFile(path) {
+        return this.inner.deleteFile(this.guardWrite("deleteFile", path));
+      }
+      async createDir(path) {
+        return this.inner.createDir(this.guardWrite("createDir", path));
+      }
+      async stat(path) {
+        return this.inner.stat(this.guardRead("stat", path));
+      }
+      // Boolean probes stay invisible (return false on a denied path) BUT still fire the
+      // audit hook — otherwise an agent could enumerate secrets via exists() without
+      // ever tripping the circuit breaker.
+      async exists(path) {
+        const abs = this.abs(path);
+        return this.visible(abs, "exists") ? this.inner.exists(abs) : false;
+      }
+      async isDirectory(path) {
+        const abs = this.abs(path);
+        return this.visible(abs, "isDirectory") ? this.inner.isDirectory(abs) : false;
+      }
+      async isFile(path) {
+        const abs = this.abs(path);
+        return this.visible(abs, "isFile") ? this.inner.isFile(abs) : false;
+      }
+      /** List a directory, filtering out entries the policy hides. */
+      async readDir(path) {
+        const abs = this.guardRead("readDir", path);
+        const entries = await this.inner.readDir(abs);
+        return entries.filter((name) => this.visible(abs === "/" ? `/${name}` : `${abs}/${name}`));
+      }
+      resolvePath(path, cwd) {
+        return this.inner.resolvePath(path, cwd ?? this.inner.getCwd());
+      }
+      getCwd() {
+        return this.inner.getCwd();
+      }
+      /** Guard cwd too: the jail must never be able to "stand" on a denied/out-of-confine dir. */
+      setCwd(path) {
+        const abs = this.abs(path);
+        if (!this.visible(abs, "setCwd")) throw new Error(`File not found: ${abs}`);
+        this.inner.setCwd(abs);
+      }
+    };
+    DEFAULT_DENY = [
+      // env / config secrets
+      "**/.env",
+      "**/.env.*",
+      "**/.npmrc",
+      "**/.netrc",
+      // private keys & certs
+      "**/*.pem",
+      "**/*.key",
+      "**/*.crt",
+      "**/*.cert",
+      "**/*.p12",
+      "**/*.pfx",
+      "**/id_rsa",
+      "**/id_rsa.*",
+      "**/id_ed25519",
+      "**/id_ed25519.*",
+      "**/id_dsa",
+      "**/id_dsa.*",
+      "**/id_ecdsa",
+      "**/id_ecdsa.*",
+      // credential stores (dir AND contents)
+      "**/.ssh",
+      "**/.ssh/**",
+      "**/.aws",
+      "**/.aws/**",
+      "**/.docker",
+      "**/.docker/**",
+      "**/.dockercfg",
+      "**/.kube",
+      "**/.kube/**",
+      "**/.kubeconfig",
+      "**/credentials",
+      "**/.credentials",
+      "**/secrets.json",
+      // VCS internals + git config (can carry tokens / remote creds)
+      "**/.git",
+      "**/.git/**",
+      "**/.gitconfig",
+      "**/.gitmodules"
+    ];
+    JailOptions = class {
+      /** Globs that are invisible and unwritable (secrets). */
+      deny = [...DEFAULT_DENY];
+      /** Globs readable but not writable/deletable (the pinned constitution). */
+      readonly = [];
+      /** If set, only paths matching these globs are accessible at all. */
+      confineTo;
+      /** Audit hook fired on every blocked operation (drives the circuit breaker). */
+      onViolation;
+    };
+  }
+});
+
+// src/tools.shell.ts
+var tools_shell_exports = {};
+__export(tools_shell_exports, {
+  ShellJobRegistry: () => ShellJobRegistry,
+  makeRealShellTool: () => makeRealShellTool,
+  makeShellJobTools: () => makeShellJobTools
+});
+function childEnv(opts) {
+  const base = {};
+  const redact = opts.redactEnv !== false;
+  for (const [k, v] of Object.entries(process.env)) if (!(redact && SECRET_ENV_RE.test(k))) base[k] = v;
+  return { ...base, ...opts.env };
+}
+async function nodeSpawn() {
+  if (!_spawn) _spawn = (await import("child_process")).spawn;
+  return _spawn;
+}
+function makeRealShellTool(options) {
+  const timeoutMs = options.timeoutMs ?? 12e4;
+  return {
+    name: "Shell",
+    description: "Run a shell command via /bin/sh in the working directory. Executes any installed binary \u2014 ls, cat, grep, git, bun, node, curl, scripts, etc. Returns combined stdout+stderr; non-zero exits are prefixed `[exit N]`. Set `background:true` for long-running processes (servers, watchers) \u2014 returns a job id immediately; poll with ShellOutput, stop with ShellKill.",
+    parameters: {
+      type: "object",
+      required: ["command"],
+      properties: {
+        command: { type: "string", description: "the shell command line to execute" },
+        background: { type: "boolean", description: "run detached and return a job id immediately (for servers/watchers/long builds)" }
+      }
+    },
+    async run({ command, background }, ctx) {
+      const cmd = String(command ?? "");
+      if (!cmd.trim()) return "[exit 1] empty command";
+      if (background) {
+        if (!options.registry) return "Error: background execution is not enabled in this host (no job registry).";
+        const id = await options.registry.start(cmd);
+        return `Started background job ${id}. Poll output with ShellOutput({id:"${id}"}), check ShellStatus({id:"${id}"}), stop with ShellKill({id:"${id}"}).`;
+      }
+      const spawn = options.spawn ?? await nodeSpawn();
+      const ctl = new AbortController();
+      const onAbort = () => ctl.abort();
+      if (ctx.signal) {
+        if (ctx.signal.aborted) ctl.abort();
+        else ctx.signal.addEventListener("abort", onAbort, { once: true });
+      }
+      let timedOut = false;
+      const timer = setTimeout(() => {
+        timedOut = true;
+        ctl.abort();
+      }, timeoutMs);
+      try {
+        return await new Promise((resolve) => {
+          let out = "";
+          let settled = false;
+          const finish = (s) => {
+            if (settled) return;
+            settled = true;
+            resolve(s);
+          };
+          let proc;
+          try {
+            proc = spawn("/bin/sh", ["-c", cmd], { cwd: options.cwd, env: childEnv(options), signal: ctl.signal });
+          } catch (e) {
+            return finish(`[exit 1] failed to spawn shell: ${e?.message ?? e}`);
+          }
+          const collect = (chunk) => {
+            out += typeof chunk === "string" ? chunk : chunk?.toString?.("utf8") ?? "";
+          };
+          proc.stdout?.on("data", collect);
+          proc.stderr?.on("data", collect);
+          proc.on("error", (err) => {
+            if (err?.name === "AbortError" || ctl.signal.aborted) return finish(reasonFor(timedOut, timeoutMs, clean(out)));
+            log4.debug("shell spawn error", err);
+            finish(`[exit 1] ${err?.message ?? err}${out ? "\n" + clean(out) : ""}`);
+          });
+          proc.on("close", (code) => {
+            if (ctl.signal.aborted) return finish(reasonFor(timedOut, timeoutMs, clean(out)));
+            const body = clean(out);
+            if (code && code !== 0) return finish(`[exit ${code}]${body ? "\n" + body : ""}`);
+            finish(body || "(command succeeded, no output)");
+          });
+        });
+      } finally {
+        clearTimeout(timer);
+        ctx.signal?.removeEventListener("abort", onAbort);
+      }
+    }
+  };
+}
+function reasonFor(timedOut, timeoutMs, body) {
+  const head = timedOut ? `[exit 124] timed out after ${timeoutMs}ms (killed)` : "[exit 130] cancelled (killed)";
+  return body ? `${head}
+${body}` : head;
+}
+function makeShellJobTools(registry) {
+  const idParam = { type: "object", properties: { id: { type: "string", description: "the job id from Shell({background:true})" } } };
+  return [
+    {
+      name: "ShellOutput",
+      description: "Read the accumulated output (tail) of a background Shell job by id.",
+      parameters: { type: "object", required: ["id"], properties: { id: { type: "string" } } },
+      async run({ id }) {
+        const out = registry.output(String(id));
+        if (out == null) return NO_JOB2(String(id));
+        const st = registry.status(String(id));
+        return `[${st.status}${st.exitCode != null ? ` exit ${st.exitCode}` : ""}]
+${clean(out) || "(no output yet)"}`;
+      }
+    },
+    {
+      name: "ShellStatus",
+      description: "Status of a background Shell job (running/exited/killed + exit code). Omit `id` to list all jobs.",
+      parameters: idParam,
+      async run({ id }) {
+        if (!id) {
+          const jobs = registry.list();
+          return jobs.length ? jobs.map((j) => `${j.id}  ${j.status}  ${j.command}`).join("\n") : "(no background jobs)";
+        }
+        const st = registry.status(String(id));
+        return st ? `${st.status}${st.exitCode != null ? ` (exit ${st.exitCode})` : ""} \xB7 ${st.bytes} byte(s) buffered` : NO_JOB2(String(id));
+      }
+    },
+    {
+      name: "ShellKill",
+      description: "Stop a running background Shell job by id (SIGTERM).",
+      parameters: { type: "object", required: ["id"], properties: { id: { type: "string" } } },
+      async run({ id }) {
+        return registry.kill(String(id)) ? `Killed job ${id}.` : NO_JOB2(String(id));
+      }
+    }
+  ];
+}
+var log4, clean, SECRET_ENV_RE, _spawn, ShellJobRegistry, NO_JOB2;
+var init_tools_shell = __esm({
+  "src/tools.shell.ts"() {
+    "use strict";
+    init_tools();
+    init_redact();
+    init_logging();
+    log4 = forComponent("shell");
+    clean = (s) => truncateOutput(redactSecrets(s.replace(/\n+$/, "")));
+    SECRET_ENV_RE = /(_API_KEY|_TOKEN|_SECRET|_PASSWORD|_PRIVATE_KEY|^AWS_|^GITHUB_TOKEN$|^OPENAI_|^ANTHROPIC_|^GOOGLE_|^GEMINI_|^GROQ_|^NPM_TOKEN$)/i;
+    ShellJobRegistry = class {
+      constructor(cfg) {
+        this.cfg = cfg;
+        if (cfg.killOnExit && typeof process !== "undefined") process.once("exit", () => this.killAll());
+      }
+      cfg;
+      jobs = /* @__PURE__ */ new Map();
+      seq = 0;
+      async start(command) {
+        const id = `job-${++this.seq}`;
+        const max = this.cfg.maxBuffer ?? 256 * 1024;
+        const job = { command, buf: "", status: "running" };
+        const append = (chunk) => {
+          const s = typeof chunk === "string" ? chunk : chunk?.toString?.("utf8") ?? "";
+          job.buf = (job.buf + s).slice(-max);
+        };
+        try {
+          const spawn = this.cfg.spawn ?? await nodeSpawn();
+          const proc = spawn("/bin/sh", ["-c", command], { cwd: this.cfg.cwd, env: childEnv(this.cfg) });
+          job.proc = proc;
+          proc.stdout?.on("data", append);
+          proc.stderr?.on("data", append);
+          proc.on("error", (err) => {
+            if (job.status === "running") {
+              job.status = "error";
+              append(`
+[error] ${err?.message ?? err}`);
+            }
+          });
+          proc.on("close", (code) => {
+            if (job.status === "running") {
+              job.status = "exited";
+              job.exitCode = code ?? void 0;
+            }
+          });
+        } catch (e) {
+          job.status = "error";
+          job.buf = `failed to spawn: ${e?.message ?? e}`;
+        }
+        this.jobs.set(id, job);
+        return id;
+      }
+      /** Current tail output for a job (null = no such job). */
+      output(id) {
+        return this.jobs.get(id)?.buf ?? (this.jobs.has(id) ? "" : null);
+      }
+      status(id) {
+        const j = this.jobs.get(id);
+        return j ? { status: j.status, exitCode: j.exitCode, bytes: j.buf.length } : null;
+      }
+      list() {
+        return [...this.jobs].map(([id, j]) => ({ id, command: j.command, status: j.status }));
+      }
+      kill(id) {
+        const j = this.jobs.get(id);
+        if (!j) return false;
+        if (j.status === "running") {
+          try {
+            j.proc?.kill("SIGTERM");
+          } catch {
+          }
+          j.status = "killed";
+        }
+        return true;
+      }
+      killAll() {
+        for (const id of this.jobs.keys()) this.kill(id);
+      }
+    };
+    NO_JOB2 = (id) => `Error: no background job '${id}'. Use ShellStatus with no id to list jobs, or start one with Shell({background:true}).`;
+  }
+});
+
+// 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_tools();
+
+// src/tools.jobs.ts
+var SandboxJobRegistry = class {
+  constructor(maxBuffer = 256 * 1024) {
+    this.maxBuffer = maxBuffer;
+  }
+  maxBuffer;
+  jobs = /* @__PURE__ */ new Map();
+  seq = 0;
+  /** Start `fn` in the background and return a job id immediately (does not await completion). */
+  start(fn, opts = {}) {
+    const id = `job-${++this.seq}`;
+    const ctl = new AbortController();
+    const onChunk = (s) => {
+      job.buf = (job.buf + s).slice(-this.maxBuffer);
+    };
+    const job = { kind: opts.kind ?? "task", label: opts.label ?? "", status: "running", buf: "", ctl, promise: Promise.resolve() };
+    job.promise = fn({ signal: ctl.signal, onChunk }).then(
+      (res) => {
+        if (job.status === "running") {
+          job.status = "done";
+          if (res) onChunk(res);
+        }
+      },
+      (e) => {
+        if (job.status === "running") {
+          job.status = "error";
+          onChunk(`
+[error] ${e?.message ?? e}`);
+        }
+      }
+    );
+    this.jobs.set(id, job);
+    return id;
+  }
+  /** Tail output for a job (null = no such job, '' = job exists but no output yet). */
+  output(id) {
+    return this.jobs.get(id)?.buf ?? (this.jobs.has(id) ? "" : null);
+  }
+  status(id) {
+    const j = this.jobs.get(id);
+    return j ? { status: j.status, bytes: j.buf.length } : null;
+  }
+  list() {
+    return [...this.jobs].map(([id, j]) => ({ id, kind: j.kind, label: j.label, status: j.status }));
+  }
+  /** Signal cancel (the producer decides what abort means — e.g. skip the overlay commit). */
+  kill(id) {
+    const j = this.jobs.get(id);
+    if (!j) return false;
+    if (j.status === "running") {
+      j.ctl.abort();
+      j.status = "killed";
+    }
+    return true;
+  }
+  killAll() {
+    for (const id of this.jobs.keys()) this.kill(id);
+  }
+  /** Await every still-running job. Called at turn end so a job's committed writes aren't lost from view
+   *  just because the model didn't poll it. Returns the ids that were still running when drain began. */
+  async drain() {
+    const pending = [...this.jobs].filter(([, j]) => j.status === "running").map(([id]) => id);
+    await Promise.all([...this.jobs.values()].map((j) => j.promise));
+    return pending;
+  }
+};
+var NO_JOB = (id) => `Error: no background job '${id}'. Use JobStatus with no id to list jobs, or start one with bash({background:true}).`;
+function makeJobTools(registry) {
+  return [
+    {
+      name: "JobOutput",
+      description: "Read the accumulated output (tail) of a background job by id (from bash({background:true})).",
+      parameters: { type: "object", required: ["id"], properties: { id: { type: "string" } } },
+      async run({ id }) {
+        const out = registry.output(String(id));
+        if (out == null) return NO_JOB(String(id));
+        const st = registry.status(String(id));
+        return `[${st.status}]
+${out.replace(/\n+$/, "") || "(no output yet)"}`;
+      }
+    },
+    {
+      name: "JobStatus",
+      description: "Status of a background job (running/done/killed/error). Omit `id` to list all jobs.",
+      parameters: { type: "object", properties: { id: { type: "string" } } },
+      async run({ id }) {
+        if (!id) {
+          const jobs = registry.list();
+          return jobs.length ? jobs.map((j) => `${j.id}  ${j.status}  ${j.kind}${j.label ? "  " + j.label : ""}`).join("\n") : "(no background jobs)";
+        }
+        const st = registry.status(String(id));
+        return st ? `${st.status} \xB7 ${st.bytes} byte(s) buffered` : NO_JOB(String(id));
+      }
+    },
+    {
+      name: "JobKill",
+      description: "Stop a running background job by id (the job is cancelled; its overlay writes are NOT committed).",
+      parameters: { type: "object", required: ["id"], properties: { id: { type: "string" } } },
+      async run({ id }) {
+        return registry.kill(String(id)) ? `Killed job ${id}.` : NO_JOB(String(id));
+      }
+    }
+  ];
+}
+
+// src/host.ts
+var askUserQuestionTool = {
+  name: "AskUserQuestion",
+  description: "Ask the user a multiple-choice question when a decision is genuinely theirs to make (ambiguous requirement, a fork you cannot resolve from context). Returns their selection.",
+  parameters: {
+    type: "object",
+    required: ["question", "options"],
+    properties: {
+      question: { type: "string" },
+      header: { type: "string", description: "short label for the question" },
+      options: {
+        type: "array",
+        items: { type: "object", required: ["label"], properties: { label: { type: "string" }, description: { type: "string" } } }
+      },
+      multiSelect: { type: "boolean" }
+    }
+  },
+  async run(args, ctx) {
+    if (!ctx.host?.ask) {
+      const fallback = args.options?.[0]?.label ?? "";
+      return `No interactive user is available \u2014 proceed using your best judgment.${fallback ? ` (Closest default: "${fallback}")` : ""}`;
+    }
+    return ctx.host.ask(args);
+  }
+};
+var ScriptedHostBridge = class {
+  constructor(answers = [], confirmDefault = true) {
+    this.answers = answers;
+    this.confirmDefault = confirmDefault;
+  }
+  answers;
+  confirmDefault;
+  asked = [];
+  confirms = [];
+  events = [];
+  async ask(q) {
+    this.asked.push(q);
+    return this.answers.shift() ?? q.options[0]?.label ?? "";
+  }
+  async confirm(prompt) {
+    this.confirms.push(prompt);
+    return this.confirmDefault;
+  }
+  notify(event) {
+    this.events.push(event);
+  }
+};
+var ConsoleHostBridge = class {
+  async ask(q) {
+    const rl = await import("readline/promises");
+    const io = rl.createInterface({ input: process.stdin, output: process.stdout });
+    try {
+      const lines = [q.header ? `
+[${q.header}] ${q.question}` : `
+${q.question}`];
+      q.options.forEach((o, i) => lines.push(`  ${i + 1}) ${o.label}${o.description ? " \u2014 " + o.description : ""}`));
+      const ans = await io.question(lines.join("\n") + "\n> ");
+      const n = Number(ans.trim());
+      return Number.isInteger(n) && q.options[n - 1] ? q.options[n - 1].label : ans.trim();
+    } finally {
+      io.close();
+    }
+  }
+  async confirm(prompt) {
+    const rl = await import("readline/promises");
+    const io = rl.createInterface({ input: process.stdin, output: process.stdout });
+    try {
+      const ans = await io.question(`
+${prompt} [y/N] `);
+      return /^y(es)?$/i.test(ans.trim());
+    } finally {
+      io.close();
+    }
+  }
+  notify(event) {
+    console.error(`[${event.kind}] ${event.message}`);
+  }
+};
+
+// src/relevance.ts
+var STOP = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "for",
+  "with",
+  "that",
+  "this",
+  "from",
+  "into",
+  "your",
+  "you",
+  "are",
+  "was",
+  "will",
+  "use",
+  "using",
+  "run",
+  "add",
+  "fix",
+  "make",
+  "file",
+  "files",
+  "code",
+  "please",
+  "need",
+  "want",
+  "should",
+  "all"
+]);
+function tokenize(s) {
+  const out = /* @__PURE__ */ new Set();
+  for (const w of String(s ?? "").toLowerCase().match(/[a-z0-9]+/g) ?? []) {
+    if (w.length >= 3 && !STOP.has(w)) out.add(w);
+  }
+  return out;
+}
+function idfWeights(corpus) {
+  const N = corpus.length;
+  if (N === 0) return /* @__PURE__ */ new Map();
+  const df = /* @__PURE__ */ new Map();
+  for (const doc of corpus) for (const t of tokenize(doc)) df.set(t, (df.get(t) ?? 0) + 1);
+  const idf = /* @__PURE__ */ new Map();
+  for (const [t, n] of df) idf.set(t, Math.log((N + 1) / (n + 1)) + 1);
+  return idf;
+}
+function relevanceScore(text, queryTokens, idf) {
+  if (queryTokens.size === 0) return 0;
+  const t = tokenize(text);
+  let score = 0;
+  for (const q of queryTokens) if (t.has(q)) score += idf?.get(q) ?? 1;
+  return score;
+}
+function topByRelevance(items, query, text, k, corpus) {
+  if (!Number.isInteger(k) || k < 1) return { kept: items, rest: [] };
+  if (items.length <= k || !query.trim()) return { kept: items, rest: [] };
+  const q = tokenize(query);
+  if (q.size === 0) return { kept: items.slice(0, k), rest: items.slice(k) };
+  const idf = corpus?.length ? idfWeights(corpus) : void 0;
+  const scored = items.map((x, i) => ({ i, s: relevanceScore(text(x), q, idf) }));
+  scored.sort((a, b) => b.s - a.s || a.i - b.i);
+  const keep = new Set(scored.slice(0, k).map((e) => e.i));
+  return { kept: items.filter((_, i) => keep.has(i)), rest: items.filter((_, i) => !keep.has(i)) };
+}
+
+// src/frontmatter.ts
+function splitFrontmatter(md) {
+  const m = md.match(/^---\s*\n([\s\S]*?)\n---\s*\n?/);
+  return { block: m ? m[1] : "", body: (m ? md.slice(m[0].length) : md).trim() };
+}
+function grabField(block, key) {
+  const lines = block.split("\n");
+  const i = lines.findIndex((l) => new RegExp(`^${key}\\s*:`, "i").test(l));
+  if (i < 0) return void 0;
+  const inline = lines[i].replace(new RegExp(`^${key}\\s*:\\s*`, "i"), "");
+  if (/^[>|][+-]?\s*$/.test(inline)) {
+    const folded = [];
+    for (let j = i + 1; j < lines.length && /^\s+\S/.test(lines[j]); j++) folded.push(lines[j].trim());
+    return folded.join(" ").trim() || void 0;
+  }
+  return inline.trim().replace(/^["']|["']$/g, "") || void 0;
+}
+
+// src/skills.ts
+var MAX_CATALOG = 25;
+function parseFrontmatter(md) {
+  const { block } = splitFrontmatter(md);
+  const b = block || md.slice(0, 600);
+  return { name: grabField(b, "name"), description: grabField(b, "description") };
+}
+async function loadSkills(fs, dir, opts = {}) {
+  const skills = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const d of Array.isArray(dir) ? dir : [dir]) {
+    if (!await fs.exists(d)) continue;
+    for (const entry of await fs.readDir(d)) {
+      if (seen.has(entry)) continue;
+      const skillMd = `${d}/${entry}/SKILL.md`;
+      if (await fs.exists(skillMd)) {
+        seen.add(entry);
+        const fm = parseFrontmatter(await fs.readFile(skillMd));
+        skills.push({ name: fm.name || entry, description: fm.description || "", path: skillMd });
+      }
+    }
+  }
+  if (skills.length === 0) return { skills, catalog: "" };
+  const { kept, rest } = topByRelevance(skills, opts.relevanceHint ?? "", (s) => `${s.name} ${s.description}`, opts.max ?? MAX_CATALOG);
+  const catalog = "## Skills (load one before acting on a matching task)\n" + kept.map((s) => `- **${s.name}** \u2014 ${s.description} (\`${s.path}\`)`).join("\n") + (rest.length ? `
+- (${rest.length} more, names only \u2014 call \`Skill\` to load): ${rest.map((s) => s.name).join(", ")}` : "") + "\nWhen a task matches a skill, call the `Skill` tool with its name to load its full instructions.";
+  const tool = {
+    name: "Skill",
+    description: "Load a skill by name \u2014 returns its full instructions (SKILL.md). Use when a task matches a listed skill.",
+    parameters: { type: "object", required: ["name"], properties: { name: { type: "string" } } },
+    async run({ name }, ctx) {
+      const s = skills.find((x) => x.name === name);
+      if (!s) return `Error: no skill named '${name}'. Available: ${skills.map((x) => x.name).join(", ")}`;
+      return ctx.fs.readFile(s.path);
+    }
+  };
+  return { skills, catalog, tool };
+}
+
+// src/commands.ts
+var MAX_CATALOG2 = 25;
+function parseFrontmatter2(md) {
+  const { block, body } = splitFrontmatter(md);
+  return { description: grabField(block, "description"), body };
+}
+function expandTemplate(body, args) {
+  if (!/\$ARGUMENTS|\$[1-9]/.test(body)) return args ? `${body}
+
+${args}` : body;
+  const toks = args.trim() ? args.trim().split(/\s+/) : [];
+  return body.split("$ARGUMENTS").join(args).replace(/\$([1-9])/g, (_m, n) => toks[Number(n) - 1] ?? "");
+}
+async function embedFiles(text, fs) {
+  const refs = [...new Set([...text.matchAll(/(?:^|\s)@(\S+)/g)].map((m) => m[1]))];
+  let out = text;
+  for (const ref of refs) {
+    try {
+      const content = await fs.readFile(ref);
+      out = out.split("@" + ref).join(`
+
+--- @${ref} ---
+${content}
+--- end @${ref} ---
+`);
+    } catch {
+    }
+  }
+  return out;
+}
+async function expandCommand(fs, cmd, args) {
+  const { body } = parseFrontmatter2(await fs.readFile(cmd.path));
+  return embedFiles(expandTemplate(body, args), fs);
+}
+async function loadCommands(fs, dir, opts = {}) {
+  const commands = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const d of Array.isArray(dir) ? dir : [dir]) {
+    if (!await fs.exists(d)) continue;
+    for (const entry of await fs.readDir(d)) {
+      if (!entry.endsWith(".md")) continue;
+      const name = entry.replace(/\.md$/, "");
+      if (seen.has(name)) continue;
+      seen.add(name);
+      const path = `${d}/${entry}`;
+      const fm = parseFrontmatter2(await fs.readFile(path));
+      commands.push({ name, description: fm.description || "", path });
+    }
+  }
+  if (commands.length === 0) return { commands, catalog: "" };
+  const { kept, rest } = topByRelevance(commands, opts.relevanceHint ?? "", (c) => `${c.name} ${c.description}`, opts.max ?? MAX_CATALOG2);
+  const catalog = "## Slash commands (reusable prompt templates)\n" + kept.map((c) => `- **/${c.name}** \u2014 ${c.description} (\`${c.path}\`)`).join("\n") + (rest.length ? `
+- (${rest.length} more, names only \u2014 call \`SlashCommand\` to run): ${rest.map((c) => c.name).join(", ")}` : "") + "\nTo run one, call the `SlashCommand` tool with its name (and optional `args`); it returns the expanded template to act on.";
+  const tool = {
+    name: "SlashCommand",
+    description: "Run a slash command by name \u2014 returns its expanded prompt template (with your `args` substituted/appended). Use when a task matches a listed command.",
+    parameters: {
+      type: "object",
+      required: ["name"],
+      properties: { name: { type: "string" }, args: { type: "string", description: "arguments to fill the template" } }
+    },
+    async run({ name, args }, ctx) {
+      const slug = String(name ?? "").replace(/^\//, "");
+      const c = commands.find((x) => x.name === slug);
+      if (!c) return `Error: no command named '${slug}'. Available: ${commands.map((x) => x.name).join(", ")}`;
+      return expandCommand(ctx.fs, c, String(args ?? ""));
+    }
+  };
+  return { commands, catalog, tool };
+}
+
+// src/memory.ts
+init_tools_structured();
+var MAX_INDEX = 25;
+async function loadMemory(fs, dir, opts = {}) {
+  const indexPath = `${dir}/MEMORY.md`;
+  const tools = [recallTool(fs, dir), rememberTool(fs, dir), memorySearchTool(fs, dir)];
+  const md = await fs.exists(indexPath) ? (await fs.readFile(indexPath)).trim() : "";
+  if (!md) return { index: "", tools };
+  const lines = md.split("\n");
+  const pointers = lines.filter((l) => /^\s*-\s*\[.+\]\(.+\.md\)/.test(l));
+  const header = lines.filter((l) => !/^\s*-\s*\[.+\]\(.+\.md\)/.test(l)).join("\n").trim();
+  const { kept, rest } = topByRelevance(pointers, opts.relevanceHint ?? "", (l) => l, opts.max ?? MAX_INDEX);
+  const restSlugs = rest.map((l) => l.match(/\]\(([^)]+)\.md\)/)?.[1] ?? l.match(/\[([^\]]+)\]/)?.[1] ?? "").filter(Boolean);
+  const index = "## Memory (persistent context \u2014 recalled across sessions)\n" + (header ? header + "\n" : "") + kept.join("\n") + (restSlugs.length ? `
+- (${restSlugs.length} more learnings, slugs only \u2014 call \`Recall\` if relevant): ${restSlugs.join(", ")}` : "") + `
+
+These are pointers only. Call \`Recall\` with a slug (or multiple slugs/a pattern) to load full bodies when relevant.
+Call \`MemorySearch\` with a query to find memories by content when you don't know the slug.
+Call \`Remember\` to persist a durable fact for future sessions.`;
+  return { index, tools };
+}
+function slugify(s, fallback = "note") {
+  const base = String(s ?? "").trim().toLowerCase().replace(/\.md$/i, "").replace(/[^\w\s-]/g, "").replace(/[\s_]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 48);
+  return base || fallback;
+}
+async function writeFact(fs, dir, slug, body) {
+  await mkdirp(fs, dir);
+  await fs.writeFile(`${dir}/${slug}.md`, body.endsWith("\n") ? body : body + "\n");
+  const indexPath = `${dir}/MEMORY.md`;
+  const idx = await fs.exists(indexPath) ? await fs.readFile(indexPath) : "# Memory Index\n";
+  const line = `- [${slug}](${slug}.md) \u2014 ${body.split("\n")[0].slice(0, 80)}`;
+  const lines = idx.split("\n");
+  const at = lines.findIndex((l) => l.includes(`(${slug}.md)`));
+  if (at >= 0) {
+    if (lines[at] !== line) {
+      lines[at] = line;
+      await fs.writeFile(indexPath, lines.join("\n"));
+    }
+  } else {
+    await fs.writeFile(indexPath, idx.replace(/\s*$/, "") + `
+${line}
+`);
+  }
+}
+function cleanSlug(raw) {
+  let s = String(raw ?? "").trim().replace(/\.md$/i, "").replace(/\\/g, "/").replace(/\/+/g, "/").replace(/^\/|\/$/g, "");
+  while (s.includes("..")) s = s.replace(/\.\./g, "");
+  return s;
+}
+async function listSlugs(fs, dir, prefix = "") {
+  let entries;
+  try {
+    entries = await fs.readDir(dir);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const e of entries.sort()) {
+    const full = dir === "/" ? `/${e}` : `${dir}/${e}`;
+    const rel = prefix ? `${prefix}/${e}` : e;
+    if (await fs.isDirectory(full)) out.push(...await listSlugs(fs, full, rel));
+    else if (e.endsWith(".md") && e !== "MEMORY.md") out.push(rel.replace(/\.md$/, ""));
+  }
+  return out;
+}
+async function loadFact(fs, dir, slug) {
+  const path = `${dir}/${slug}.md`;
+  try {
+    return await fs.readFile(path);
+  } catch {
+    return null;
+  }
+}
+function recallTool(fs, dir) {
+  return {
+    name: "Recall",
+    description: 'Load memory facts by slug. Pass `slug` for one, `slugs` for several, or `pattern` (glob like "auth*") to match. Returns full bodies, separated by `--- slug ---` headers.',
+    parameters: {
+      type: "object",
+      properties: {
+        slug: { type: "string", description: "single fact slug (filename without .md)" },
+        slugs: { type: "array", items: { type: "string" }, description: "multiple slugs to load at once" },
+        pattern: { type: "string", description: 'glob pattern to match against slugs (e.g. "auth*", "*database*")' }
+      }
+    },
+    async run({ slug, slugs, pattern }, ctx) {
+      let targets = [];
+      if (slug) targets = [cleanSlug(slug)];
+      else if (Array.isArray(slugs)) targets = slugs.map(cleanSlug).filter(Boolean);
+      else if (pattern) {
+        const escaped = String(pattern).replace(/[.+^${}()|[\]\\]/g, "\\$&");
+        const re = new RegExp("^" + escaped.replace(/\*/g, ".*").replace(/\?/g, ".") + "$", "i");
+        targets = (await listSlugs(ctx.fs, dir)).filter((s) => re.test(s));
+      }
+      if (!targets.length) return `Error: no slugs resolved. Pass slug, slugs, or pattern.`;
+      const parts = [];
+      for (const s of targets.slice(0, 20)) {
+        const body = await loadFact(ctx.fs, dir, s);
+        if (body != null) parts.push(targets.length > 1 ? `--- ${s} ---
+${body}` : body);
+        else parts.push(targets.length > 1 ? `--- ${s} ---
+[not found]` : `Error: no memory fact '${s}'.`);
+      }
+      if (targets.length > 20) parts.push(`(${targets.length - 20} more matched \u2014 narrow the pattern)`);
+      return parts.join("\n\n");
+    }
+  };
+}
+function memorySearchTool(fs, dir) {
+  return {
+    name: "MemorySearch",
+    description: "Search memory facts by content \u2014 find relevant memories when you don't know the exact slug. Returns up to 10 matching slug + snippet pairs, ranked by relevance. Use `regex: true` for regex patterns.",
+    parameters: {
+      type: "object",
+      required: ["query"],
+      properties: {
+        query: { type: "string", description: "search query (keywords or regex pattern)" },
+        regex: { type: "boolean", description: "treat query as a regex pattern (default: false)" }
+      }
+    },
+    async run({ query, regex }, ctx) {
+      const q = String(query ?? "").trim();
+      if (!q) return "Error: empty query.";
+      const slugs = await listSlugs(ctx.fs, dir);
+      if (!slugs.length) return "(no memory facts found)";
+      let matcher;
+      if (regex) {
+        try {
+          const re = new RegExp(q, "i");
+          matcher = (l) => re.test(l);
+        } catch (e) {
+          return `Error: invalid regex: ${e}`;
+        }
+      } else {
+        const lower = q.toLowerCase();
+        matcher = (l) => l.toLowerCase().includes(lower);
+      }
+      const loaded = [];
+      for (const slug of slugs) {
+        const body = await loadFact(ctx.fs, dir, slug);
+        if (body) loaded.push({ slug, body });
+      }
+      const idf = idfWeights(loaded.map((l) => l.body));
+      const qTokens = tokenize(q);
+      const hits = [];
+      for (const { slug, body } of loaded) {
+        const lines = body.split("\n");
+        const matchLine = lines.find(matcher);
+        if (!matchLine && !relevanceScore(body, qTokens, idf)) continue;
+        const snippet = matchLine?.trim().slice(0, 120) || lines.find((l) => l.trim())?.trim().slice(0, 120) || "";
+        hits.push({ slug, snippet, score: relevanceScore(body, qTokens, idf) });
+      }
+      if (!hits.length) return "(no matches)";
+      hits.sort((a, b) => b.score - a.score);
+      return hits.slice(0, 10).map((h) => `${h.slug}: ${h.snippet}`).join("\n");
+    }
+  };
+}
+function rememberTool(fs, dir) {
+  return {
+    name: "Remember",
+    description: "Persist a durable fact for future sessions (a fix you found, a gotcha, a project constraint). Adds a pointer to the Memory index and stores the body. Use sparingly \u2014 only genuinely reusable knowledge, not task-specific scratch.",
+    parameters: {
+      type: "object",
+      required: ["fact"],
+      properties: {
+        fact: { type: "string", description: "the durable fact to remember (one or more lines)" },
+        slug: { type: "string", description: "optional kebab-case id; derived from the fact if omitted" }
+      }
+    },
+    async run({ fact, slug }, ctx) {
+      const body = String(fact ?? "").trim();
+      if (!body) return `Error: nothing to remember (empty fact).`;
+      const name = slugify(slug || body.split("\n")[0]);
+      await writeFact(ctx.fs, dir, name, body);
+      return `Remembered '${name}' (recallable in future sessions).`;
+    }
+  };
+}
+
+// src/instructions.ts
+var DEFAULT_NAMES = ["AGENT.md", "AGENTS.md", "CLAUDE.md"];
+async function loadInstructions(fs, names = DEFAULT_NAMES) {
+  const cwd = fs.getCwd();
+  const base = cwd === "/" ? "" : cwd;
+  for (const name of names) {
+    const sections = [];
+    for (const path of [`${base}/${name}`, `${base}/.claude/${name}`]) {
+      if (!await fs.exists(path)) continue;
+      const md = (await fs.readFile(path)).trim();
+      if (md) sections.push(`<!-- ${path} -->
+${md}`);
+    }
+    if (sections.length) {
+      return `## Project instructions
+Repository-specific instructions \u2014 follow them.
+
+${sections.join("\n\n---\n\n")}`;
+    }
+  }
+  return "";
+}
+
+// src/subagent.ts
+init_tools();
+init_OverlayFilesystem();
+async function boundedPool(items, limit, fn) {
+  const out = new Array(items.length);
+  let next = 0;
+  const worker = async () => {
+    while (next < items.length) {
+      const i = next++;
+      out[i] = await fn(items[i], i);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.max(1, Math.min(limit, items.length)) }, worker));
+  return out;
+}
+function childOptionsFor(opts, fs, depth, maxDepth, agentType) {
+  let def;
+  if (agentType) {
+    def = (opts.agents ?? []).find((a) => a.name === agentType);
+    if (!def) return `no subagent type '${agentType}'. Available: ${(opts.agents ?? []).map((a) => a.name).join(", ") || "(none defined)"}`;
+  }
+  const childOpts = { ai: opts.ai, fs, model: def?.model ?? opts.model, subagents: true, depth: depth + 1, maxDepth };
+  if (opts.maxSteps != null) childOpts.maxSteps = opts.maxSteps;
+  if (def?.systemPrompt) childOpts.systemPrompt = def.systemPrompt;
+  if (def?.tools?.length) {
+    try {
+      childOpts.tools = toolsByName(def.tools);
+    } catch (e) {
+      return `subagent '${agentType}' declares an unknown tool \u2014 ${e.message}`;
+    }
+  }
+  return childOpts;
+}
+function makeTaskTool(opts) {
+  const depth = opts.depth ?? 0;
+  const maxDepth = opts.maxDepth ?? 2;
+  return {
+    name: "Task",
+    description: "Delegate a self-contained sub-task to a child agent over the same filesystem. It runs autonomously with its own step budget and returns a concise summary \u2014 use to isolate context-heavy work (broad search, a scoped refactor). Provide a short `description` and a full `prompt`. Set `background: true` to run it detached (returns a job id to poll with JobOutput while you keep working); its file edits are overlay-isolated and commit when it finishes.",
+    parameters: {
+      type: "object",
+      required: ["description", "prompt"],
+      properties: {
+        description: { type: "string", description: "a short (3-5 word) label for the sub-task" },
+        prompt: { type: "string", description: "the full instructions the child agent should carry out" },
+        agentType: { type: "string", description: "optional named subagent type (its persona, model, and scoped tools) \u2014 see the catalog" },
+        background: { type: "boolean", description: "run detached (overlay-isolated, commits on finish); returns a job id to poll with JobOutput instead of blocking" }
+      }
+    },
+    async run({ description, prompt, agentType, background }, ctx) {
+      if (depth >= maxDepth) {
+        return `Error: Task depth limit reached (maxDepth ${maxDepth}). Cannot spawn another child agent \u2014 do this work directly instead.`;
+      }
+      const label = String(description ?? agentType ?? "sub-task");
+      if (background && ctx.jobs) {
+        const id = ctx.jobs.start(async ({ signal }) => {
+          const overlay = new OverlayFilesystem(opts.fs);
+          const childOpts2 = childOptionsFor(opts, overlay, depth, maxDepth, agentType);
+          if (typeof childOpts2 === "string") throw new Error(childOpts2);
+          childOpts2.signal = signal;
+          const res2 = await new Agent(childOpts2).run(String(prompt ?? ""));
+          if (signal.aborted) return "[killed before commit]";
+          await overlay.commit();
+          const summary2 = res2.text || `(child '${label}' finished with no summary; finishReason=${res2.finishReason})`;
+          await opts.hooks?.onSubagentStop?.(summary2, { label, agentType });
+          return summary2;
+        }, { kind: "agent", label });
+        return `Started background sub-task ${id} ('${label}') \u2014 poll with JobOutput({id:"${id}"}).`;
+      }
+      const childOpts = childOptionsFor(opts, opts.fs, depth, maxDepth, agentType);
+      if (typeof childOpts === "string") return `Error: ${childOpts}`;
+      const child = new Agent(childOpts);
+      const res = await child.run(String(prompt ?? ""));
+      const summary = res.text || `(child agent finished '${label}' with no summary; finishReason=${res.finishReason})`;
+      await opts.hooks?.onSubagentStop?.(summary, { label, agentType });
+      return summary;
+    }
+  };
+}
+function makeTaskBatchTool(opts) {
+  const depth = opts.depth ?? 0;
+  const maxDepth = opts.maxDepth ?? 2;
+  const maxParallel = opts.maxParallel ?? 4;
+  return {
+    name: "TaskBatch",
+    description: "Delegate SEVERAL independent sub-tasks to child agents that run concurrently; returns all their summaries. Each child is write-isolated (its file edits are merged back in array order). Use for parallel fan-out (review/search/scoped refactors across files). Provide `tasks: [{ description, prompt, agentType? }]`.",
+    parameters: {
+      type: "object",
+      required: ["tasks"],
+      properties: {
+        tasks: {
+          type: "array",
+          description: "the sub-tasks to run in parallel",
+          items: {
+            type: "object",
+            required: ["description", "prompt"],
+            properties: {
+              description: { type: "string", description: "a short (3-5 word) label" },
+              prompt: { type: "string", description: "the full instructions for this child" },
+              agentType: { type: "string", description: "optional named subagent type" }
+            }
+          }
+        }
+      }
+    },
+    async run({ tasks }, _ctx) {
+      if (depth >= maxDepth) return `Error: Task depth limit reached (maxDepth ${maxDepth}). Cannot spawn child agents \u2014 do this work directly instead.`;
+      const list = Array.isArray(tasks) ? tasks : [];
+      if (!list.length) return "Error: TaskBatch needs a non-empty `tasks` array.";
+      const results = await boundedPool(list, maxParallel, async (t, i) => {
+        const label = String(t?.description ?? t?.agentType ?? `task ${i + 1}`);
+        const overlay = new OverlayFilesystem(opts.fs);
+        const childOpts = childOptionsFor(opts, overlay, depth, maxDepth, t?.agentType);
+        if (typeof childOpts === "string") return { label, error: childOpts, ok: false };
+        try {
+          const res = await new Agent(childOpts).run(String(t?.prompt ?? ""));
+          await opts.hooks?.onSubagentStop?.(res.text, { label, agentType: t?.agentType });
+          return { label, text: res.text, overlay, ok: res.finishReason !== "error" };
+        } catch (e) {
+          return { label, error: e instanceof Error ? e.message : String(e), ok: false };
+        }
+      });
+      for (const r of results) if (r.ok && r.overlay) await r.overlay.commit().catch(() => {
+      });
+      return results.map((r, i) => `### ${i + 1}. ${r.label}
+${r.error ? `ERROR: ${r.error}` : r.text || "(no summary)"}`).join("\n\n");
+    }
+  };
+}
+
+// src/agents.ts
+function parseAgentFrontmatter(md) {
+  const m = md.match(/^---\s*\n([\s\S]*?)\n---\s*\n?/);
+  const block = m ? m[1] : "";
+  const get = (k) => {
+    const r = new RegExp(`^${k}\\s*:\\s*(.+)$`, "im").exec(block);
+    return r ? r[1].trim().replace(/^["']|["']$/g, "") : void 0;
+  };
+  const toolsRaw = get("tools");
+  const tools = toolsRaw ? toolsRaw.replace(/^\[|\]$/g, "").split(",").map((s) => s.trim().replace(/^["']|["']$/g, "")).filter(Boolean) : void 0;
+  return { description: get("description"), model: get("model"), tools, body: (m ? md.slice(m[0].length) : md).trim() };
+}
+async function loadAgents(fs, dir) {
+  const agents = [];
+  if (await fs.exists(dir)) {
+    for (const entry of await fs.readDir(dir)) {
+      if (!entry.endsWith(".md")) continue;
+      const fm = parseAgentFrontmatter(await fs.readFile(`${dir}/${entry}`));
+      agents.push({
+        name: entry.replace(/\.md$/, ""),
+        description: fm.description || "",
+        systemPrompt: fm.body || void 0,
+        model: fm.model,
+        tools: fm.tools
+      });
+    }
+  }
+  if (!agents.length) return { agents, catalog: "" };
+  const catalog = "## Subagent types (pass as the `Task` tool `agentType`)\n" + agents.map((a) => `- **${a.name}** \u2014 ${a.description}`).join("\n");
+  return { agents, catalog };
+}
+
+// src/Agent.ts
+init_OverlayFilesystem();
+
+// src/permissions.ts
+init_tools_structured();
+function commandMatches(glob, cmd) {
+  const pattern = glob.split("*").map((s) => s.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join(".*");
+  return new RegExp("^" + pattern + "$").test(cmd);
+}
+var PermissionOptions = class {
+  rules = [];
+  /** decision when no rule matches. */
+  default = "allow";
+  /** host channel for `ask` (confirm). If absent, `ask` is treated as `deny` (fail-closed). */
+  host;
+};
+var PermissionPolicy = class {
+  options;
+  constructor(options) {
+    this.options = { ...new PermissionOptions(), ...options };
+  }
+  /** Resolve the decision for a tool call (first matching rule, else default). */
+  decide(call) {
+    for (const r of this.options.rules) {
+      if (r.tool && r.tool !== call.name) continue;
+      if (r.pathGlob) {
+        const path = typeof call.args?.path === "string" ? call.args.path : null;
+        const cmd = typeof call.args?.command === "string" ? call.args.command : null;
+        if (path != null) {
+          if (!globToRegExp(r.pathGlob).test(path.startsWith("/") ? path : `/${path}`)) continue;
+        } else if (cmd != null) {
+          if (!commandMatches(r.pathGlob, cmd)) continue;
+        } else continue;
+      }
+      return r.decision;
+    }
+    return this.options.default;
+  }
+  /** A preToolUse hook enforcing this policy (deny/ask → block; allow → proceed). */
+  hooks() {
+    return {
+      preToolUse: async (call) => {
+        const d = this.decide(call);
+        if (d === "allow") return;
+        if (d === "deny") return { block: true, reason: `denied by permission policy (${call.name})` };
+        if (this.options.ask) {
+          const r = await this.options.ask(call);
+          const decision = r?.decision ?? "deny";
+          if (r?.remember) this.options.rules.unshift({ tool: call.name, decision });
+          return decision === "allow" ? void 0 : { block: true, reason: `not approved (${call.name})` };
+        }
+        const ok = await this.options.host?.confirm?.(`Allow ${call.name}${call.args?.path ? " on " + call.args.path : ""}?`);
+        return ok ? void 0 : { block: true, reason: `not approved (${call.name})` };
+      }
+    };
+  }
+};
+var DEFAULT_MUTATING = ["Write", "Edit", "MultiEdit", "deleteFile", "bash"];
+function planMode(opts) {
+  const mutating = new Set(opts?.mutating ?? DEFAULT_MUTATING);
+  let approved = false;
+  const tool = {
+    name: "ExitPlanMode",
+    description: "Call when your plan is ready and you want to start making changes. Provide the `plan`. Until this is approved, edits/writes are blocked.",
+    parameters: { type: "object", required: ["plan"], properties: { plan: { type: "string", description: "the concrete steps you will take" } } },
+    async run({ plan }, _ctx) {
+      if (opts?.host?.confirm) {
+        const ok = await opts.host.confirm(`Approve this plan?
+
+${String(plan ?? "")}`);
+        if (!ok) return "Plan not approved. Revise it and call ExitPlanMode again.";
+      }
+      approved = true;
+      return "Plan approved \u2014 you may now make changes.";
+    }
+  };
+  const hooks = {
+    preToolUse: (call) => !approved && mutating.has(call.name) ? { block: true, reason: "plan mode: present a plan and call ExitPlanMode (approved) before editing." } : void 0
+  };
+  return { hooks, tool };
+}
+function composeHooks(...list) {
+  const hooks = list.filter(Boolean);
+  return {
+    async preToolUse(call, meta) {
+      for (const h of hooks) {
+        const d = await h.preToolUse?.(call, meta);
+        if (d?.block) return d;
+      }
+    },
+    async postToolUse(call, result, meta) {
+      for (const h of hooks) await h.postToolUse?.(call, result, meta);
+    },
+    onStop(text) {
+      for (const h of hooks) h.onStop?.(text);
+    },
+    // lifecycle: concatenate session-start context; chain prompt-submit transforms; fan out pre-compact.
+    async onSessionStart() {
+      let ctx = "";
+      for (const h of hooks) {
+        const r = await h.onSessionStart?.();
+        if (r) ctx += (ctx ? "\n\n" : "") + r;
+      }
+      return ctx || void 0;
+    },
+    async onUserPromptSubmit(text) {
+      let t = text;
+      for (const h of hooks) {
+        const r = await h.onUserPromptSubmit?.(t);
+        if (typeof r === "string") t = r;
+      }
+      return t;
+    },
+    async onPreCompact(messages) {
+      for (const h of hooks) await h.onPreCompact?.(messages);
+    },
+    async onSubagentStop(summary, info) {
+      for (const h of hooks) await h.onSubagentStop?.(summary, info);
+    }
+  };
+}
+
+// src/Agent.ts
+init_logging();
+
+// src/lint.ts
+var CODE_RE = /\.(ts|tsx|js|jsx|mjs|cjs)$/;
+function checkSyntax(path, content) {
+  if (!CODE_RE.test(path)) return null;
+  try {
+    const open = { ")": "(", "]": "[", "}": "{" };
+    const names = { "(": "'('", "[": "'['", "{": "'{'" };
+    const stack = [];
+    const n = content.length;
+    for (let i = 0; i < n; i++) {
+      const c = content[i];
+      if (c === "/" && content[i + 1] === "/") {
+        while (i < n && content[i] !== "\n") i++;
+        continue;
+      }
+      if (c === "/" && content[i + 1] === "*") {
+        i += 2;
+        while (i < n && !(content[i] === "*" && content[i + 1] === "/")) i++;
+        i++;
+        continue;
+      }
+      if (c === '"' || c === "'" || c === "`") {
+        const quote = c;
+        i++;
+        while (i < n) {
+          if (content[i] === "\\") {
+            i += 2;
+            continue;
+          }
+          if (content[i] === quote) break;
+          i++;
+        }
+        continue;
+      }
+      if (c === "(" || c === "[" || c === "{") stack.push(c);
+      else if (c === ")" || c === "]" || c === "}") {
+        const want = open[c];
+        if (stack.length === 0) return `Syntax check failed for ${path}: unexpected closing '${c}'. Fix before writing.`;
+        const top = stack.pop();
+        if (top !== want) return `Syntax check failed for ${path}: mismatched '${c}' (expected to close ${names[top]}). Fix before writing.`;
+      }
+    }
+    if (stack.length > 0) {
+      const ch = stack[stack.length - 1];
+      return `Syntax check failed for ${path}: unbalanced ${names[ch]} (${stack.length} unclosed). Fix before writing.`;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// src/Agent.ts
+var log3 = forComponent("Agent");
+var AgentOptions = class {
+  /** Any ai.libx.js AIClient (or a FakeAIClient). */
+  ai;
+  /** Filesystem backend — MemFilesystem, NodeDiskFilesystem, IndexedDbFilesystem, …
+   *  OPTIONAL: if omitted, the agent lazily defaults to a JAILED real disk rooted at `process.cwd()`
+   *  (secrets hidden by DEFAULT_DENY) — resolved via a dynamic node import at first run, so the edge/
+   *  browser build (which always passes its own fs) never pulls in `node:fs`. Pass `fs` explicitly to
+   *  use any other backend (and to keep full control of the jail). */
+  fs;
+  model = "anthropic/claude-sonnet-4-6";
+  systemPrompt = 'You are a coding agent operating on a virtual filesystem. Use the `bash` tool to explore (ls, grep, find, cat) and the `Read`/`Edit` tools to view and modify files. Always Read a file before Editing it. When multiple tool calls are independent (e.g. several Reads or Greps with no dependency between them), issue them together in a single turn rather than one at a time. When the task is complete, reply with a short summary and make no further tool calls.\nWhen working with a knowledge base or document workspace: use `RepoMap` with scope "docs" to see all document headings and summaries (orient first); use `MemorySearch` to find memories by content when you don\'t know the exact slug; use `Recall` with multiple slugs to batch-load related facts in one call. Prefer targeted loads over reading everything \u2014 orient \u2192 search \u2192 load \u2192 act.';
+  tools = defaultTools();
+  maxSteps = 25;
+  // --- automatic kill-switches (always on; protect the API budget against runaway loops/abuse) ---
+  /** Hard ceiling on accumulated tokens (prompt+completion) across the run. 0 = unbounded. */
+  maxTokens = 2e5;
+  /** Wall-clock ceiling in ms for the whole run. 0 = unbounded. */
+  timeoutMs = 12e4;
+  /** Stop if the identical tool-call batch (name+args) repeats this many times in a row. 0 = off. */
+  maxRepeats = 3;
+  /** Cumulative cap on tool calls dispatched across the run. 0 = unbounded. */
+  maxToolCalls = 100;
+  /** External cancellation — abort the loop between steps (e.g. a UI "Cancel" button). */
+  signal;
+  /** 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;
+  /** 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;
+  /** VFS dir(s) of skills (`<dir>/<id>/SKILL.md`). If set: inject a catalog + add the `Skill` tool. Multiple dirs are merged (first wins on name collisions). */
+  skillsDir;
+  /** VFS dir(s) of slash-command templates (`<dir>/<name>.md`). If set: inject a catalog + add the `SlashCommand` tool. Multiple dirs are merged (first wins). */
+  commandsDir;
+  /** VFS dir of memory (`<dir>/MEMORY.md`). If set: inject the index at run start (persistence = backend). */
+  memoryDir;
+  /** Filenames to discover as project instructions (e.g. `AGENT.md`, `AGENTS.md`, `CLAUDE.md`).
+   *  Walks the VFS tree and merges all found files (general → specific, like Claude Code).
+   *  `true` (default) = auto-discover standard names. `string[]` = custom names. `false` = skip. */
+  instructionFiles = true;
+  /** Host interaction channel (human-in-the-loop). If set: adds the `AskUserQuestion` tool. */
+  host;
+  /** Deterministic interception points around tool execution (pre/post/stop). */
+  hooks;
+  /** If true: add the `Task` tool so the agent can spawn depth-limited child agents over the VFS. */
+  subagents = false;
+  /** VFS dir of typed-subagent defs (`<dir>/<name>.md`). If set with `subagents`: inject a catalog + enable the `Task` `agentType` param. */
+  agentsDir;
+  /** Current recursion depth (0 = top-level); spawned children run at depth+1. */
+  depth = 0;
+  /** Hard ceiling on subagent nesting (beyond it the `Task` tool refuses to spawn). */
+  maxDepth = 2;
+  /** Stream tokens from the model. Takes effect only with a `host.notify`; off => current (non-stream) behavior. */
+  stream = false;
+  /** Fold the dropped middle of an over-long transcript into a synthetic summary (edge-safe, no LLM). Off => drop-oldest. */
+  compaction;
+  /** Add `Checkpoint`/`Rollback` tools (requires the fs to be an OverlayFilesystem). */
+  checkpoints = false;
+  /** Enable `bash({background:true})` + JobOutput/JobStatus/JobKill — sandbox background jobs (overlay-isolated,
+   *  committed on completion, drained at turn end). Useful when the VFS backend is slow (remote) or for sub-agents. */
+  backgroundJobs = false;
+  /** Plan mode: block mutating tools until the agent calls `ExitPlanMode` (host-approved). */
+  planMode = false;
+  /** Permission policy gating each tool call (allow / ask / deny). */
+  permissions;
+  /** Opt-in syntax guardrail: refuse to persist a syntactically-broken code-file write/edit. Default off. */
+  lintOnWrite;
+  /** Opt-in: after a write-class tool runs, run `command` over the VFS and append any failure to the tool result.
+   *  `tools` defaults to ['Write','Edit','MultiEdit','ApplyEdits']. */
+  autoTest;
+};
+var Agent = class _Agent {
+  options;
+  transcript = [];
+  ctx;
+  // built in the ctor when `fs` is provided, else lazily in ensureFs()
+  activeTools = [];
+  activeHooks;
+  // composed: user hooks + plan-mode + permissions
+  prepared = false;
+  // memo guard: prompt/tools/plan-state built once per conversation
+  systemPromptCache = "";
+  // the assembled system prompt from the last prepare()
+  started = false;
+  // session-start lifecycle hook fires once per conversation
+  /** Inject tools into a running agent (e.g. dynamically mounted MCP servers). Takes effect on the next turn. */
+  addTools(tools) {
+    this.activeTools.push(...tools);
+  }
+  /** Remove tools by name from a running agent. Returns the count removed. */
+  removeTools(names) {
+    const s = names instanceof Set ? names : new Set(names);
+    const before = this.activeTools.length;
+    this.activeTools = this.activeTools.filter((t) => !s.has(t.name));
+    return before - this.activeTools.length;
+  }
+  constructor(options) {
+    this.options = { ...new AgentOptions(), ...options };
+    if (this.options.fs) this.buildCtx();
+  }
+  /** Build the tool context from the resolved fs + options. Idempotent-safe: called once (ctor or ensureFs). */
+  buildCtx() {
+    this.ctx = makeContext(this.options.fs, this.options.host);
+    this.ctx.signal = this.options.signal;
+    if (this.options.lintOnWrite) this.ctx.lint = checkSyntax;
+    this.ctx.ai = this.options.ai;
+    this.ctx.model = this.options.model;
+    if (this.options.backgroundJobs) this.ctx.jobs = new SandboxJobRegistry();
+  }
+  /**
+   * Resolve the filesystem + build the tool context if the ctor couldn't (no `fs` was passed). The disk
+   * default lives HERE, not in the ctor: the ctor can't await, and we must avoid a STATIC `node:fs` import
+   * in the core (edge/browser would break). The dynamic import only fires when `fs` is omitted — edge code
+   * always passes its own `MemFilesystem`, so the node module is never reached. Default = jailed disk @ cwd.
+   */
+  async ensureFs() {
+    if (this.ctx) return;
+    if (!this.options.fs) {
+      const { NodeDiskFilesystem: NodeDiskFilesystem2 } = await Promise.resolve().then(() => (init_NodeDiskFilesystem(), NodeDiskFilesystem_exports));
+      const { JailedFilesystem: JailedFilesystem2 } = await Promise.resolve().then(() => (init_JailedFilesystem(), JailedFilesystem_exports));
+      const disk = new NodeDiskFilesystem2(process.cwd());
+      await disk.init();
+      this.options.fs = new JailedFilesystem2(disk);
+      log3.info(`no fs provided \u2014 defaulting to jailed real disk at ${process.cwd()}`);
+    }
+    this.buildCtx();
+  }
+  /**
+   * Assemble the system prompt + active tools/hooks ONCE per conversation (memoized).
+   * `run()` resets the memo to start fresh; `send()` reuses it, so multi-turn state —
+   * plan-mode approval, the tool set, the skills/commands/memory snapshot — stays stable
+   * across turns (and the frozen prompt pairs well with prompt caching). Does NOT touch
+   * the transcript; `run`/`send` own that.
+   */
+  async prepare(taskHint) {
+    if (this.prepared) return this.systemPromptCache;
+    const o = this.options;
+    const fs = o.fs;
+    let systemPrompt = o.systemPrompt;
+    let tools = o.tools;
+    if (o.instructionFiles !== false) {
+      const names = Array.isArray(o.instructionFiles) ? o.instructionFiles : void 0;
+      const ins = await loadInstructions(fs, names);
+      if (ins) systemPrompt += "\n\n" + ins;
+    }
+    if (o.memoryDir) {
+      const { index, tools: memTools } = await loadMemory(fs, o.memoryDir, { relevanceHint: taskHint });
+      if (index) systemPrompt += "\n\n" + index;
+      tools = [...tools, ...memTools];
+    }
+    if (o.skillsDir) {
+      const { catalog, tool } = await loadSkills(fs, o.skillsDir, { relevanceHint: taskHint });
+      if (catalog) systemPrompt += "\n\n" + catalog;
+      if (tool) tools = [...tools, tool];
+    }
+    if (o.commandsDir) {
+      const { catalog, tool } = await loadCommands(fs, o.commandsDir, { relevanceHint: taskHint });
+      if (catalog) systemPrompt += "\n\n" + catalog;
+      if (tool) tools = [...tools, tool];
+    }
+    if (o.host) tools = [...tools, askUserQuestionTool];
+    if (o.subagents) {
+      let agents;
+      if (o.agentsDir) {
+        const loaded = await loadAgents(fs, o.agentsDir);
+        agents = loaded.agents;
+        if (loaded.catalog) systemPrompt += "\n\n" + loaded.catalog;
+      }
+      const taskOpts = { ai: o.ai, model: o.model, fs, depth: o.depth, maxDepth: o.maxDepth, agents, hooks: o.hooks };
+      tools = [...tools, makeTaskTool(taskOpts), makeTaskBatchTool(taskOpts)];
+    }
+    if (o.checkpoints) tools = [...tools, ...checkpointTools()];
+    if (this.ctx.jobs) tools = [...tools, ...makeJobTools(this.ctx.jobs)];
+    const plan = o.planMode ? planMode({ host: o.host }) : void 0;
+    if (plan) tools = [...tools, plan.tool];
+    this.activeHooks = composeHooks(o.hooks, plan?.hooks, o.permissions?.hooks());
+    this.activeTools = tools;
+    this.systemPromptCache = systemPrompt;
+    this.prepared = true;
+    return systemPrompt;
+  }
+  /** Single-shot: reset all per-conversation state and run `task` to completion. `task` may be plain
+   *  text or multimodal content parts (text + images). */
+  async run(task) {
+    await this.ensureFs();
+    this.prepared = false;
+    this.started = false;
+    const systemPrompt = await this.prepare(contentText(task));
+    const startCtx = await this.fireSessionStart();
+    const userContent = await this.applyPromptSubmit(task);
+    this.transcript = [
+      { role: "system", content: systemPrompt + (startCtx ? "\n\n" + startCtx : "") },
+      { role: "user", content: userContent }
+    ];
+    return this.runLoop();
+  }
+  /** Apply onUserPromptSubmit to a turn: rewrite plain text; pass multimodal content through untouched. */
+  async applyPromptSubmit(task) {
+    return typeof task === "string" ? await this.fireUserPromptSubmit(task) : task;
+  }
+  /** Fire onSessionStart once per conversation; returns any injected context. */
+  async fireSessionStart() {
+    if (this.started) return void 0;
+    this.started = true;
+    const ctx = await this.activeHooks?.onSessionStart?.();
+    return typeof ctx === "string" && ctx ? ctx : void 0;
+  }
+  /** Fire onUserPromptSubmit; returns the (possibly rewritten) prompt text. */
+  async fireUserPromptSubmit(task) {
+    const r = await this.activeHooks?.onUserPromptSubmit?.(task);
+    return typeof r === "string" ? r : task;
+  }
+  /**
+   * Multi-turn: continue the existing conversation by appending a user turn instead of
+   * resetting — this is what makes an interactive REPL feel like one conversation. The
+   * leading system message is (re)synced to the current prompt, so a resumed session whose
+   * tools were rebuilt gets a matching catalog rather than a stale one.
+   */
+  async send(task) {
+    await this.ensureFs();
+    const systemPrompt = await this.prepare(contentText(task));
+    const startCtx = await this.fireSessionStart();
+    const userContent = await this.applyPromptSubmit(task);
+    const sys = systemPrompt + (startCtx ? "\n\n" + startCtx : "");
+    if (this.transcript[0]?.role === "system") this.transcript[0] = { role: "system", content: sys };
+    else this.transcript.unshift({ role: "system", content: sys });
+    this.transcript.push({ role: "user", content: userContent });
+    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.
+   */
+  compactNow(maxMessages = 12) {
+    const max = Math.max(2, maxMessages);
+    if (this.transcript.length <= max) return 0;
+    void this.activeHooks?.onPreCompact?.(this.transcript);
+    const before = this.transcript.length;
+    this.transcript = compact(this.transcript, max);
+    return before - this.transcript.length;
+  }
+  async runLoop() {
+    const o = this.options;
+    const wireTools = toWireTools(this.activeTools);
+    const useStream = o.stream === true && typeof o.host?.notify === "function";
+    let steps = 0;
+    const usage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+    let usageEstimated = false;
+    const start = Date.now();
+    let toolCallsTotal = 0;
+    let lastFp = "";
+    let repeats = 0;
+    const kill = (finishReason) => {
+      log3.warn(`kill-switch: ${finishReason} (steps=${steps}, tokens=${usage.totalTokens}, ms=${Date.now() - start})`);
+      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 >= o.timeoutMs) return kill("timeout");
+      if (o.maxTokens && usage.totalTokens >= o.maxTokens) return kill("budget");
+      steps++;
+      let res;
+      const sent = this.trimContext();
+      try {
+        if (useStream) {
+          const r = await o.ai.chat({ model: o.model, messages: sent, tools: wireTools, stream: true, signal: o.signal });
+          res = await this.consumeStream(r);
+        } else {
+          const r = await o.ai.chat({ model: o.model, messages: sent, tools: wireTools, stream: false, signal: o.signal });
+          res = r;
+        }
+      } catch (err) {
+        if (err?.code === "budget") return kill("budget");
+        if (o.signal?.aborted) return kill("aborted");
+        log3.error("chat() failed", err);
+        return { text: "", steps, finishReason: "error", messages: this.transcript, usage, usageEstimated, error: err };
+      }
+      if (o.signal?.aborted) return kill("aborted");
+      if (!res.usage) {
+        const promptTokens = estimateTokens(sent);
+        const completionTokens = Math.ceil((contentText(res.content).length + (res.toolCalls ? JSON.stringify(res.toolCalls).length : 0)) / 4);
+        res.usage = { promptTokens, completionTokens, totalTokens: promptTokens + completionTokens };
+        usageEstimated = true;
+      }
+      if (res.usage) {
+        usage.promptTokens += res.usage.promptTokens ?? 0;
+        usage.completionTokens += res.usage.completionTokens ?? 0;
+        usage.totalTokens += res.usage.totalTokens ?? 0;
+      }
+      const toolCalls = res.toolCalls ?? [];
+      this.transcript.push({
+        role: "assistant",
+        content: res.content ?? "",
+        ...toolCalls.length ? { tool_calls: toolCalls } : {}
+      });
+      if (toolCalls.length === 0) {
+        log3.verbose(`completed in ${steps} step(s)`);
+        await this.ctx.jobs?.drain();
+        await this.activeHooks?.onStop?.(res.content ?? "");
+        return { text: res.content ?? "", steps, finishReason: "stop", messages: this.transcript, usage, usageEstimated };
+      }
+      const fp = toolCalls.map((tc) => tc.function.name + ":" + (tc.function.arguments ?? "")).join("|");
+      repeats = fp === lastFp ? repeats + 1 : 1;
+      lastFp = fp;
+      if (o.maxRepeats && repeats >= o.maxRepeats) return kill("loop");
+      toolCallsTotal += toolCalls.length;
+      if (o.maxToolCalls && toolCallsTotal > o.maxToolCalls) return kill("max_tool_calls");
+      for (const tc of toolCalls) {
+        const content = await this.dispatch(tc);
+        this.transcript.push({ role: "tool", tool_call_id: tc.id, name: tc.function.name, content });
+      }
+    }
+  }
+  /**
+   * Drain a streamed chat() response: emit each text delta to the host
+   * (`{kind:'text_delta'}`) and fold all chunks back into the single
+   * ChatResponse the non-stream path would have returned.
+   */
+  async consumeStream(stream) {
+    let content = "";
+    let finishReason;
+    let toolCalls;
+    let usage;
+    for await (const chunk of stream) {
+      if (this.options.signal?.aborted) break;
+      if (chunk.reasoningContent) this.options.host.notify({ kind: "thinking_delta", message: chunk.reasoningContent });
+      if (chunk.content) {
+        content += chunk.content;
+        this.options.host.notify({ kind: "text_delta", message: chunk.content });
+      }
+      if (chunk.finishReason) finishReason = chunk.finishReason;
+      if (chunk.toolCalls?.length) toolCalls = chunk.toolCalls;
+      if (chunk.usage) usage = chunk.usage;
+    }
+    return { content, ...finishReason ? { finishReason } : {}, ...toolCalls ? { toolCalls } : {}, ...usage ? { usage } : {} };
+  }
+  async dispatch(tc) {
+    const tool = this.activeTools.find((t) => t.name === tc.function.name);
+    if (!tool) return `Error: unknown tool '${tc.function.name}'`;
+    let args = {};
+    try {
+      args = tc.function.arguments ? JSON.parse(tc.function.arguments) : {};
+    } catch (e) {
+      return `Error: invalid JSON arguments for ${tc.function.name}: ${String(e)}`;
+    }
+    const hooks = this.activeHooks;
+    const call = { name: tc.function.name, args };
+    const meta = { id: tc.id };
+    const decision = await hooks?.preToolUse?.(call, meta);
+    if (decision?.block) {
+      const blocked = `Blocked by hook: ${decision.reason ?? "no reason given"}`;
+      log3.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 });
+    let result;
+    let threw = false;
+    try {
+      log3.debug(`${tc.function.name}(${tc.function.arguments})`);
+      result = await tool.run(args, this.ctx);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      log3.debug(`${tc.function.name} -> error: ${msg}`);
+      result = `Error: ${msg}`;
+      threw = true;
+    }
+    if (!threw) result = await this.maybeAutoTest(tc.function.name, result);
+    await hooks?.postToolUse?.(call, result, meta);
+    this.options.host?.notify?.({ kind: "tool_result", id: tc.id ?? "", output: result, isError: threw });
+    return result;
+  }
+  static WRITE_CLASS = ["Write", "Edit", "MultiEdit", "ApplyEdits"];
+  /** Append an autoTest failure section to a write-class tool result, if configured. */
+  async maybeAutoTest(toolName, result) {
+    const at = this.options.autoTest;
+    if (!at?.command) return result;
+    const set = at.tools ?? _Agent.WRITE_CLASS;
+    if (!set.includes(toolName)) return result;
+    const r = await this.ctx.exec.execute(at.command);
+    if (r.exitCode === 0) return result;
+    const out = truncateOutput(((r.output ?? "") + (r.error ?? "")).replace(/\n+$/, ""));
+    return `${result}
+
+[autoTest] \`${at.command}\` FAILED (exit ${r.exitCode}):
+${out}`;
+  }
+  /**
+   * Shape the per-turn context (a VIEW — the stored transcript is never mutated). Layered, each off by default:
+   *  1. coarse reduction — `compaction` (fold the dropped middle into a synthetic summary) OR
+   *     `maxContextMessages` (pure drop-oldest), keeping the system message + most-recent window.
+   *  2. note-taking (`keepToolOutputs`) — collapse all-but-the-recent-N tool-result bodies to one-line stubs
+   *     (kills "immortal tool results": a big Read/Grep stops costing its full weight once it's old).
+   *  3. token-aware backstop (`maxContextTokens`) — drop oldest messages until under an estimated token ceiling.
+   * With every knob off, returns the transcript unchanged (same reference).
+   */
+  trimContext() {
+    const o = this.options;
+    const m = this.transcript;
+    let out = null;
+    if (o.compaction?.maxMessages && m.length > o.compaction.maxMessages) out = compact(m, o.compaction.maxMessages);
+    else if (o.maxContextMessages && m.length > o.maxContextMessages) out = dropOldest(m, o.maxContextMessages);
+    if (o.keepToolOutputs) out = stubOldToolResults(out ?? m, o.keepToolOutputs);
+    if (o.maxContextTokens) out = fitTokenBudget(out ?? m, o.maxContextTokens);
+    return dropOrphanToolResults(out ?? m);
+  }
+};
+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);
+}
+function stubOldToolResults(messages, keep) {
+  const meta = /* @__PURE__ */ new Map();
+  for (const msg of messages)
+    for (const tc of msg.tool_calls ?? []) {
+      let path;
+      try {
+        const a = tc.function.arguments ? JSON.parse(tc.function.arguments) : {};
+        if (typeof a.path === "string") path = a.path;
+      } catch {
+      }
+      meta.set(tc.id, path);
+    }
+  const toolIdx = messages.map((x, i) => x.role === "tool" ? i : -1).filter((i) => i >= 0);
+  const stub = new Set(toolIdx.slice(0, Math.max(0, toolIdx.length - keep)));
+  if (stub.size === 0) return messages;
+  return messages.map((x, i) => {
+    const text = contentText(x.content);
+    if (!stub.has(i) || text.length <= 120) return x;
+    const where = meta.get(x.tool_call_id ?? "");
+    const lines = text.split("\n").length;
+    return { ...x, content: `[${x.name ?? "tool"}${where ? ` ${where}` : ""} output elided \u2014 ${lines} lines; re-run the tool to view]` };
+  });
+}
+var hasCallFor = (msgs, id) => msgs.some((m) => m.role === "assistant" && m.tool_calls?.some((tc) => tc.id === id));
+function dropOrphanToolResults(messages) {
+  const ok = (m) => m.role !== "tool" || hasCallFor(messages, m.tool_call_id);
+  return messages.every(ok) ? messages : messages.filter(ok);
+}
+function fitTokenBudget(messages, maxTokens) {
+  if (estimateTokens(messages) <= maxTokens) return messages;
+  const head = messages[0]?.role === "system" ? [messages[0]] : [];
+  let body = messages.slice(head.length);
+  while (body.length && estimateTokens([...head, ...body]) > maxTokens) body = body.slice(1);
+  while (body.length && body[0].role === "tool" && !hasCallFor(body, body[0].tool_call_id)) body = body.slice(1);
+  if (estimateTokens([...head, ...body]) > maxTokens)
+    log3.warn(`context ~${estimateTokens([...head, ...body])} tok still over maxContextTokens=${maxTokens} after trimming (system head can't be dropped)`);
+  return [...head, ...body];
+}
+function compact(m, max) {
+  const hasSystem = m[0]?.role === "system";
+  const head = hasSystem ? [m[0]] : [];
+  const tailCount = Math.max(1, max - head.length - 1);
+  const tail = m.slice(head.length).slice(-tailCount);
+  const dropped = m.slice(head.length, m.length - tail.length);
+  if (dropped.length === 0) return [...head, ...tail];
+  return [...head, { role: "system", content: summarize(dropped) }, ...tail];
+}
+function summarize(messages) {
+  const tools = /* @__PURE__ */ new Set();
+  const files = /* @__PURE__ */ new Set();
+  let lastAssistant = "";
+  for (const msg of messages) {
+    for (const tc of msg.tool_calls ?? []) {
+      tools.add(tc.function.name);
+      try {
+        const args = tc.function.arguments ? JSON.parse(tc.function.arguments) : {};
+        if (typeof args.path === "string") files.add(args.path);
+      } catch {
+      }
+    }
+    if (msg.role === "assistant" && msg.content) lastAssistant = contentText(msg.content);
+  }
+  const lines = [`[summary of ${messages.length} 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}`);
+  return lines.join("\n");
+}
+function lastAssistantText(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === "assistant") return contentText(messages[i].content);
+  }
+  return "";
+}
+
+// src/index.ts
+init_NodeDiskFilesystem();
+
+// src/BodDbFilesystem.ts
+import { PathResolver as PathResolver2 } from "@livx.cc/wcli/core";
+import { BodDB } from "@bod.ee/db";
+var MemBackend = class {
+  store = /* @__PURE__ */ new Map();
+  async read(id) {
+    const d = this.store.get(id);
+    if (!d) throw new Error(`fileId not found: ${id}`);
+    return d;
+  }
+  async write(id, data) {
+    this.store.set(id, data);
+  }
+  async delete(id) {
+    this.store.delete(id);
+  }
+  async exists(id) {
+    return this.store.has(id);
+  }
+};
+var BodDbFilesystem = class {
+  cwd = "/";
+  db;
+  vfs;
+  owns;
+  constructor(db) {
+    this.owns = !db;
+    this.db = db ?? new BodDB({ path: ":memory:", sweepInterval: 0, vfs: { storageRoot: ":memory:", backend: new MemBackend() } });
+    if (!this.db.vfs) throw new Error("BodDbFilesystem: the BodDB must have VFS enabled (construct it with { vfs: { \u2026 } }).");
+    this.vfs = this.db.vfs;
+  }
+  /** Release the underlying DB's timers/handles. Closes only a DB we created (a passed-in DB is the caller's). */
+  close() {
+    if (this.owns) this.db.close();
+  }
+  resolvePath(path, cwd) {
+    return PathResolver2.resolve(path, cwd || this.cwd);
+  }
+  getCwd() {
+    return this.cwd;
+  }
+  setCwd(path) {
+    this.cwd = PathResolver2.normalize(path);
+  }
+  /** Parent dir of an absolute VFS path ('/a/b.txt' -> '/a'; '/a' -> '/'). */
+  parentOf(p) {
+    const i = p.lastIndexOf("/");
+    return i <= 0 ? "/" : p.slice(0, i);
+  }
+  /** Throw (matching the other backends) unless the parent directory exists. Root is always a dir. */
+  assertParentDir(p, path) {
+    const parent = this.parentOf(p);
+    if (parent === "/") return;
+    const s = this.vfs.stat(parent);
+    if (!s || !s.isDir) throw new Error(`Parent directory does not exist: ${path}`);
+  }
+  async readFile(path) {
+    const p = this.resolvePath(path);
+    const s = this.vfs.stat(p);
+    if (!s) throw new Error(`File not found: ${path}`);
+    if (s.isDir) throw new Error(`Not a file: ${path}`);
+    return new TextDecoder().decode(await this.vfs.read(p));
+  }
+  async writeFile(path, content) {
+    const p = this.resolvePath(path);
+    this.assertParentDir(p, path);
+    if (this.vfs.stat(p)?.isDir) throw new Error(`Is a directory: ${path}`);
+    await this.vfs.write(p, new TextEncoder().encode(content), "text/plain");
+  }
+  async deleteFile(path) {
+    const p = this.resolvePath(path);
+    const s = this.vfs.stat(p);
+    if (!s) throw new Error(`File not found: ${path}`);
+    if (s.isDir && this.vfs.list(p).length > 0) throw new Error(`Directory not empty: ${path}`);
+    await this.vfs.remove(p);
+  }
+  async readDir(path) {
+    const p = this.resolvePath(path);
+    if (p !== "/") {
+      const s = this.vfs.stat(p);
+      if (!s) throw new Error(`Directory not found: ${path}`);
+      if (!s.isDir) throw new Error(`Not a directory: ${path}`);
+    }
+    return this.vfs.list(p).map((e) => e.name);
+  }
+  async createDir(path) {
+    const p = this.resolvePath(path);
+    if (p === "/" || this.vfs.stat(p)) throw new Error(`File or directory already exists: ${path}`);
+    this.assertParentDir(p, path);
+    this.vfs.mkdir(p);
+  }
+  async exists(path) {
+    const p = this.resolvePath(path);
+    return p === "/" || this.vfs.stat(p) !== null;
+  }
+  async stat(path) {
+    const p = this.resolvePath(path);
+    const s = this.vfs.stat(p);
+    if (!s) {
+      if (p === "/") return { created: /* @__PURE__ */ new Date(0), modified: /* @__PURE__ */ new Date(0), size: 0, permissions: "drwxr-xr-x", isExecutable: false };
+      throw new Error(`File not found: ${path}`);
+    }
+    const when = new Date(s.mtime);
+    return {
+      created: when,
+      modified: when,
+      size: s.size,
+      permissions: s.isDir ? "drwxr-xr-x" : "-rw-r--r--",
+      isExecutable: false
+    };
+  }
+  async isDirectory(path) {
+    const p = this.resolvePath(path);
+    return p === "/" || this.vfs.stat(p)?.isDir === true;
+  }
+  async isFile(path) {
+    const s = this.vfs.stat(this.resolvePath(path));
+    return !!s && !s.isDir;
+  }
+};
+
+// src/index.ts
+init_JailedFilesystem();
+init_OverlayFilesystem();
+
+// src/MountFilesystem.ts
+var DIR_META = { created: /* @__PURE__ */ new Date(0), modified: /* @__PURE__ */ new Date(0), size: 0, permissions: "drwxr-xr-x", isExecutable: false };
+var norm = (p) => "/" + p.split("/").filter(Boolean).join("/");
+var MountFilesystem = class {
+  constructor(root, mounts = []) {
+    this.root = root;
+    this.mounts = mounts.map((m) => ({ prefix: norm(m.prefix), fs: m.fs })).sort((a, b) => b.prefix.length - a.prefix.length);
+  }
+  root;
+  mounts;
+  resolvePath(path, cwd) {
+    return this.root.resolvePath(path, cwd ?? this.root.getCwd());
+  }
+  getCwd() {
+    return this.root.getCwd();
+  }
+  setCwd(path) {
+    this.root.setCwd(path);
+  }
+  abs(p) {
+    return this.resolvePath(p);
+  }
+  /** Route an absolute VFS path to a backend + its path within that backend. */
+  route(abs) {
+    for (const m of this.mounts) {
+      if (abs === m.prefix || abs.startsWith(m.prefix + "/")) return { fs: m.fs, sub: abs.slice(m.prefix.length) || "/" };
+    }
+    return { fs: this.root, sub: abs };
+  }
+  /** Is `abs` strictly ABOVE a mount point (a synthesized dir the root may not have)? */
+  isMountAncestor(abs) {
+    const base = abs === "/" ? "/" : abs + "/";
+    return this.mounts.some((m) => m.prefix.startsWith(base));
+  }
+  /** Immediate child segment names of `abs` that come from mounts (for readDir merge). */
+  mountChildrenOf(abs) {
+    const base = abs === "/" ? "/" : abs + "/";
+    const out = /* @__PURE__ */ new Set();
+    for (const m of this.mounts) if (m.prefix.startsWith(base)) out.add(m.prefix.slice(base.length).split("/")[0]);
+    return [...out];
+  }
+  async readFile(path) {
+    const { fs, sub } = this.route(this.abs(path));
+    return fs.readFile(sub);
+  }
+  async writeFile(path, content) {
+    const { fs, sub } = this.route(this.abs(path));
+    return fs.writeFile(sub, content);
+  }
+  async deleteFile(path) {
+    const { fs, sub } = this.route(this.abs(path));
+    return fs.deleteFile(sub);
+  }
+  async createDir(path) {
+    const { fs, sub } = this.route(this.abs(path));
+    return fs.createDir(sub);
+  }
+  async exists(path) {
+    const a = this.abs(path);
+    if (this.isMountAncestor(a)) return true;
+    const { fs, sub } = this.route(a);
+    return fs.exists(sub);
+  }
+  async isDirectory(path) {
+    const a = this.abs(path);
+    if (this.isMountAncestor(a)) return true;
+    const { fs, sub } = this.route(a);
+    return fs.isDirectory(sub);
+  }
+  async isFile(path) {
+    const a = this.abs(path);
+    if (this.isMountAncestor(a)) return false;
+    const { fs, sub } = this.route(a);
+    return fs.isFile(sub);
+  }
+  async stat(path) {
+    const a = this.abs(path);
+    if (this.isMountAncestor(a)) return DIR_META;
+    const { fs, sub } = this.route(a);
+    return fs.stat(sub);
+  }
+  async readDir(path) {
+    const a = this.abs(path);
+    const { fs, sub } = this.route(a);
+    const names = /* @__PURE__ */ new Set();
+    let routedOk = false;
+    try {
+      for (const n of await fs.readDir(sub)) names.add(n);
+      routedOk = true;
+    } catch {
+    }
+    for (const n of this.mountChildrenOf(a)) names.add(n);
+    if (!routedOk && !this.isMountAncestor(a)) throw new Error(`Directory not found: ${path}`);
+    return [...names].sort();
+  }
+};
+
+// src/speculate.ts
+init_OverlayFilesystem();
+async function raceAttempts(base, n, run, score) {
+  const attempts = await Promise.all(
+    Array.from({ length: Math.max(1, n) }, async (_, index) => {
+      const fs = new OverlayFilesystem(base);
+      const result = await run(fs, index);
+      const s = await score({ fs, result, index });
+      return { index, fs, result, score: s };
+    })
+  );
+  const ranked = attempts.filter((a) => a.score != null).sort((a, b) => b.score - a.score || a.index - b.index);
+  const winner = ranked[0] ?? null;
+  if (winner) await winner.fs.commit();
+  return { winner, attempts };
+}
+
+// src/synthesize.ts
+function validateToolCode(code) {
+  const DENY = [
+    ["process", /\bprocess\b/],
+    ["require", /\brequire\b/],
+    ["import", /\bimport\b/],
+    ["eval", /\beval\b/],
+    ["Function", /\bFunction\b/],
+    ["constructor", /\bconstructor\b/],
+    ["__proto__", /__proto__/],
+    ["prototype", /\bprototype\b/],
+    ["globalThis", /\bglobalThis\b/],
+    ["global", /\bglobal\b/],
+    ["window", /\bwindow\b/],
+    ["self", /\bself\b/],
+    ["Bun", /\bBun\b/],
+    ["Deno", /\bDeno\b/],
+    ["fetch", /\bfetch\b/],
+    ["XMLHttpRequest", /\bXMLHttpRequest\b/],
+    ["WebSocket", /\bWebSocket\b/],
+    ["child_process", /\bchild_process\b/],
+    ["node:", /node:/],
+    ["setTimeout", /\bsetTimeout\b/],
+    ["setInterval", /\bsetInterval\b/],
+    ["setImmediate", /\bsetImmediate\b/],
+    ["Atomics", /\bAtomics\b/],
+    ["SharedArrayBuffer", /\bSharedArrayBuffer\b/],
+    ["WebAssembly", /\bWebAssembly\b/],
+    ["Reflect", /\bReflect\b/],
+    ["Proxy", /\bProxy\b/],
+    ["Buffer", /\bBuffer\b/],
+    ["while(true)", /while\s*\(\s*true\s*\)/],
+    ["for(;;)", /for\s*\(\s*;\s*;\s*\)/],
+    // escape sequences can smuggle a denied identifier past the substring check
+    // (e.g. `process` parses as `process`), so forbid them outright.
+    ["\\u escape", /\\u/],
+    ["\\x escape", /\\x/]
+  ];
+  const violations = DENY.filter(([, re]) => re.test(code)).map(([name]) => name);
+  return { ok: violations.length === 0, violations };
+}
+function compileSynthesizedTool(spec) {
+  const v = validateToolCode(spec.code);
+  if (!v.ok) throw new Error(`unsafe synthesized tool '${spec.name}': blocked tokens [${v.violations.join(", ")}]`);
+  if (!/^[A-Za-z_]\w{0,39}$/.test(spec.name)) throw new Error(`invalid tool name '${spec.name}'`);
+  const fn = new Function("args", "ctx", `"use strict"; return (async (args, ctx) => { ${spec.code} })(args, ctx);`);
+  return {
+    name: spec.name,
+    description: spec.description,
+    parameters: spec.parameters ?? { type: "object", properties: {} },
+    async run(args, ctx) {
+      const r = await fn(args, ctx);
+      return typeof r === "string" ? r : JSON.stringify(r ?? "");
+    }
+  };
+}
+
+// src/FakeAIClient.ts
+var FakeAIClient = class {
+  seen = [];
+  script;
+  constructor(script) {
+    this.script = [...script];
+  }
+  async chat(options) {
+    this.seen.push(options);
+    const next = this.script.shift();
+    if (!next) throw new Error("FakeAIClient: script exhausted (model asked for more turns than scripted)");
+    return next;
+  }
+};
+var toolCall = (id, name, args) => ({
+  id,
+  type: "function",
+  function: { name, arguments: JSON.stringify(args) }
+});
+
+// src/index.ts
+init_tools();
+
+// src/presets.ts
+init_tools();
+import { MemFilesystem } from "@livx.cc/wcli/core";
+function sandboxAgentOptions(opts = {}) {
+  return { fs: new MemFilesystem(), ...opts };
+}
+function diskAgentOptions(opts = {}) {
+  return { ...opts };
+}
+async function fullAgentOptions(opts = {}) {
+  const { makeRealShellTool: makeRealShellTool2, makeShellJobTools: makeShellJobTools2, ShellJobRegistry: ShellJobRegistry2 } = await Promise.resolve().then(() => (init_tools_shell(), tools_shell_exports));
+  const { cwd = process.cwd(), tools, ...rest } = opts;
+  const registry = new ShellJobRegistry2({ cwd, killOnExit: true });
+  const shell = [makeRealShellTool2({ cwd, registry }), ...makeShellJobTools2(registry)];
+  return { ...rest, tools: [...tools ?? defaultTools(), ...shell] };
+}
+
+// src/index.ts
+init_tools_structured();
+init_todo();
+init_tools_web();
+
+// src/lessons.ts
+init_logging();
+var log5 = forComponent("Lessons");
+var LessonOptionsDefaults = class {
+  minRepeats = 2;
+};
+var LESSONS = [
+  { match: /changed since it was read|stale/i, slug: "lesson-stale-edit", body: "Edit kept failing because the file changed since it was read (stale). Re-Read a file immediately before Editing it \u2014 do not Read far ahead of the Edit." },
+  { match: /is not unique|\(\d+ matches\)/i, slug: "lesson-edit-ambiguous", body: "Edit kept failing because old_string was not unique. Include more surrounding lines to disambiguate, or batch with MultiEdit." },
+  { match: /has not been read yet/i, slug: "lesson-read-before-edit", body: "Edit was attempted before Reading the file. Always Read a file before Editing it." },
+  { match: /not found in/i, slug: "lesson-edit-not-found", body: "Edit old_string was not found. Re-Read the current file and copy the exact text (whitespace included) before Editing." },
+  { match: /unknown tool/i, slug: "lesson-unknown-tool", body: "A non-existent tool was called. Only call tools that are advertised in the current tool set." }
+];
+var isFailure = (result) => /^Error:|^Blocked by hook:|^\[exit [1-9]/.test(result);
+function lessonCapture(options) {
+  const o = { ...new LessonOptionsDefaults(), ...options };
+  const counts = /* @__PURE__ */ new Map();
+  const written = /* @__PURE__ */ new Set();
+  return {
+    async postToolUse(_call, result) {
+      if (!isFailure(result)) return;
+      const lesson = LESSONS.find((l) => l.match.test(result));
+      if (!lesson || written.has(lesson.slug)) return;
+      const n = (counts.get(lesson.slug) ?? 0) + 1;
+      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) => log5.warn(`could not persist ${lesson.slug}: ${e?.message ?? e}`));
+      log5.debug(`captured lesson ${lesson.slug} (recurred ${n}\xD7)`);
+    }
+  };
+}
+
+// src/reflect.ts
+init_logging();
+var log6 = forComponent("Reflect");
+async function reflectOnRun(o) {
+  const digest = digestRun(o.result.messages, o.maxDigestChars ?? 6e3);
+  if (!digest.trim()) return null;
+  const prompt = `A coding agent just finished a task with outcome "${o.result.finishReason}". Here is a digest of what it did:
+
+${digest}
+
+If there is a DURABLE, reusable lesson that would help a FUTURE session avoid a mistake seen here, reply with exactly one line:
+LESSON: <imperative, specific, \u2264200 chars>
+If the run was fine or the issue was purely task-specific (not generalizable), reply exactly: NONE`;
+  let text = "";
+  try {
+    const r = await o.ai.chat({ model: o.model, messages: [{ role: "user", content: prompt }], stream: false });
+    text = r?.content ?? "";
+  } catch (e) {
+    log6.warn(`reflection call failed: ${e?.message ?? e}`);
+    return null;
+  }
+  const m = text.match(/LESSON:\s*(.+)/i);
+  const lesson = m?.[1]?.trim().slice(0, 200) ?? "";
+  if (!lesson || /^none\b/i.test(lesson)) return null;
+  const slug = ("lesson-" + slugify(lesson)).slice(0, 56);
+  try {
+    await writeFact(o.fs, o.dir, slug, lesson);
+  } catch (e) {
+    log6.warn(`could not persist lesson: ${e?.message ?? e}`);
+    return null;
+  }
+  log6.debug(`reflection persisted ${slug}`);
+  return slug;
+}
+function digestRun(messages, maxChars) {
+  const lines = [];
+  for (const m of messages) {
+    if (m.role === "assistant" && m.content) lines.push(`assistant: ${contentText(m.content).slice(0, 200)}`);
+    for (const tc of m.tool_calls ?? []) lines.push(`tool ${tc.function.name}(${(tc.function.arguments ?? "").slice(0, 120)})`);
+    if (m.role === "tool" && m.content) lines.push(`  \u2192 ${contentText(m.content).split("\n")[0].slice(0, 200)}`);
+  }
+  const out = lines.join("\n").replace(/LESSON:/gi, "lesson(reported):");
+  return out.length > maxChars ? out.slice(0, maxChars) + "\n\u2026 (truncated)" : out;
+}
+
+// src/mcp.ts
+function toText(result) {
+  if (result == null) return "";
+  if (typeof result === "string") return result;
+  const content = result.content;
+  if (Array.isArray(content)) {
+    const text = content.map((c) => typeof c?.text === "string" ? c.text : JSON.stringify(c)).join("\n");
+    if (text) return text;
+  }
+  return JSON.stringify(result);
+}
+function mcpToolToAgentTool(spec, callTool, prefix = "mcp__") {
+  return {
+    name: `${prefix}${spec.name}`,
+    description: spec.description ?? `MCP tool ${spec.name}`,
+    parameters: spec.inputSchema ?? { type: "object", properties: {} },
+    async run(args, _ctx) {
+      return toText(await callTool(spec.name, args ?? {}));
+    }
+  };
+}
+function mcpToolsToAgentTools(specs, callTool, prefix = "mcp__", filter) {
+  return (filter ? specs.filter(filter) : specs).map((s) => mcpToolToAgentTool(s, callTool, prefix));
+}
+function describeSpec(s) {
+  const schema = s.inputSchema ? `
+   args: ${JSON.stringify(s.inputSchema)}` : "";
+  return `${s.name} \u2014 ${s.description ?? "(no description)"}${schema}`;
+}
+function makeMcpToolSearch(specs, callTool, options = {}) {
+  const maxResults = options.maxResults ?? 10;
+  const byName = new Map(specs.map((s) => [s.name, s]));
+  const catalogLine = `${specs.length} MCP tool(s) available \u2014 search by keyword, then call by exact name.`;
+  const searchTool = {
+    name: "ToolSearch",
+    description: `Search the available MCP tools by keyword (${catalogLine}). Returns matching tool names + their argument schemas; call one with \`McpCall\`.`,
+    parameters: { type: "object", required: ["query"], properties: { query: { type: "string", description: "keywords to match against tool name + description" } } },
+    async run({ query }) {
+      const q = String(query ?? "").trim();
+      if (!q) return catalogLine;
+      const { kept } = topByRelevance(specs, q, (s) => `${s.name} ${s.description ?? ""}`, maxResults);
+      if (!kept.length) return `(no MCP tool matches "${q}" \u2014 try broader keywords)`;
+      return kept.map(describeSpec).join("\n");
+    }
+  };
+  const callMcpTool = {
+    name: "McpCall",
+    description: "Call an MCP tool discovered via `ToolSearch`, by its exact name. Pass its arguments as `args`.",
+    parameters: {
+      type: "object",
+      required: ["name"],
+      properties: {
+        name: { type: "string", description: "exact tool name from ToolSearch" },
+        args: { type: "object", description: "arguments object for the tool (per its schema)" }
+      }
+    },
+    async run({ name, args }) {
+      const n = String(name ?? "");
+      if (!byName.has(n)) return `Error: unknown MCP tool '${n}'. Use ToolSearch to find valid names.`;
+      return toText(await callTool(n, args ?? {}));
+    }
+  };
+  return [searchTool, callMcpTool];
+}
+
+// src/hooks.ts
+var RecordingHooks = class {
+  /** tool name -> reason; a matching preToolUse call is blocked with that reason. */
+  constructor(blocks = {}) {
+    this.blocks = blocks;
+  }
+  blocks;
+  pre = [];
+  post = [];
+  stops = [];
+  preToolUse(call, meta) {
+    this.pre.push({ call, meta });
+    const reason = this.blocks[call.name];
+    if (reason != null) return { block: true, reason };
+  }
+  postToolUse(call, result, meta) {
+    this.post.push({ call, result, meta });
+  }
+  onStop(finalText) {
+    this.stops.push(finalText);
+  }
+};
+var RecordingLifecycle = class {
+  /** @param startContext injected at session start; @param rewrite maps a submitted prompt to a new one. */
+  constructor(startContext, rewrite) {
+    this.startContext = startContext;
+    this.rewrite = rewrite;
+  }
+  startContext;
+  rewrite;
+  starts = 0;
+  prompts = [];
+  compactions = [];
+  subagentStops = [];
+  onSessionStart() {
+    this.starts++;
+    return this.startContext;
+  }
+  onUserPromptSubmit(text) {
+    this.prompts.push(text);
+    return this.rewrite?.(text);
+  }
+  onPreCompact(messages) {
+    this.compactions.push(messages.length);
+  }
+  onSubagentStop(summary, info) {
+    this.subagentStops.push({ summary, label: info?.label });
+  }
+};
+
+// src/index.ts
+init_logging();
+import { MemFilesystem as MemFilesystem2, IndexedDbFilesystem, CommandExecutor as CommandExecutor2, registerHeadlessCommands as registerHeadlessCommands2 } from "@livx.cc/wcli/core";
+export {
+  Agent,
+  AgentOptions,
+  BodDbFilesystem,
+  CommandExecutor2 as CommandExecutor,
+  ConsoleHostBridge,
+  DEFAULT_DENY,
+  DEFAULT_MUTATING,
+  FakeAIClient,
+  IndexedDbFilesystem,
+  JailOptions,
+  JailedFilesystem,
+  LessonOptionsDefaults,
+  MemFilesystem2 as MemFilesystem,
+  MountFilesystem,
+  NodeDiskFilesystem,
+  OverlayFilesystem,
+  PermissionOptions,
+  PermissionPolicy,
+  RecordingHooks,
+  RecordingLifecycle,
+  SandboxJobRegistry,
+  ScriptedHostBridge,
+  applyEditsTool,
+  askUserQuestionTool,
+  bashTool,
+  checkpointTool,
+  checkpointTools,
+  compileSynthesizedTool,
+  composeHooks,
+  contentText,
+  defaultTools,
+  diskAgentOptions,
+  editTool,
+  expandCommand,
+  expandTemplate,
+  forComponent,
+  fullAgentOptions,
+  globTool,
+  grepTool,
+  htmlToText,
+  idfWeights,
+  imagePart,
+  lessonCapture,
+  loadAgents,
+  loadCommands,
+  loadInstructions,
+  loadMemory,
+  loadSkills,
+  log,
+  makeContext,
+  makeJobTools,
+  makeMcpToolSearch,
+  makeTaskBatchTool,
+  makeTaskTool,
+  makeWebFetchTool,
+  makeWebSearchTool,
+  mcpToolToAgentTool,
+  mcpToolsToAgentTools,
+  mkdirp,
+  multiEditTool,
+  planMode,
+  raceAttempts,
+  readTool,
+  reflectOnRun,
+  registerHeadlessCommands2 as registerHeadlessCommands,
+  relevanceScore,
+  repoIndex,
+  repoMapTool,
+  rollbackTool,
+  sandboxAgentOptions,
+  slugify,
+  toWireTools,
+  todoWriteTool,
+  tokenize,
+  toolCall,
+  toolRegistry,
+  toolsByName,
+  topByRelevance,
+  validateToolCode,
+  webFetchTool,
+  webSearchTool,
+  writeFact,
+  writeTool
+};
+//# sourceMappingURL=index.js.map