@vibgrate/cli 2026.722.1 → 2026.727.1

package/dist/chunk-3BVSDMHV.js

@@ -0,0 +1,2496 @@
+import { localGraphBackend } from './chunk-4CQ3MGNN.js';
+import { buildIdentifierTrieFromGraph, KvBlockRegistry, graphDraftCandidates, extractIdentifiers, scanIdentifiersAgainstTrie } from './chunk-JIBOJTGS.js';
+import { buildAgentMessages, redactSecrets, unifiedDiff, applyEdit } from './chunk-7JHPQ6WF.js';
+import { resolve, resolveLib, loadCatalog, readDoc, localPackageDocs, resolveVersion } from './chunk-C4CKTAZP.js';
+import { resolveOne } from './chunk-J7LKEB2R.js';
+import { summarizeCapsule, buildCodeContext, buildTaskCapsule, capsuleToCodeContext, recordCliCall, CLI_TOOL_ALIASES, CAPSULE_RANKING_VERSION } from './chunk-EDAAG7BL.js';
+import { impactOf } from './chunk-6IOQJGFT.js';
+import { parseSource, langForExtension } from './chunk-3Q7QBWFW.js';
+import { repositoryIdFromRoot } from './chunk-BWPBB45M.js';
+import { hashString, canonicalize } from './chunk-JFGYT6BI.js';
+import { spawnSync } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+
+// src/code/capsule-delta.ts
+var CAPSULE_DELTA_SCHEMA_VERSION = "capsule-delta/0";
+function buildCapsuleDelta(previous, next) {
+  const prevPrimary = keySet(previous.primary);
+  const nextPrimary = keySet(next.primary);
+  const prevSupport = keySet(previous.supporting);
+  keySet(next.supporting);
+  const addedPrimary = next.primary.filter((p) => !prevPrimary.has(symKey(p))).map((p) => ({ qualifiedName: p.qualifiedName, file: p.file, kind: p.kind }));
+  const removedPrimary = previous.primary.filter((p) => !nextPrimary.has(symKey(p))).map((p) => ({ qualifiedName: p.qualifiedName, file: p.file }));
+  const addedSupporting = next.supporting.filter((p) => !prevSupport.has(symKey(p))).map((p) => ({ qualifiedName: p.qualifiedName, file: p.file, kind: p.kind }));
+  const changedSourceFiles = diffSourceFiles(previous.sourceSlices, next.sourceSlices);
+  const verificationDelta = diffVerification(previous.verificationPlan, next.verificationPlan);
+  const delta = {
+    schemaVersion: CAPSULE_DELTA_SCHEMA_VERSION,
+    changedSourceFiles,
+    addedPrimary,
+    removedPrimary,
+    addedSupporting,
+    verificationDelta,
+    rendered: "",
+    tokensEstimate: 0
+  };
+  delta.rendered = renderCapsuleDelta(delta, next);
+  delta.tokensEstimate = Math.max(1, Math.ceil(delta.rendered.length / 4));
+  return delta;
+}
+function isEmptyCapsuleDelta(d) {
+  return d.changedSourceFiles.length === 0 && d.addedPrimary.length === 0 && d.removedPrimary.length === 0 && d.addedSupporting.length === 0 && d.verificationDelta.syntaxFilesAdded.length === 0 && d.verificationDelta.syntaxFilesRemoved.length === 0 && d.verificationDelta.notesAdded.length === 0;
+}
+function keySet(syms) {
+  return new Set(syms.map(symKey));
+}
+function symKey(p) {
+  return `${p.qualifiedName}\0${p.file}`;
+}
+function diffSourceFiles(prev, next) {
+  const prevHash = /* @__PURE__ */ new Map();
+  for (const s of prev) {
+    const k = `${s.file}:${s.start}-${s.end}`;
+    prevHash.set(k, s.contentHash);
+  }
+  const changed = /* @__PURE__ */ new Set();
+  for (const s of next) {
+    const k = `${s.file}:${s.start}-${s.end}`;
+    const old = prevHash.get(k);
+    if (old !== s.contentHash) changed.add(s.file);
+  }
+  const nextFiles = new Set(next.map((s) => s.file));
+  for (const s of prev) {
+    if (!nextFiles.has(s.file)) changed.add(s.file);
+  }
+  return [...changed].sort();
+}
+function diffVerification(prev, next) {
+  const prevFiles = new Set(prev.syntaxFiles);
+  const nextFiles = new Set(next.syntaxFiles);
+  const prevNotes = new Set(prev.notes);
+  return {
+    syntaxFilesAdded: next.syntaxFiles.filter((f) => !prevFiles.has(f)).sort(),
+    syntaxFilesRemoved: prev.syntaxFiles.filter((f) => !nextFiles.has(f)).sort(),
+    notesAdded: next.notes.filter((n) => !prevNotes.has(n))
+  };
+}
+function renderCapsuleDelta(d, next) {
+  const lines = [
+    "## Capsule delta (since last context)",
+    `Instruction: ${next.instruction}`
+  ];
+  if (d.changedSourceFiles.length) {
+    lines.push(`Source updated: ${d.changedSourceFiles.join(", ")}`);
+  }
+  if (d.addedPrimary.length) {
+    lines.push("New primary:");
+    for (const p of d.addedPrimary) lines.push(`- ${p.qualifiedName} (${p.kind}) ${p.file}`);
+  }
+  if (d.removedPrimary.length) {
+    lines.push("Removed primary:");
+    for (const p of d.removedPrimary) lines.push(`- ${p.qualifiedName} ${p.file}`);
+  }
+  if (d.addedSupporting.length) {
+    lines.push("New supporting:");
+    for (const p of d.addedSupporting.slice(0, 8)) lines.push(`- ${p.qualifiedName} ${p.file}`);
+  }
+  if (d.verificationDelta.syntaxFilesAdded.length || d.verificationDelta.notesAdded.length) {
+    lines.push("Verification plan updates:");
+    for (const f of d.verificationDelta.syntaxFilesAdded) lines.push(`- +syntax ${f}`);
+    for (const n of d.verificationDelta.notesAdded.slice(0, 4)) lines.push(`- +note ${n}`);
+  }
+  if (isEmptyCapsuleDelta(d)) {
+    lines.push("(no structural capsule changes)");
+  }
+  const changed = new Set(d.changedSourceFiles);
+  const slices = next.sourceSlices.filter((s) => changed.has(s.file)).slice(0, 6);
+  if (slices.length) {
+    lines.push("", "### Updated source slices");
+    for (const s of slices) {
+      lines.push(`\`\`\`${s.file}:${s.start}-${s.end}`, s.content, "```");
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/code/advanced-mode.ts
+var DISCOVERY_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "search_code",
+  "read_file",
+  "list_files",
+  "graph_impact",
+  "library_docs"
+]);
+function createDiscoveryGateState() {
+  return { discoveryCount: 0, mutations: 0, inspectChangeUsed: false };
+}
+function gateDiscoveryTool(name, state, options) {
+  if (options.advancedMode) return { allow: true };
+  if (!DISCOVERY_TOOL_NAMES.has(name)) return { allow: true };
+  if (state.mutations > 0 || state.inspectChangeUsed) return { allow: true };
+  const soft = options.softLimit ?? 2;
+  const hard = options.hardLimit ?? 6;
+  if (hard > 0 && state.discoveryCount >= hard) {
+    return {
+      allow: false,
+      reason: `Discovery tools are limited for capsule-first runs (${hard} free calls used). Use inspect_task / inspect_change / apply_patch / edit_file with the capsule evidence, or re-run with advanced mode if you need free search.`
+    };
+  }
+  if (state.discoveryCount >= soft) {
+    return {
+      allow: true,
+      note: `(capsule-first) Prefer the Task Capsule evidence over further navigation. Call inspect_change before multi-file edits. Discovery calls so far: ${state.discoveryCount + 1}.`
+    };
+  }
+  return { allow: true };
+}
+function recordDiscoveryGateOutcome(name, state, result) {
+  if (DISCOVERY_TOOL_NAMES.has(name)) state.discoveryCount++;
+  if (result.mutated) state.mutations++;
+  if (name === "inspect_change") state.inspectChangeUsed = true;
+}
+
+// src/code/session-graph.ts
+async function materializeSessionGraph(base, overlay, options = {}) {
+  return applyOverlayToGraph(base, overlay.snapshot(), {
+    parseFile: options.parseFile ?? defaultParse,
+    readContent: (rel) => {
+      const entry = overlay.snapshot().get(normalize(rel));
+      if (!entry) return null;
+      if (entry.kind === "delete") return null;
+      return entry.content;
+    }
+  });
+}
+async function applyOverlayToGraph(base, dirty, options = {}) {
+  if (dirty.size === 0) {
+    return { graph: base, deleted: [], rewritten: [], reparsed: [] };
+  }
+  const deleted = [];
+  const rewritten = [];
+  for (const [file, entry] of [...dirty.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+    if (entry.kind === "delete") deleted.push(file);
+    else rewritten.push(file);
+  }
+  const drop = new Set([...deleted, ...rewritten].map(normalize));
+  const keptNodes = base.nodes.filter((n) => !drop.has(normalize(n.file)));
+  const keptIds = new Set(keptNodes.map((n) => n.id));
+  const keptEdges = base.edges.filter((e) => keptIds.has(e.src) && keptIds.has(e.dst));
+  const reparsed = [];
+  const newNodes = [];
+  const newEdges = [];
+  const parseFile = options.parseFile;
+  const readContent = options.readContent;
+  if (parseFile && readContent) {
+    for (const file of rewritten) {
+      const content = readContent(file);
+      if (content === null) continue;
+      const lang = langIdFor(file);
+      if (!lang) continue;
+      try {
+        const fp = await parseFile(file, content, lang);
+        const resolved = resolve([fp]);
+        for (const n of resolved.nodes) {
+          newNodes.push(withAnalysisDefaults(n));
+        }
+        for (const e of resolved.edges) {
+          newEdges.push(e);
+        }
+        reparsed.push(file);
+      } catch {
+      }
+    }
+  }
+  const nodes = [...keptNodes, ...newNodes].sort((a, b) => a.id.localeCompare(b.id));
+  const edges = [...keptEdges, ...newEdges].sort((a, b) => a.id.localeCompare(b.id));
+  const nodeIds = new Set(nodes.map((n) => n.id));
+  const edgesFinal = edges.filter((e) => nodeIds.has(e.src) && nodeIds.has(e.dst));
+  const graph = {
+    ...base,
+    nodes,
+    edges: edgesFinal,
+    meta: {
+      ...base.meta,
+      counts: {
+        ...base.meta.counts,
+        nodes: nodes.length,
+        edges: edgesFinal.length
+      }
+    },
+    provenance: {
+      ...base.provenance,
+      // Session view fingerprint — not a corpus commit; consumers must not confuse with disk map.
+      corpusHash: `${base.provenance.corpusHash}:session:${deleted.length}:${rewritten.length}:${reparsed.join(",")}`
+    }
+  };
+  return { graph, deleted, rewritten, reparsed };
+}
+async function defaultParse(rel, source, langId) {
+  return parseSource(rel, langId, source);
+}
+function langIdFor(rel) {
+  const ext = rel.includes(".") ? rel.slice(rel.lastIndexOf(".")) : "";
+  const def = langForExtension(ext);
+  return def?.id ?? null;
+}
+function withAnalysisDefaults(n) {
+  return {
+    ...n,
+    importance: n.importance ?? 0.5,
+    centrality: n.centrality ?? { degree: 0, pagerank: 0, betweenness: 0, eigenvector: 0 },
+    area: n.area ?? 0,
+    isHub: n.isHub ?? false,
+    tested: n.tested ?? false
+  };
+}
+function normalize(file) {
+  return file.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+
+// src/code/worktree-overlay.ts
+var DEFAULT_EXTS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".go",
+  ".rs",
+  ".java",
+  ".cs",
+  ".rb",
+  ".kt",
+  ".swift"
+]);
+function listWorktreeDirtyFiles(root, options = {}) {
+  const max = options.maxFiles ?? 80;
+  const exts = options.extensions ? new Set(options.extensions) : DEFAULT_EXTS;
+  const body = options.porcelain ?? (() => {
+    try {
+      const res = spawnSync("git", ["status", "--porcelain", "-uall"], {
+        cwd: root,
+        encoding: "utf8",
+        timeout: 15e3
+      });
+      if (res.status !== 0) return "";
+      return res.stdout ?? "";
+    } catch {
+      return "";
+    }
+  })();
+  const files = /* @__PURE__ */ new Set();
+  for (const line of body.split("\n")) {
+    if (!line.trim()) continue;
+    const ren = /^.. (.+) -> (.+)$/.exec(line);
+    const raw = ren ? ren[2] : line.slice(3).trim();
+    const rel = raw.replace(/^"|"$/g, "").replace(/\\"/g, '"');
+    if (!rel || rel.startsWith(".git/")) continue;
+    const ext = path.extname(rel).toLowerCase();
+    if (exts.size && !exts.has(ext)) continue;
+    files.add(rel.replace(/\\/g, "/"));
+  }
+  return [...files].sort().slice(0, max);
+}
+function buildWorktreeOverlayEntries(root, dirtyFiles, options = {}) {
+  const read = options.readFile ?? ((abs) => {
+    try {
+      return fs.readFileSync(abs, "utf8");
+    } catch {
+      return null;
+    }
+  });
+  const out = /* @__PURE__ */ new Map();
+  for (const rel of dirtyFiles) {
+    const abs = path.resolve(root, rel);
+    const content = read(abs);
+    if (content === null) out.set(normalize2(rel), { kind: "delete" });
+    else out.set(normalize2(rel), { kind: "write", content });
+  }
+  return out;
+}
+async function materializeWorktreeGraph(base, root, options = {}) {
+  const dirtyFiles = options.dirtyFiles ?? listWorktreeDirtyFiles(root, options);
+  if (!dirtyFiles.length) {
+    return { graph: base, deleted: [], rewritten: [], reparsed: [], dirtyFiles: [] };
+  }
+  const entries = buildWorktreeOverlayEntries(root, dirtyFiles, { readFile: options.readFile });
+  const result = await applyOverlayToGraph(base, entries, {
+    parseFile: options.parseFile,
+    readContent: (rel) => {
+      const e = entries.get(normalize2(rel));
+      if (!e || e.kind === "delete") return null;
+      return e.content;
+    }
+  });
+  return { ...result, dirtyFiles };
+}
+function normalize2(file) {
+  return file.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+
+// src/code/patch-ir.ts
+var PATCH_IR_SCHEMA_VERSION = "patch-ir/0";
+function patchIRToCodeEdits(patch) {
+  const out = [];
+  for (const op of patch.operations) {
+    if (op.op === "replace-text") {
+      out.push({
+        op: "replace",
+        file: op.file,
+        search: op.search,
+        replace: op.replace,
+        anchorSymbol: op.anchorSymbol ?? void 0
+      });
+      continue;
+    }
+    if (op.op === "create-file") {
+      out.push({ op: "create", file: op.file, content: op.content });
+      continue;
+    }
+    if (op.op === "delete-file") {
+      out.push({ op: "delete", file: op.file });
+      continue;
+    }
+  }
+  return out;
+}
+function validatePatchIR(patch) {
+  const errors = [];
+  if (patch.schemaVersion !== PATCH_IR_SCHEMA_VERSION) {
+    errors.push(`unsupported schemaVersion: ${String(patch.schemaVersion)}`);
+  }
+  if (!Array.isArray(patch.operations) || patch.operations.length === 0) {
+    errors.push("operations must be a non-empty array");
+  } else {
+    patch.operations.forEach((op, i) => {
+      if (!op || typeof op !== "object" || !("op" in op)) {
+        errors.push(`operations[${i}]: missing op`);
+        return;
+      }
+      switch (op.op) {
+        case "replace-text":
+          if (!op.file?.trim()) errors.push(`operations[${i}]: replace-text requires file`);
+          if (typeof op.search !== "string") errors.push(`operations[${i}]: replace-text requires search`);
+          if (typeof op.replace !== "string") errors.push(`operations[${i}]: replace-text requires replace`);
+          break;
+        case "replace-range":
+          if (!op.file?.trim()) errors.push(`operations[${i}]: replace-range requires file`);
+          if (!Number.isInteger(op.start) || op.start < 1) errors.push(`operations[${i}]: replace-range start must be >= 1`);
+          if (!Number.isInteger(op.end) || op.end < op.start) errors.push(`operations[${i}]: replace-range end must be >= start`);
+          if (typeof op.replacement !== "string") errors.push(`operations[${i}]: replace-range requires replacement`);
+          break;
+        case "create-file":
+          if (!op.file?.trim()) errors.push(`operations[${i}]: create-file requires file`);
+          if (typeof op.content !== "string") errors.push(`operations[${i}]: create-file requires content`);
+          break;
+        case "delete-file":
+          if (!op.file?.trim()) errors.push(`operations[${i}]: delete-file requires file`);
+          break;
+        case "replace-symbol":
+          if (!op.symbolId?.trim()) errors.push(`operations[${i}]: replace-symbol requires symbolId`);
+          if (typeof op.replacement !== "string") errors.push(`operations[${i}]: replace-symbol requires replacement`);
+          break;
+        default:
+          errors.push(`operations[${i}]: unknown op`);
+      }
+    });
+  }
+  return { ok: errors.length === 0, errors };
+}
+
+// src/code/apply-patch-ir.ts
+function applyPatchIR(patch, options) {
+  const structural = validatePatchIR(patch);
+  if (!structural.ok) {
+    return { ok: false, files: /* @__PURE__ */ new Map(), ops: [], errors: structural.errors };
+  }
+  const spansForFile = options.spansForFile ?? (() => []);
+  const locateSymbol = options.locateSymbol ?? (() => null);
+  const working = /* @__PURE__ */ new Map();
+  const befores = /* @__PURE__ */ new Map();
+  const ops = [];
+  const errors = [];
+  const read = (file) => {
+    if (working.has(file)) return working.get(file);
+    const before = options.readFile(file);
+    befores.set(file, before);
+    working.set(file, before);
+    return before;
+  };
+  const write = (file, content) => {
+    if (!befores.has(file)) befores.set(file, options.readFile(file));
+    working.set(file, content);
+  };
+  for (const assumption of patch.assumptions) {
+    const check = checkAssumption(assumption, (f) => options.readFile(f), locateSymbol);
+    if (!check.ok) {
+      errors.push(check.reason ?? "assumption failed");
+      ops.push({
+        index: -1,
+        op: "replace-text",
+        file: assumption.file ?? "",
+        status: "assumption-failed",
+        reason: check.reason
+      });
+      if (options.transactional) {
+        return { ok: false, files: /* @__PURE__ */ new Map(), ops, errors };
+      }
+    }
+  }
+  if (options.transactional && errors.length) {
+    return { ok: false, files: /* @__PURE__ */ new Map(), ops, errors };
+  }
+  if (options.transactional) {
+    const preview = applyAll(patch.operations, read, write, spansForFile, locateSymbol, ops);
+    const failed = preview.some((o) => o.status !== "applied" && o.status !== "no-op");
+    if (failed) {
+      const failErrors = preview.filter((o) => o.status !== "applied" && o.status !== "no-op").map((o) => o.reason ?? o.status);
+      return { ok: false, files: /* @__PURE__ */ new Map(), ops: preview, errors: failErrors };
+    }
+  } else {
+    applyAll(patch.operations, read, write, spansForFile, locateSymbol, ops);
+  }
+  const files = /* @__PURE__ */ new Map();
+  for (const [file, after] of working) {
+    files.set(file, { before: befores.get(file) ?? null, after });
+  }
+  const hardFail = ops.some((o) => o.status === "assumption-failed" || o.status === "unsupported" || o.status === "invalid" || o.status === "not-found" || o.status === "ambiguous" || o.status === "conflict");
+  return {
+    ok: !hardFail && errors.length === 0,
+    files,
+    ops,
+    errors
+  };
+}
+function applyAll(operations, read, write, spansForFile, locateSymbol, ops) {
+  const out = ops;
+  out.length = 0;
+  for (let i = 0; i < operations.length; i++) {
+    const op = operations[i];
+    const result = applyOne(op, i, read, write, spansForFile, locateSymbol);
+    out.push(result);
+  }
+  return out;
+}
+function applyOne(op, index, read, write, spansForFile, locateSymbol) {
+  if (op.op === "replace-text" || op.op === "create-file" || op.op === "delete-file") {
+    const edits = patchIRToCodeEdits({
+      operations: [op]});
+    const edit = edits[0];
+    const file = edit.file;
+    const before = read(file);
+    const { content, outcome } = applyEdit(before, edit, spansForFile(file));
+    if (outcome.status === "applied" || outcome.status === "no-op") {
+      write(file, content);
+    }
+    return { index, op: op.op, file, status: outcome.status, reason: outcome.reason };
+  }
+  if (op.op === "replace-range") {
+    const file = op.file;
+    const before = read(file);
+    if (before === null) {
+      return { index, op: op.op, file, status: "not-found", reason: `${file} does not exist` };
+    }
+    if (op.expectedHash) {
+      const h = hashString(before);
+      if (h !== op.expectedHash) {
+        return { index, op: op.op, file, status: "conflict", reason: `file hash mismatch for ${file} (stale capsule or concurrent edit)` };
+      }
+    }
+    const lines = before.split("\n");
+    if (op.start < 1 || op.end > lines.length || op.end < op.start) {
+      return { index, op: op.op, file, status: "invalid", reason: `replace-range ${op.start}-${op.end} outside file (${lines.length} lines)` };
+    }
+    const next = [...lines.slice(0, op.start - 1), ...op.replacement.split("\n"), ...lines.slice(op.end)].join("\n");
+    write(file, next);
+    return { index, op: op.op, file, status: next === before ? "no-op" : "applied" };
+  }
+  if (op.op === "replace-symbol") {
+    const loc = locateSymbol(op.symbolId);
+    if (!loc) {
+      return { index, op: op.op, file: op.file ?? "", status: "not-found", reason: `symbol ${op.symbolId} not in the map` };
+    }
+    const file = op.file?.trim() ? op.file : loc.file;
+    if (normalize3(file) !== normalize3(loc.file)) {
+      return { index, op: op.op, file, status: "conflict", reason: `symbol ${op.symbolId} lives in ${loc.file}, not ${file}` };
+    }
+    const rangeOp = {
+      op: "replace-range",
+      file: loc.file,
+      start: loc.start,
+      end: loc.end,
+      replacement: op.replacement,
+      expectedHash: op.expectedHash,
+      anchorSymbol: op.symbolId
+    };
+    return applyOne(rangeOp, index, read, write, spansForFile, locateSymbol);
+  }
+  return { index, op: op.op, file: "", status: "unsupported", reason: "unknown operation" };
+}
+function checkAssumption(a, readFile2, locateSymbol) {
+  switch (a.kind) {
+    case "file-hash": {
+      if (!a.file || !a.expectedHash) return { ok: false, reason: "file-hash assumption needs file and expectedHash" };
+      const content = readFile2(a.file);
+      if (content === null) return { ok: false, reason: `assumption file-hash: ${a.file} missing` };
+      if (hashString(content) !== a.expectedHash) return { ok: false, reason: `assumption file-hash failed for ${a.file}` };
+      return { ok: true };
+    }
+    case "text-present": {
+      if (!a.file || !a.detail) return { ok: false, reason: "text-present assumption needs file and detail" };
+      const content = readFile2(a.file);
+      if (content === null || !content.includes(a.detail)) {
+        return { ok: false, reason: `assumption text-present failed for ${a.file}` };
+      }
+      return { ok: true };
+    }
+    case "symbol-exists": {
+      if (!a.symbolId) return { ok: false, reason: "symbol-exists assumption needs symbolId" };
+      if (!locateSymbol(a.symbolId)) return { ok: false, reason: `assumption symbol-exists failed: ${a.symbolId}` };
+      return { ok: true };
+    }
+    case "symbol-span": {
+      if (!a.symbolId) return { ok: false, reason: "symbol-span assumption needs symbolId" };
+      const loc = locateSymbol(a.symbolId);
+      if (!loc) return { ok: false, reason: `assumption symbol-span: ${a.symbolId} missing` };
+      if (a.file && normalize3(a.file) !== normalize3(loc.file)) {
+        return { ok: false, reason: `assumption symbol-span file mismatch for ${a.symbolId}` };
+      }
+      return { ok: true };
+    }
+    case "other":
+      return { ok: true };
+    default:
+      return { ok: false, reason: `unknown assumption kind: ${String(a.kind)}` };
+  }
+}
+function normalize3(file) {
+  return file.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function locatorsFromGraph(nodes) {
+  const map = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    map.set(n.id, { id: n.id, file: normalize3(n.file), start: n.span.start, end: n.span.end });
+  }
+  return (id) => map.get(id) ?? null;
+}
+
+// src/code/secrets.ts
+var SECRET_FILE = new RegExp(
+  [
+    String.raw`(^|/)\.env(\.[\w.-]+)?$`,
+    // .env, .env.local, .env.production
+    String.raw`(^|/)\.npmrc$`,
+    String.raw`(^|/)\.netrc$`,
+    String.raw`(^|/)\.pgpass$`,
+    String.raw`(^|/)\.git-credentials$`,
+    String.raw`(^|/)id_(rsa|dsa|ecdsa|ed25519)$`,
+    String.raw`\.pem$`,
+    String.raw`\.key$`,
+    String.raw`\.p12$`,
+    String.raw`\.pfx$`,
+    String.raw`(^|/)credentials(\.json)?$`,
+    // aws credentials, gcloud
+    String.raw`(^|/)\.aws/credentials$`,
+    String.raw`(^|/)secrets?\.(ya?ml|json|toml|env)$`
+  ].join("|"),
+  "i"
+);
+function isSecretPath(file) {
+  const normalized = file.replace(/\\/g, "/");
+  return SECRET_FILE.test(normalized);
+}
+function secretRefusal(file) {
+  return `refusing to read ${file} \u2014 it looks like a secrets/credentials file, and this content would be sent to the model. Reference the values by name instead, or read a non-secret file.`;
+}
+var TOKEN_SHAPES = /\b(sk|pk|rk|xoxb|xoxp|ghp|gho|ghs|ghu|glpat|AKIA|ASIA|AIza|ya29|hf|nvapi|sk-ant|sk-or)[-_][A-Za-z0-9\-_./+]{8,}/g;
+var BEARER = /\b(Authorization|Bearer|token|api[_-]?key)\b\s*[:=]\s*['"]?[A-Za-z0-9\-_./+]{12,}['"]?/gi;
+var ASSIGNMENT = /\b([A-Za-z0-9_]*(?:KEY|TOKEN|SECRET|PASSWORD|PASSWD|PWD|CREDENTIAL|PRIVATE|ACCESS|SESSION)[A-Za-z0-9_]*)\s*([:=])\s*['"]?([^\s'";,]{6,})/gi;
+var URL_AUTH = /\b([a-z][a-z0-9+.-]*:\/\/)([^:/\s]+):([^@/\s]+)@/gi;
+function redactText(text) {
+  return text.replace(URL_AUTH, "$1$2:***redacted***@").replace(TOKEN_SHAPES, (_m, prefix) => `${prefix}-***redacted***`).replace(BEARER, (_m, k) => `${k}: ***redacted***`).replace(ASSIGNMENT, (_m, name, op) => `${name}${op}***redacted***`);
+}
+function findSecretShapes(text) {
+  const hits = [];
+  const scan = (re, kind) => {
+    re.lastIndex = 0;
+    let m;
+    while ((m = re.exec(text)) !== null) {
+      hits.push({ kind, index: m.index });
+      if (m[0].length === 0) re.lastIndex++;
+    }
+  };
+  scan(TOKEN_SHAPES, "token");
+  scan(BEARER, "bearer");
+  scan(ASSIGNMENT, "assignment");
+  scan(URL_AUTH, "url-auth");
+  return hits.sort((a, b) => a.index - b.index || a.kind.localeCompare(b.kind));
+}
+function secretEgressRefusal(text, surface = "network payload") {
+  const hits = findSecretShapes(text);
+  if (hits.length === 0) return null;
+  const kinds = [...new Set(hits.map((h) => h.kind))].sort().join(", ");
+  return `refusing to send ${surface} \u2014 detected credential-shaped content (${kinds}). Remove secrets before any network call; path-level secrets files are also blocked.`;
+}
+
+// src/code/safety.ts
+var DANGEROUS = [
+  { pattern: /\brm\s+(-[a-z]*f[a-z]*\s+)?(-[a-z]*r[a-z]*\s+)?(-[a-z]*\s+)*(\/|~|\$HOME|\.)(\s|$)/i, reason: "recursive/forced delete of a root or home path" },
+  { pattern: /\brm\s+-[a-z]*r[a-z]*f|\brm\s+-[a-z]*f[a-z]*r/i, reason: "recursive force delete" },
+  { pattern: /\bmkfs\b|\bmke2fs\b/i, reason: "formats a filesystem" },
+  { pattern: /\bdd\b[^|]*\bof=\/dev\//i, reason: "writes raw to a device" },
+  { pattern: />\s*\/dev\/(sd|nvme|hd|disk)/i, reason: "writes raw to a disk device" },
+  { pattern: /:\s*\(\s*\)\s*\{[^}]*\}\s*;\s*:/, reason: "fork bomb" },
+  { pattern: /\b(curl|wget|fetch)\b[^\n|]*\|\s*(sudo\s+)?(sh|bash|zsh|python|node|ruby|perl)\b/i, reason: "pipes a download straight into a shell/interpreter" },
+  { pattern: /\bgit\s+push\b[^\n]*(--force\b|-f\b)/i, reason: "force-push (rewrites remote history)" },
+  { pattern: /\bgit\s+(reset\s+--hard|clean\s+-[a-z]*f)/i, reason: "destroys uncommitted work" },
+  { pattern: /\b(shutdown|reboot|halt|poweroff)\b/i, reason: "powers off / reboots the machine" },
+  { pattern: /\bchmod\s+-R\s+0*777\s+(\/|~)/i, reason: "world-writable on a root/home path" },
+  { pattern: /\bsudo\b/i, reason: "runs as root (never automatic)" },
+  { pattern: /\beval\b\s+["'`]?\$\(/i, reason: "evaluates dynamically-constructed shell" }
+];
+function dangerousCommand(command, extraDeny = []) {
+  const cmd = command.trim();
+  for (const { pattern, reason } of DANGEROUS) {
+    if (pattern.test(cmd)) return reason;
+  }
+  for (const raw of extraDeny) {
+    if (!raw) continue;
+    try {
+      if (new RegExp(raw, "i").test(cmd)) return `matches a project denylist rule (${raw})`;
+    } catch {
+      if (cmd.toLowerCase().includes(raw.toLowerCase())) return `matches a project denylist rule (${raw})`;
+    }
+  }
+  return null;
+}
+
+// src/code/network-policy.ts
+var NETWORK_POLICY_VERSION = "network-policy@2026.07.0";
+function commandSuggestsNetwork(command) {
+  const cmd = command.trim();
+  if (!cmd) return false;
+  if (/\b(curl|wget|fetch|httpie|aria2c|nc|ncat|netcat|socat|telnet|ftp|sftp|scp|rsync|ssh|nmap|masscan)\b/i.test(
+    cmd
+  )) {
+    return true;
+  }
+  if (/\b(node|nodejs)\b[^\n]*\b(fetch|https?\.get|http\.request|net\.connect)\b/i.test(cmd)) return true;
+  if (/\bpython[23]?\b[^\n]*\b(urllib|requests|http\.client|socket)\b/i.test(cmd)) return true;
+  if (/https?:\/\//i.test(cmd)) return true;
+  if (/\b(npm|pnpm|yarn|bun)\s+(install|add|update)\b/i.test(cmd) && !/\s--offline\b/i.test(cmd)) {
+    if (!/\s(\.\/|\/|\.\.\/)/.test(cmd) && !/\sfile:/i.test(cmd)) return true;
+  }
+  if (/\bpip[23]?\s+install\b/i.test(cmd) && !/\s--no-index\b/i.test(cmd) && !/\s\.\/|\/|\.\.\//.test(cmd)) {
+    return true;
+  }
+  return false;
+}
+function networkCommandRefusal(command, options = { enforce: true }) {
+  if (!options.enforce) return null;
+  if (!commandSuggestsNetwork(command)) return null;
+  const ver = options.policy?.policyVersion ?? NETWORK_POLICY_VERSION;
+  return `network policy ${ver} denies outbound network from agent shell commands (default-deny). Run the command yourself outside the agent, or re-run interactively without --auto if a human should approve it.`;
+}
+
+// src/code/failure-capsule.ts
+var FAILURE_CAPSULE_SCHEMA_VERSION = "failure-capsule/0";
+var FAILURE_CAPSULE_COMPILER_ID = "vg-failure-capsule/0";
+function buildFailureCapsule(options) {
+  const maxDiag = options.maxDiagnostic ?? 2500;
+  const maxSlices = options.maxSlices ?? 6;
+  const failed = pickFailedStep(options);
+  const diagnosticExcerpt = redactAndTrim(failed.rawDiagnostic, maxDiag);
+  const affectedSymbols = collectAffected(options.capsule, options.changedFiles ?? [], diagnosticExcerpt);
+  const sourceSlices = pickSourceSlices(options.capsule, affectedSymbols, maxSlices);
+  const likelyCorrections = rankCorrections(failed, diagnosticExcerpt, options.changedFiles ?? []);
+  const previousOpsSummary = options.previousOpsSummary ?? (options.changedFiles ?? []).map((f) => `touched ${f}`);
+  const capsule = {
+    schemaVersion: FAILURE_CAPSULE_SCHEMA_VERSION,
+    failedStep: failed.step,
+    diagnosticExcerpt,
+    affectedSymbols,
+    sourceSlices,
+    previousOpsSummary,
+    graphDeltaNote: options.graphDeltaNote,
+    likelyCorrections,
+    rendered: "",
+    provenance: {
+      compiler: FAILURE_CAPSULE_COMPILER_ID,
+      modelId: options.modelId ?? null,
+      policyVersion: options.policyVersion ?? null
+    }
+  };
+  capsule.rendered = renderFailureCapsule(capsule);
+  return capsule;
+}
+function renderFailureCapsule(fc) {
+  const lines = [
+    "## Failure Capsule",
+    `Failed step: ${fc.failedStep.type}${fc.failedStep.command ? ` \`${fc.failedStep.command}\`` : ""}${fc.failedStep.exitCode != null ? ` (exit ${fc.failedStep.exitCode})` : ""}`,
+    "",
+    "### Diagnostic",
+    fc.diagnosticExcerpt || "(no output)"
+  ];
+  if (fc.affectedSymbols.length) {
+    lines.push("", "### Affected symbols / files");
+    for (const s of fc.affectedSymbols.slice(0, 12)) {
+      lines.push(`- ${s.qualifiedName} (${s.file})${s.reason ? ` \u2014 ${s.reason}` : ""}`);
+    }
+  }
+  if (fc.sourceSlices.length) {
+    lines.push("", "### Relevant source");
+    for (const sl of fc.sourceSlices) {
+      lines.push(`\`\`\`${sl.file}:${sl.startLine}-${sl.endLine}`, sl.content, "```");
+    }
+  }
+  if (fc.previousOpsSummary.length) {
+    lines.push("", "### Prior ops", ...fc.previousOpsSummary.map((o) => `- ${o}`));
+  }
+  if (fc.likelyCorrections.length) {
+    lines.push("", "### Likely corrections", ...fc.likelyCorrections.map((c) => `- ${c}`));
+  }
+  if (fc.graphDeltaNote) {
+    lines.push("", `Graph: ${fc.graphDeltaNote}`);
+  }
+  return lines.join("\n");
+}
+function pickFailedStep(options) {
+  if (options.verify && options.verify.exitCode !== 0) {
+    return {
+      step: {
+        type: "verify",
+        command: options.verify.command,
+        exitCode: options.verify.exitCode
+      },
+      rawDiagnostic: options.verify.stdout || `exit ${options.verify.exitCode}`
+    };
+  }
+  const fail = (options.ladderSteps ?? []).find((s) => !s.ok && s.step.kind !== "note");
+  if (fail) {
+    if (fail.step.kind === "command") {
+      return {
+        step: { type: "command", command: fail.step.command, detail: fail.message },
+        rawDiagnostic: fail.message
+      };
+    }
+    if (fail.step.kind === "syntax") {
+      return {
+        step: { type: "syntax", detail: fail.message },
+        rawDiagnostic: fail.message
+      };
+    }
+    return {
+      step: { type: "ladder", detail: fail.message },
+      rawDiagnostic: fail.message
+    };
+  }
+  return {
+    step: { type: "other", detail: "verification failed" },
+    rawDiagnostic: "verification failed (no diagnostic detail)"
+  };
+}
+function collectAffected(capsule, changedFiles, diagnostic) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (qualifiedName, file, reason) => {
+    const key = `${qualifiedName}|${file}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    out.push({ qualifiedName, file, reason });
+  };
+  for (const f of changedFiles) {
+    push(f, f, "modified this session");
+  }
+  if (capsule) {
+    for (const p of capsule.primary) {
+      if (changedFiles.includes(p.file) || diagnosticIncludes(diagnostic, p.file) || diagnosticIncludes(diagnostic, p.qualifiedName)) {
+        push(p.qualifiedName, p.file, "primary seed");
+      }
+    }
+    for (const p of capsule.supporting) {
+      if (changedFiles.includes(p.file) || diagnosticIncludes(diagnostic, p.file)) {
+        push(p.qualifiedName, p.file, "supporting seed");
+      }
+    }
+    if (!out.length) {
+      for (const p of capsule.primary.slice(0, 6)) push(p.qualifiedName, p.file, "primary seed");
+    }
+  }
+  return out;
+}
+function pickSourceSlices(capsule, affected, maxSlices) {
+  if (!capsule?.sourceSlices?.length) return [];
+  const files = new Set(affected.map((a) => a.file));
+  const preferred = capsule.sourceSlices.filter((s) => files.has(s.file));
+  const rest = capsule.sourceSlices.filter((s) => !files.has(s.file));
+  const picked = [...preferred, ...rest].slice(0, maxSlices);
+  return picked.map((s) => ({
+    file: s.file,
+    startLine: s.start,
+    endLine: s.end,
+    content: s.content,
+    contentHash: s.contentHash || hashString(s.content)
+  }));
+}
+function rankCorrections(failed, diagnostic, changedFiles) {
+  const hints = [];
+  const d = diagnostic.toLowerCase();
+  if (failed.step.type === "syntax") {
+    hints.push("Restore missing files or write non-empty content before re-verifying.");
+  }
+  if (/cannot find module|module not found|enoent/i.test(diagnostic)) {
+    hints.push("Check import paths and that new files were created where imports expect them.");
+  }
+  if (/typeerror|typescript|ts\d{4}/i.test(diagnostic)) {
+    hints.push("Fix the reported type error in the touched files; re-run the typecheck command.");
+  }
+  if (/assert|expect|fail(ed)?/i.test(d) && /test/.test(d)) {
+    hints.push("Align the implementation with the failing assertion; avoid changing the test unless the task requires it.");
+  }
+  if (/syntaxerror|unexpected token|parse error/i.test(diagnostic)) {
+    hints.push("Repair syntax around the last edit; re-read the file span before patching again.");
+  }
+  if (changedFiles.length) {
+    hints.push(`Re-read and patch: ${changedFiles.slice(0, 5).join(", ")}.`);
+  }
+  if (!hints.length) {
+    hints.push("Inspect the diagnostic excerpt, re-read the affected files, apply a minimal fix, then verify again.");
+  }
+  return hints.slice(0, 6);
+}
+function diagnosticIncludes(diagnostic, needle) {
+  if (!needle) return false;
+  return diagnostic.toLowerCase().includes(needle.toLowerCase());
+}
+function redactAndTrim(raw, max) {
+  let s = raw.replace(/(api[_-]?key|token|secret|password)\s*[:=]\s*\S+/gi, "$1=[REDACTED]").replace(/\b(sk|ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{8,}\b/g, "[REDACTED]").replace(/\bBearer\s+[A-Za-z0-9._\-]+\b/gi, "Bearer [REDACTED]");
+  if (s.length > max) {
+    const lines = s.split("\n");
+    const errorish = lines.filter((l) => /error|fail|assert|exception|enoent|cannot/i.test(l));
+    const head = (errorish.length ? errorish : lines).slice(0, 40).join("\n");
+    s = head.length > max ? head.slice(0, max) + "\n\u2026 (truncated)" : head + (lines.length > 40 ? "\n\u2026 (truncated)" : "");
+  }
+  return s.trim();
+}
+
+// src/code/verify-ladder.ts
+function compileVerificationLadder(plan, options = {}) {
+  const steps = [];
+  const maxSyntax = options.maxSyntaxFiles ?? 20;
+  for (const note of plan.notes) {
+    steps.push({ kind: "note", detail: note });
+  }
+  const syntaxFiles = [...new Set(plan.syntaxFiles.map(normalize4))].filter(Boolean).sort().slice(0, maxSyntax);
+  if (syntaxFiles.length) {
+    steps.push({
+      kind: "syntax",
+      files: syntaxFiles,
+      detail: `check ${syntaxFiles.length} target file(s) exist after edit`
+    });
+  }
+  const commands = /* @__PURE__ */ new Set();
+  for (const t of options.patchTargets ?? []) {
+    if (t.kind === "command" || t.kind === "test" || t.kind === "build" || t.kind === "typecheck") {
+      if (t.target.trim()) commands.add(t.target.trim());
+    }
+  }
+  if (options.testCommand?.trim()) commands.add(options.testCommand.trim());
+  for (const command of [...commands].sort()) {
+    steps.push({ kind: "command", command, detail: `run \`${command}\`` });
+  }
+  if (plan.suggestedTests.length) {
+    steps.push({
+      kind: "note",
+      detail: `graph-linked tests to prefer: ${plan.suggestedTests.slice(0, 8).join(", ")}`
+    });
+  }
+  return steps;
+}
+function runVerificationLadder(steps, options, failFast = true) {
+  const results = [];
+  let ranCommands = false;
+  let ok = true;
+  for (const step of steps) {
+    const result = runStep(step, options);
+    if (result.step.kind === "command" && options.runCommands !== false) ranCommands = true;
+    results.push(result);
+    if (!result.ok) {
+      ok = false;
+      if (failFast && step.kind !== "note") break;
+    }
+  }
+  return { ok, steps: results, ranCommands };
+}
+function runStep(step, options) {
+  if (step.kind === "note") {
+    return { step, ok: true, message: step.detail };
+  }
+  if (step.kind === "syntax") {
+    const missing = [];
+    const empty = [];
+    for (const file of step.files) {
+      const content = options.readFile(file);
+      if (content === null) missing.push(file);
+      else if (content.length === 0) empty.push(file);
+    }
+    if (missing.length || empty.length) {
+      const parts = [];
+      if (missing.length) parts.push(`missing: ${missing.join(", ")}`);
+      if (empty.length) parts.push(`empty: ${empty.join(", ")}`);
+      return { step, ok: false, message: `syntax check failed \u2014 ${parts.join("; ")}` };
+    }
+    return { step, ok: true, message: `syntax ok \u2014 ${step.files.length} file(s) present` };
+  }
+  if (options.runCommands === false || !options.run) {
+    return { step, ok: true, message: `skipped command (not configured): ${step.command}` };
+  }
+  const res = options.run(step.command);
+  if (res.exitCode === 0) {
+    return { step, ok: true, message: `\`${step.command}\` exit 0` };
+  }
+  const tail = (res.stdout ?? "").slice(0, 2e3);
+  return {
+    step,
+    ok: false,
+    message: `\`${step.command}\` exit ${res.exitCode}${tail ? `:
+${tail}` : ""}`
+  };
+}
+function normalize4(file) {
+  return file.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+
+// src/code/inspect-change.ts
+function inspectChange(graph, input = {}) {
+  const depth = input.depth ?? 3;
+  const maxRoots = input.maxRoots ?? 12;
+  const maxAffected = input.maxAffected ?? 40;
+  const filesTouched = [...new Set((input.files ?? []).map(normalize5).filter(Boolean))].sort();
+  const symbolHints = [...new Set((input.symbols ?? []).map((s) => s.trim()).filter(Boolean))];
+  const roots = collectRoots(graph, symbolHints, filesTouched).slice(0, maxRoots);
+  const affectedMap = /* @__PURE__ */ new Map();
+  let direct = 0;
+  let transitive = 0;
+  for (const root of roots) {
+    const imp = impactOf(graph, root.id, { depth });
+    direct += imp.direct;
+    transitive += imp.transitive;
+    for (const a of imp.affected) {
+      const prev = affectedMap.get(a.id);
+      if (!prev || a.depth < prev.depth || a.depth === prev.depth && a.confidence > prev.confidence) {
+        affectedMap.set(a.id, {
+          id: a.id,
+          name: a.name,
+          kind: a.kind,
+          file: a.file,
+          line: a.line,
+          depth: a.depth,
+          confidence: a.confidence,
+          viaRoot: root.qualifiedName
+        });
+      }
+    }
+  }
+  const affected = [...affectedMap.values()].sort((a, b) => a.depth - b.depth || b.confidence - a.confidence || a.name.localeCompare(b.name)).slice(0, maxAffected);
+  const report = {
+    roots,
+    affected,
+    direct,
+    transitive,
+    filesTouched,
+    rendered: ""
+  };
+  report.rendered = renderInspectChange(report);
+  return report;
+}
+function collectRoots(graph, symbols, files) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (id) => {
+    if (seen.has(id)) return;
+    const node = graph.nodes.find((n) => n.id === id);
+    if (!node || node.kind === "file" || node.kind === "external") return;
+    seen.add(id);
+    out.push({
+      id: node.id,
+      qualifiedName: node.qualifiedName,
+      kind: node.kind,
+      file: node.file,
+      line: node.span?.start ?? 0
+    });
+  };
+  for (const s of symbols) {
+    if (graph.nodes.some((n) => n.id === s)) {
+      push(s);
+      continue;
+    }
+    const hit = resolveOne(graph, s);
+    if (hit.node) push(hit.node.id);
+    else if (hit.candidates.length === 1 && hit.candidates[0]) push(hit.candidates[0].id);
+  }
+  for (const file of files) {
+    for (const n of graph.nodes) {
+      if (n.kind === "file" || n.kind === "external") continue;
+      if (normalize5(n.file) === file) push(n.id);
+    }
+  }
+  return out.sort((a, b) => a.file.localeCompare(b.file) || a.qualifiedName.localeCompare(b.qualifiedName));
+}
+function renderInspectChange(r) {
+  const lines = ["## Inspect change (blast radius)"];
+  if (r.filesTouched.length) lines.push(`Files: ${r.filesTouched.join(", ")}`);
+  if (!r.roots.length) {
+    lines.push("No graph symbols resolved for this change \u2014 impact unknown.");
+    return lines.join("\n");
+  }
+  lines.push(`Roots (${r.roots.length}):`);
+  for (const root of r.roots) {
+    lines.push(`- ${root.qualifiedName} (${root.kind}) ${root.file}:${root.line}`);
+  }
+  lines.push(`Affected: ${r.affected.length} (direct\u2248${r.direct}, transitive\u2248${r.transitive})`);
+  if (!r.affected.length) {
+    lines.push("Nothing depends on these symbols (safe to change in isolation).");
+  } else {
+    for (const a of r.affected.slice(0, 30)) {
+      lines.push(`- ${a.name} (${a.file}:${a.line}) d=${a.depth} via ${a.viaRoot}`);
+    }
+    if (r.affected.length > 30) lines.push(`\u2026 +${r.affected.length - 30} more`);
+  }
+  return lines.join("\n");
+}
+function normalize5(file) {
+  return file.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+
+// src/code/identifier-enforce.ts
+function stripNonCodeSpans(text) {
+  return text.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/\/\/[^\n]*/g, " ").replace(/(^|[^:])#[^\n]*/gm, "$1 ").replace(/'(?:\\.|[^'\\])*'/g, " ").replace(/"(?:\\.|[^"\\])*"/g, " ").replace(/`(?:\\.|[^`\\])*`/g, " ");
+}
+function enforceIdentifiersInText(text, trie, options = {}) {
+  if (!trie || text == null || text === "") return { ok: true, unknown: [] };
+  const codeOnly = options.codeOnly !== false;
+  const scanned = codeOnly ? stripNonCodeSpans(text) : text;
+  const scan = scanIdentifiersAgainstTrie(scanned, trie);
+  const allow = new Set(options.allow ?? []);
+  const unknown = scan.unknown.filter((id) => !allow.has(id));
+  if (unknown.length === 0) return { ok: true, unknown: [] };
+  return {
+    ok: false,
+    unknown,
+    reason: `blocked: ${unknown.length} identifier(s) not in the code graph: ${unknown.slice(0, 16).join(", ")}${unknown.length > 16 ? "\u2026" : ""}. Use only symbols from inspect_task / the graph, or add them before inventing names.`
+  };
+}
+function bodyFromOp(op) {
+  switch (op.op) {
+    case "replace-range":
+      return op.replacement;
+    case "replace-text":
+      return op.replace;
+    case "create-file":
+      return op.content;
+    case "replace-symbol":
+      return op.replacement;
+    case "delete-file":
+      return null;
+    default:
+      return null;
+  }
+}
+function fileFromOp(op) {
+  if ("file" in op && typeof op.file === "string") return op.file;
+  return null;
+}
+function enforceIdentifiersInPatch(patch, trie, options = {}) {
+  if (!trie) return { ok: true, unknown: [] };
+  const unknown = /* @__PURE__ */ new Set();
+  for (const op of patch.operations) {
+    const body = bodyFromOp(op);
+    if (!body) continue;
+    const allow = new Set(options.allow ?? []);
+    const file = fileFromOp(op);
+    if (file && options.readFile) {
+      const existing = options.readFile(file);
+      if (existing) {
+        for (const id of extractIdentifiers(existing)) allow.add(id);
+      }
+    }
+    if (op.op === "replace-text" && typeof op.search === "string") {
+      for (const id of extractIdentifiers(op.search)) allow.add(id);
+    }
+    const r = enforceIdentifiersInText(body, trie, { ...options, allow });
+    for (const u of r.unknown) unknown.add(u);
+  }
+  if (unknown.size === 0) return { ok: true, unknown: [] };
+  const list = [...unknown].sort();
+  return {
+    ok: false,
+    unknown: list,
+    reason: `blocked apply_patch: ${list.length} identifier(s) not in the code graph: ${list.slice(0, 16).join(", ")}${list.length > 16 ? "\u2026" : ""}. Do not invent symbols \u2014 use graph names only.`
+  };
+}
+
+// src/code/tools.ts
+var MAX_OUTPUT = 12e3;
+var AGENT_TOOLS = [
+  {
+    name: "search_code",
+    description: "Search the codebase by concept or identifier using the deterministic code graph (preferred over reading files blindly). Returns the most relevant symbols with file:line.",
+    parameters: { type: "object", properties: { query: { type: "string", description: 'What to find, e.g. "where auth failures are handled"' } }, required: ["query"] }
+  },
+  {
+    name: "read_file",
+    description: "Read a file (optionally a line range). Use after search_code to see the exact code.",
+    parameters: { type: "object", properties: { path: { type: "string" }, start_line: { type: "number" }, end_line: { type: "number" } }, required: ["path"] }
+  },
+  {
+    name: "list_files",
+    description: "List files known to the code map, optionally filtered by directory prefix and a simple substring/extension pattern.",
+    parameters: { type: "object", properties: { dir: { type: "string" }, pattern: { type: "string" } } }
+  },
+  {
+    name: "graph_impact",
+    description: "What depends on a symbol \u2014 the blast radius of changing it (callers/importers/subtypes). Use before editing shared code.",
+    parameters: { type: "object", properties: { symbol: { type: "string" } }, required: ["symbol"] }
+  },
+  {
+    name: "library_docs",
+    description: "Get version-correct documentation for a dependency this project actually uses (from the installed package), so you use the right API for the installed version. Prefer this over guessing a library's API.",
+    parameters: { type: "object", properties: { name: { type: "string", description: 'package name, e.g. "react" or "zod"' } }, required: ["name"] }
+  },
+  {
+    name: "edit_file",
+    description: "Edit a file by replacing an exact snippet. The SEARCH text must match current file contents (whitespace-flexible). Requires approval.",
+    parameters: { type: "object", properties: { path: { type: "string" }, search: { type: "string" }, replace: { type: "string" } }, required: ["path", "search", "replace"] }
+  },
+  {
+    name: "create_file",
+    description: "Create a new file with the given contents. Requires approval.",
+    parameters: { type: "object", properties: { path: { type: "string" }, content: { type: "string" } }, required: ["path", "content"] }
+  },
+  {
+    name: "delete_file",
+    description: "Delete a file. Requires approval.",
+    parameters: { type: "object", properties: { path: { type: "string" } }, required: ["path"] }
+  },
+  {
+    name: "apply_patch",
+    description: "Apply a validated PatchIR (patch-ir/0) multi-op edit transactionally. Prefer for multi-file changes with assumptions. JSON object with operations[], optional assumptions[]. Requires approval per file change.",
+    parameters: {
+      type: "object",
+      properties: {
+        patch: {
+          type: "object",
+          description: "PatchIR document: { operations: [...], assumptions?: [...] } (schemaVersion optional, defaults to patch-ir/0)"
+        }
+      },
+      required: ["patch"]
+    }
+  },
+  {
+    name: "run_command",
+    description: "Run a shell command (e.g. the test or build command) and read its output. Requires approval.",
+    parameters: { type: "object", properties: { command: { type: "string" } }, required: ["command"] }
+  },
+  {
+    name: "inspect_task",
+    description: "Return (or refresh) the current Task Capsule summary \u2014 primary symbols, source files, and verification plan. Prefer this over re-searching when capsule context is already available.",
+    parameters: { type: "object", properties: {} }
+  },
+  {
+    name: "inspect_change",
+    description: "Blast radius of a proposed change before (or after) editing \u2014 what depends on the symbols/files you will touch. Prefer before multi-file edits. Does not write files.",
+    parameters: {
+      type: "object",
+      properties: {
+        symbols: {
+          type: "array",
+          items: { type: "string" },
+          description: "Symbol ids or qualified names under change"
+        },
+        files: {
+          type: "array",
+          items: { type: "string" },
+          description: "Relative file paths under change (defaults to session dirty/changed files)"
+        },
+        depth: { type: "number", description: "Impact depth (default 3)" }
+      }
+    }
+  },
+  {
+    name: "verify_change",
+    description: "Run the graph-derived verification ladder (syntax + optional test command). On failure returns a Failure Capsule for focused repair. Read-only regarding files; may run the project test command.",
+    parameters: {
+      type: "object",
+      properties: {
+        command: { type: "string", description: "Optional verify command override (default: project test command from capsule plan)" }
+      }
+    }
+  },
+  {
+    name: "finish",
+    description: "Finish the task. Call this when the change is complete, with a short summary of what you did.",
+    parameters: { type: "object", properties: { summary: { type: "string" } }, required: ["summary"] }
+  },
+  {
+    name: "abort",
+    description: "Stop the task without further edits. Use when the request is impossible or the user intent is unclear.",
+    parameters: {
+      type: "object",
+      properties: { reason: { type: "string", description: "Why the task is aborted" } },
+      required: ["reason"]
+    }
+  }
+];
+async function executeTool(call, ctx) {
+  const a = call.arguments;
+  try {
+    switch (call.name) {
+      case "search_code":
+        return await search(ctx, str(a.query));
+      case "read_file":
+        return readFile(ctx, str(a.path), num(a.start_line), num(a.end_line));
+      case "list_files":
+        return listFiles(ctx, str(a.dir), str(a.pattern));
+      case "graph_impact":
+        return await graphImpact(ctx, str(a.symbol));
+      case "library_docs":
+        return libraryDocs(ctx, str(a.name));
+      case "edit_file":
+        return editFile(ctx, str(a.path), str(a.search), str(a.replace));
+      case "create_file":
+        return createFile(ctx, str(a.path), str(a.content));
+      case "delete_file":
+        return deleteFile(ctx, str(a.path));
+      case "apply_patch":
+        return applyPatchTool(ctx, a.patch);
+      case "run_command":
+        return runCommand(ctx, str(a.command));
+      case "inspect_task":
+        return inspectTask(ctx);
+      case "inspect_change":
+        return inspectChangeTool(ctx, a);
+      case "verify_change":
+        return verifyChange(ctx, str(a.command) || void 0);
+      case "finish":
+        return { content: "done", mutated: false, finished: true, finalSummary: str(a.summary) || "done" };
+      case "abort":
+        return {
+          content: `aborted: ${str(a.reason) || "no reason given"}`,
+          mutated: false,
+          finished: true,
+          finalSummary: `aborted: ${str(a.reason) || "no reason given"}`
+        };
+      default:
+        return { content: `unknown tool "${call.name}". Available: ${AGENT_TOOLS.map((t) => t.name).join(", ")}`, mutated: false };
+    }
+  } catch (e) {
+    return { content: `tool ${call.name} failed: ${e.message}`, mutated: false };
+  }
+}
+async function search(ctx, query) {
+  if (!query) return { content: "search_code needs a query", mutated: false };
+  const backend = ctx.graphBackend ?? localGraphBackend(ctx.graph);
+  const res = await backend.search(query, { limit: 10 });
+  if (res.matches.length === 0) return { content: `no symbols matched "${query}"`, mutated: false };
+  const lines = res.matches.map(
+    (m) => `- ${m.qualifiedName} (${m.kind}) ${m.file}:${m.line}${m.signature ? `  ${m.signature}` : ""}`
+  );
+  const via = res.source === "vgd" ? " via vgd" : "";
+  return { content: `Matches for "${query}"${via}:
+${lines.join("\n")}`, mutated: false };
+}
+function readFile(ctx, path2, start, end) {
+  if (isSecretPath(path2)) return { content: secretRefusal(path2), mutated: false };
+  const content = ctx.fsImpl.read(path2);
+  if (content === null) return { content: `${path2} not found`, mutated: false };
+  const lines = content.split("\n");
+  const from = start && start > 0 ? start - 1 : 0;
+  const to = end && end > 0 ? end : lines.length;
+  const slice = lines.slice(from, to).join("\n");
+  const shown = truncate(redactText(slice));
+  const header = start || end ? `${path2} (lines ${from + 1}-${Math.min(to, lines.length)} of ${lines.length})` : `${path2} (${lines.length} lines)`;
+  return { content: `${header}:
+${shown}`, mutated: false };
+}
+function listFiles(ctx, dir, pattern) {
+  const prefix = dir ? dir.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/$/, "") : "";
+  const files = [...new Set(ctx.graph.nodes.filter((n) => n.kind === "file").map((n) => n.file))].filter((f) => !isSecretPath(f)).filter((f) => prefix ? f === prefix || f.startsWith(prefix + "/") : true).filter((f) => pattern ? f.includes(pattern) || f.endsWith(pattern) : true).sort();
+  if (files.length === 0) return { content: `no files${dir ? ` under ${dir}` : ""}${pattern ? ` matching "${pattern}"` : ""}`, mutated: false };
+  return { content: `${files.length} file(s):
+${files.slice(0, 200).join("\n")}`, mutated: false };
+}
+function libraryDocs(ctx, name) {
+  if (!name) return { content: "library_docs needs a package name", mutated: false };
+  const entry = resolveLib(loadCatalog(ctx.root), name);
+  if (entry) {
+    const doc = readDoc(ctx.root, entry);
+    if (doc.trim()) return { content: `Docs for ${name}${entry.version && entry.version !== "*" ? ` @ ${entry.version}` : ""} (${entry.source.type}):
+${truncate(redactText(doc))}`, mutated: false };
+  }
+  const local = localPackageDocs(ctx.root, name);
+  if (local?.docs.trim()) {
+    return { content: `Docs for ${name}${local.version ? ` @ ${local.version}` : ""} (${local.source}):
+${truncate(redactText(local.docs))}`, mutated: false };
+  }
+  const v = resolveVersion(ctx.root, name);
+  return {
+    content: `no bundled docs for ${name}${v.served ? ` (installed ${v.served})` : " (not found in this project)"}. Read its source under node_modules/${name}, or add curated docs with \`vg lib add\`.`,
+    mutated: false
+  };
+}
+async function graphImpact(ctx, symbol) {
+  const backend = ctx.graphBackend ?? localGraphBackend(ctx.graph);
+  const impact = await backend.impact(symbol, { depth: 3 });
+  if (!impact) return { content: `no symbol named "${symbol}" in the map`, mutated: false };
+  if (impact.affected.length === 0) {
+    return {
+      content: `nothing depends on ${impact.root.name} (safe to change in isolation)`,
+      mutated: false
+    };
+  }
+  const lines = impact.affected.slice(0, 20).map((i) => `- ${i.name} (${i.file}:${i.line})`);
+  const via = impact.source === "vgd" ? " via vgd" : "";
+  return {
+    content: `${impact.affected.length} symbol(s) depend on ${impact.root.name}${via}:
+${lines.join("\n")}`,
+    mutated: false
+  };
+}
+async function editFile(ctx, path2, search2, replace) {
+  const before = ctx.fsImpl.read(path2);
+  if (ctx.enforceIdentifiers !== false && ctx.identifierTrie) {
+    const allow = /* @__PURE__ */ new Set([
+      ...extractIdentifiers(before ?? ""),
+      ...extractIdentifiers(search2)
+    ]);
+    const idCheck = enforceIdentifiersInText(replace, ctx.identifierTrie, { allow });
+    if (!idCheck.ok) {
+      return { content: idCheck.reason ?? "blocked: unknown identifiers in edit", mutated: false };
+    }
+  }
+  const { content: after, outcome } = applyEdit(before, { op: "replace", file: path2, search: search2, replace }, ctx.spans.get(normalize6(path2)) ?? []);
+  if (outcome.status !== "applied") {
+    return { content: `edit not applied (${outcome.status}): ${outcome.reason ?? ""}`, mutated: false };
+  }
+  const diff = unifiedDiff(before, after, path2);
+  if (!await ctx.approve({ kind: "edit", file: path2, diff })) {
+    return { content: `edit to ${path2} was declined by the user`, mutated: false };
+  }
+  ctx.fsImpl.write(path2, after ?? "");
+  return { content: `edited ${path2}`, mutated: true, change: { file: path2, before, after, outcomes: [outcome], diff } };
+}
+async function createFile(ctx, path2, content) {
+  if (ctx.enforceIdentifiers !== false && ctx.identifierTrie) {
+    const idCheck = enforceIdentifiersInText(content, ctx.identifierTrie);
+    if (!idCheck.ok) {
+      return { content: idCheck.reason ?? "blocked: unknown identifiers in create", mutated: false };
+    }
+  }
+  const existing = ctx.fsImpl.read(path2);
+  if (existing !== null) return { content: `${path2} already exists \u2014 use edit_file`, mutated: false };
+  if (!await ctx.approve({ kind: "create", file: path2, bytes: Buffer.byteLength(content) })) {
+    return { content: `creating ${path2} was declined by the user`, mutated: false };
+  }
+  ctx.fsImpl.write(path2, content);
+  return { content: `created ${path2}`, mutated: true, change: { file: path2, before: null, after: content, outcomes: [{ edit: { op: "create", file: path2, content }, status: "applied" }], diff: unifiedDiff(null, content, path2) } };
+}
+async function deleteFile(ctx, path2) {
+  const before = ctx.fsImpl.read(path2);
+  if (before === null) return { content: `${path2} does not exist`, mutated: false };
+  if (!await ctx.approve({ kind: "delete", file: path2 })) {
+    return { content: `deleting ${path2} was declined by the user`, mutated: false };
+  }
+  ctx.fsImpl.remove(path2);
+  return { content: `deleted ${path2}`, mutated: true, change: { file: path2, before, after: null, outcomes: [{ edit: { op: "delete", file: path2 }, status: "applied" }], diff: unifiedDiff(before, null, path2) } };
+}
+async function applyPatchTool(ctx, raw) {
+  const patch = coercePatchIR(raw);
+  if (!patch) {
+    return { content: "apply_patch needs a patch object with operations[] (patch-ir/0)", mutated: false };
+  }
+  const structural = validatePatchIR(patch);
+  if (!structural.ok) {
+    return { content: `invalid PatchIR: ${structural.errors.join("; ")}`, mutated: false };
+  }
+  if (ctx.enforceIdentifiers !== false && ctx.identifierTrie) {
+    const idCheck = enforceIdentifiersInPatch(patch, ctx.identifierTrie, {
+      readFile: (f) => ctx.fsImpl.read(f)
+    });
+    if (!idCheck.ok) {
+      return { content: idCheck.reason ?? "blocked: unknown identifiers", mutated: false };
+    }
+  }
+  const locate = locatorsFromGraph(ctx.graph.nodes);
+  const dry = applyPatchIR(patch, {
+    readFile: (f) => ctx.fsImpl.read(f),
+    spansForFile: (f) => ctx.spans.get(normalize6(f)) ?? [],
+    locateSymbol: locate,
+    transactional: true
+  });
+  if (!dry.ok) {
+    const detail = dry.errors.length ? dry.errors.join("; ") : dry.ops.map((o) => `${o.op}@${o.file}:${o.status}`).join("; ");
+    return { content: `patch not applied: ${detail}`, mutated: false };
+  }
+  const planned = [];
+  for (const [file, entry] of [...dry.files.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
+    if (entry.before === entry.after) continue;
+    if (isSecretPath(file)) return { content: secretRefusal(file), mutated: false };
+    const op = entry.after === null ? "delete" : entry.before === null ? "create" : "edit";
+    planned.push({
+      file,
+      op,
+      before: entry.before,
+      after: entry.after,
+      diff: unifiedDiff(entry.before, entry.after, file)
+    });
+  }
+  if (planned.length === 0) {
+    return { content: "patch applied with no content changes (no-op)", mutated: false };
+  }
+  const files = planned.map((p) => {
+    if (p.op === "delete") return { file: p.file, op: "delete", diff: p.diff };
+    if (p.op === "create") {
+      return { file: p.file, op: "create", bytes: Buffer.byteLength(p.after ?? ""), diff: p.diff };
+    }
+    return { file: p.file, op: "edit", diff: p.diff };
+  });
+  if (!await ctx.approve({ kind: "patch", files })) {
+    return {
+      content: `patch declined \u2014 ${planned.length} file change(s) refused (nothing written)`,
+      mutated: false
+    };
+  }
+  const changes = [];
+  for (const p of planned) {
+    const edit = p.after === null ? { op: "delete", file: p.file } : p.before === null ? { op: "create", file: p.file, content: p.after } : { op: "replace", file: p.file, search: "", replace: p.after };
+    changes.push({
+      file: p.file,
+      before: p.before,
+      after: p.after,
+      outcomes: [{ edit, status: "applied" }],
+      diff: p.diff
+    });
+    if (p.after === null) ctx.fsImpl.remove(p.file);
+    else ctx.fsImpl.write(p.file, p.after);
+  }
+  const summary = changes.map((c) => c.file).join(", ");
+  return {
+    content: `applied patch to ${changes.length} file(s): ${summary}`,
+    mutated: true,
+    change: changes[0]
+  };
+}
+function coercePatchIR(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const o = raw;
+  if (!Array.isArray(o.operations)) return null;
+  return {
+    schemaVersion: PATCH_IR_SCHEMA_VERSION,
+    operations: o.operations,
+    assumptions: Array.isArray(o.assumptions) ? o.assumptions : [],
+    requestedVerification: Array.isArray(o.requestedVerification) ? o.requestedVerification : [],
+    provenance: { format: "structured-json", modelId: null, raw: null }
+  };
+}
+async function runCommand(ctx, command) {
+  if (!command) return { content: "run_command needs a command", mutated: false };
+  if (ctx.auto) {
+    const reason = dangerousCommand(command, ctx.denyCommands);
+    if (reason) return { content: `refused to run \`${command}\` autonomously \u2014 ${reason}. Run it yourself if you intend to, or re-run without --auto to approve it interactively.`, mutated: false };
+  }
+  const enforceNet = ctx.enforceNetworkPolicy ?? !!ctx.auto;
+  const netReason = networkCommandRefusal(command, { enforce: enforceNet });
+  if (netReason) {
+    return { content: `refused to run \`${command}\` \u2014 ${netReason}`, mutated: false };
+  }
+  const secretReason = secretEgressRefusal(command, "shell command");
+  if (secretReason) {
+    return { content: `refused to run \`${command}\` \u2014 ${secretReason}`, mutated: false };
+  }
+  if (!await ctx.approve({ kind: "run", command })) {
+    return { content: `running \`${command}\` was declined by the user`, mutated: false };
+  }
+  const res = ctx.run(command);
+  return { content: `$ ${command}
+exit ${res.exitCode}
+${truncate(res.stdout)}`, mutated: true };
+}
+function inspectTask(ctx) {
+  const capsule = ctx.getTaskCapsule?.() ?? ctx.capsule ?? null;
+  if (!capsule) {
+    return {
+      content: "No Task Capsule for this run (metadata-only context). Re-run with --capsule, or use search_code / read_file to gather evidence.",
+      mutated: false
+    };
+  }
+  const summary = summarizeCapsule(capsule);
+  const lines = [
+    `Task Capsule ${summary.schemaVersion} \xB7 ranking ${summary.rankingVersion} \xB7 ~${summary.tokensEstimate} tokens`,
+    `Instruction: ${summary.instruction}`,
+    `Primary (${summary.primary.length}):`,
+    ...summary.primary.map((p) => `  - ${p.qualifiedName} (${p.kind}) ${p.file}`),
+    `Supporting (${summary.supporting.length}):`,
+    ...summary.supporting.slice(0, 8).map((p) => `  - ${p.qualifiedName} ${p.file}`),
+    `Source slices: ${summary.sourceSliceCount} across ${summary.sourceFiles.join(", ") || "(none)"}`,
+    `Verification files: ${capsule.verificationPlan.syntaxFiles.slice(0, 8).join(", ") || "(none)"}`
+  ];
+  if (capsule.provenance.modelProfileId) lines.push(`Model profile: ${capsule.provenance.modelProfileId}`);
+  if (capsule.provenance.securityTier) lines.push(`Security tier: ${capsule.provenance.securityTier}`);
+  return { content: lines.join("\n"), mutated: false };
+}
+function inspectChangeTool(ctx, args) {
+  const symbols = Array.isArray(args.symbols) ? args.symbols.filter((x) => typeof x === "string" && x.trim().length > 0) : [];
+  let files = Array.isArray(args.files) ? args.files.filter((x) => typeof x === "string" && x.trim().length > 0) : [];
+  if (!files.length) {
+    const dirty = ctx.dirtyFiles?.() ?? [];
+    const changed = ctx.changedFiles?.() ?? [];
+    files = [.../* @__PURE__ */ new Set([...dirty, ...changed])];
+  }
+  if (!symbols.length && !files.length) {
+    return {
+      content: 'inspect_change needs symbols[] or files[] (or session dirty/changed files). Example: { "files": ["src/auth.ts"] }',
+      mutated: false
+    };
+  }
+  const depth = typeof args.depth === "number" && args.depth > 0 ? args.depth : 3;
+  const report = inspectChange(ctx.graph, { symbols, files, depth });
+  return { content: report.rendered, mutated: false };
+}
+function verifyChange(ctx, commandOverride) {
+  const capsule = ctx.getTaskCapsule?.() ?? ctx.capsule ?? null;
+  if (!capsule) {
+    if (commandOverride) {
+      const res = ctx.run(commandOverride);
+      if (res.exitCode === 0) return { content: `verify ok \u2014 \`${commandOverride}\` exit 0`, mutated: false };
+      const fc2 = buildFailureCapsule({
+        verify: { command: commandOverride, exitCode: res.exitCode, stdout: res.stdout },
+        changedFiles: []
+      });
+      return { content: fc2.rendered, mutated: false };
+    }
+    return { content: "verify_change needs a Task Capsule or an explicit command", mutated: false };
+  }
+  const steps = compileVerificationLadder(capsule.verificationPlan, {
+    testCommand: commandOverride
+  });
+  const ladder = runVerificationLadder(steps, {
+    readFile: (f) => ctx.fsImpl.read(f),
+    run: ctx.run,
+    runCommands: true
+  });
+  if (ladder.ok) {
+    return {
+      content: `verification ladder passed:
+${ladder.steps.map((s) => `\u2714 ${s.message}`).join("\n")}`,
+      mutated: false
+    };
+  }
+  const fc = buildFailureCapsule({
+    ladderSteps: ladder.steps,
+    capsule,
+    changedFiles: []
+  });
+  return { content: fc.rendered, mutated: false };
+}
+function truncate(s) {
+  if (s.length <= MAX_OUTPUT) return s;
+  return s.slice(0, MAX_OUTPUT) + `
+\u2026 (truncated ${s.length - MAX_OUTPUT} chars)`;
+}
+function str(v) {
+  return typeof v === "string" ? v : v === void 0 || v === null ? "" : String(v);
+}
+function num(v) {
+  const n = typeof v === "number" ? v : typeof v === "string" ? Number(v) : NaN;
+  return Number.isFinite(n) ? n : void 0;
+}
+function normalize6(file) {
+  return file.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+
+// src/code/overlay.ts
+var SessionOverlay = class {
+  constructor(base) {
+    this.base = base;
+  }
+  base;
+  dirty = /* @__PURE__ */ new Map();
+  /** Paths with uncommitted writes or deletes (sorted). */
+  dirtyFiles() {
+    return [...this.dirty.keys()].sort();
+  }
+  /** True if the overlay has any uncommitted mutation. */
+  isDirty() {
+    return this.dirty.size > 0;
+  }
+  read(file) {
+    const key = normalize7(file);
+    const entry = this.dirty.get(key);
+    if (entry) {
+      if (entry.kind === "delete") return null;
+      return entry.content;
+    }
+    return this.base.read(file);
+  }
+  write(file, content) {
+    this.dirty.set(normalize7(file), { kind: "write", content });
+  }
+  remove(file) {
+    this.dirty.set(normalize7(file), { kind: "delete" });
+  }
+  appendAudit(line) {
+    this.base.appendAudit(line);
+  }
+  /**
+   * Commit every dirty entry to the base filesystem, then clear the overlay.
+   * Returns the paths flushed (sorted).
+   */
+  flush() {
+    const files = this.dirtyFiles();
+    for (const file of files) {
+      const entry = this.dirty.get(file);
+      if (entry.kind === "delete") this.base.remove(file);
+      else this.base.write(file, entry.content);
+    }
+    this.dirty.clear();
+    return files;
+  }
+  /** Drop uncommitted mutations without writing the base. */
+  discard() {
+    this.dirty.clear();
+  }
+  /**
+   * Snapshot of dirty entries for tests / diagnostics (path → entry).
+   * Does not include base-only files.
+   */
+  snapshot() {
+    return new Map(this.dirty);
+  }
+};
+function normalize7(file) {
+  return file.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+
+// src/code/trajectory.ts
+var TRAJECTORY_SCHEMA_VERSION = "trajectory/0";
+var DISCOVERY_TOOLS = /* @__PURE__ */ new Set([
+  "search_code",
+  "read_file",
+  "list_files",
+  "graph_impact",
+  "library_docs"
+]);
+var MUTATION_TOOLS = /* @__PURE__ */ new Set([
+  "edit_file",
+  "create_file",
+  "delete_file",
+  "apply_patch",
+  "run_command"
+]);
+function createTrajectoryCollector() {
+  const toolCalls = [];
+  let promptTokens = 0;
+  let completionTokens = 0;
+  let failureCapsuleBuilt = false;
+  return {
+    recordTool(name, step, mutated) {
+      toolCalls.push({ name, step, mutated });
+    },
+    recordUsage(p, c) {
+      promptTokens += p;
+      completionTokens += c;
+    },
+    markFailureCapsule() {
+      failureCapsuleBuilt = true;
+    },
+    finalize(input) {
+      const discoveryToolCalls = toolCalls.filter((t) => DISCOVERY_TOOLS.has(t.name)).length;
+      const mutationToolCalls = toolCalls.filter((t) => MUTATION_TOOLS.has(t.name)).length;
+      const shellCommands = toolCalls.filter((t) => t.name === "run_command").length;
+      const znsAt1 = computeZnsAt1({
+        solved: input.solved && input.verified,
+        usedCapsule: input.usedCapsule,
+        toolCalls
+      });
+      return {
+        schemaVersion: TRAJECTORY_SCHEMA_VERSION,
+        taskId: input.taskId,
+        arm: input.arm,
+        solved: input.solved,
+        verified: input.verified,
+        znsAt1,
+        steps: input.steps,
+        stopped: input.stopped,
+        inferenceTurns: input.inferenceTurns,
+        toolCalls,
+        discoveryToolCalls,
+        mutationToolCalls,
+        shellCommands,
+        promptTokens,
+        completionTokens,
+        elapsedMs: input.elapsedMs ?? null,
+        filesChanged: input.filesChanged,
+        usedCapsule: input.usedCapsule,
+        failureCapsuleBuilt,
+        provider: input.provider
+      };
+    }
+  };
+}
+function computeZnsAt1(input) {
+  if (!input.solved || !input.usedCapsule) return false;
+  return !input.toolCalls.some((t) => DISCOVERY_TOOLS.has(t.name));
+}
+function computeFcsReport(records) {
+  const byArm = {};
+  for (const arm of ["capsule", "oracle", "metadata", "other"]) {
+    const armRecs = records.filter((r) => r.arm === arm);
+    if (!armRecs.length && arm === "other") continue;
+    byArm[arm] = summarizeArm(armRecs);
+  }
+  const capsule = records.filter((r) => r.arm === "capsule");
+  const oracle = records.filter((r) => r.arm === "oracle");
+  const oracleSolvedIds = new Set(oracle.filter((r) => r.solved).map((r) => r.taskId));
+  const capsuleByTask = /* @__PURE__ */ new Map();
+  for (const r of capsule) {
+    const prev = capsuleByTask.get(r.taskId);
+    if (!prev || r.solved && !prev.solved) capsuleByTask.set(r.taskId, r);
+  }
+  const pairedIds = [...capsuleByTask.keys()].filter((id) => oracle.some((o) => o.taskId === id));
+  const oracleSolvedPaired = pairedIds.filter((id) => oracleSolvedIds.has(id));
+  const capsuleSolvedAmongOracle = oracleSolvedPaired.filter((id) => capsuleByTask.get(id)?.solved).length;
+  const fcs = oracleSolvedPaired.length > 0 ? round(capsuleSolvedAmongOracle / oracleSolvedPaired.length) : null;
+  const capsuleSolved = capsule.filter((r) => r.solved);
+  const znsAt1Rate = capsuleSolved.length > 0 ? round(capsuleSolved.filter((r) => r.znsAt1).length / capsuleSolved.length) : null;
+  return {
+    schemaVersion: "fcs-report/0",
+    fcs,
+    pairedTasks: pairedIds.length,
+    capsuleSolved: capsuleSolvedAmongOracle,
+    oracleSolved: oracleSolvedPaired.length,
+    znsAt1Rate,
+    capsuleRuns: capsule.length,
+    oracleRuns: oracle.length,
+    metadataRuns: records.filter((r) => r.arm === "metadata").length,
+    byArm,
+    records
+  };
+}
+function renderFcsReportMarkdown(report) {
+  const lines = [
+    "# Fusion trajectory / FCS report",
+    "",
+    `| Metric | Value |`,
+    `|---|---:|`,
+    `| FCS (capsule \xF7 oracle solves) | ${report.fcs == null ? "n/a (no oracle arm)" : report.fcs.toFixed(3)} |`,
+    `| ZNS@1 rate (capsule solves) | ${report.znsAt1Rate == null ? "n/a" : (report.znsAt1Rate * 100).toFixed(1) + "%"} |`,
+    `| Paired tasks | ${report.pairedTasks} |`,
+    `| Capsule runs | ${report.capsuleRuns} |`,
+    `| Oracle runs | ${report.oracleRuns} |`,
+    `| Metadata runs | ${report.metadataRuns} |`,
+    "",
+    "## Per arm",
+    "",
+    "| Arm | Runs | Solved | Pass rate | ZNS@1 | Discovery p50 | Steps p50 | Prompt tokens p50 |",
+    "|---|---:|---:|---:|---:|---:|---:|---:|"
+  ];
+  for (const [arm, s] of Object.entries(report.byArm)) {
+    if (!s.runs) continue;
+    lines.push(
+      `| ${arm} | ${s.runs} | ${s.solved} | ${(s.passRate * 100).toFixed(1)}% | ${s.znsAt1} | ${fmt(s.medianDiscovery)} | ${fmt(s.medianSteps)} | ${fmt(s.medianPromptTokens)} |`
+    );
+  }
+  lines.push(
+    "",
+    "## Definitions",
+    "",
+    "- **ZNS@1**: solved + verified from a Task Capsule with zero discovery tool calls (`search_code`, `read_file`, `list_files`, `graph_impact`, `library_docs`).",
+    "- **FCS**: among tasks the oracle arm solves, the fraction also solved under the capsule arm (same task ids)."
+  );
+  return lines.join("\n") + "\n";
+}
+function summarizeArm(recs) {
+  const solved = recs.filter((r) => r.solved).length;
+  return {
+    runs: recs.length,
+    solved,
+    passRate: recs.length ? round(solved / recs.length) : 0,
+    znsAt1: recs.filter((r) => r.znsAt1).length,
+    medianDiscovery: median(recs.map((r) => r.discoveryToolCalls)),
+    medianSteps: median(recs.map((r) => r.steps)),
+    medianPromptTokens: median(recs.map((r) => r.promptTokens))
+  };
+}
+function median(values) {
+  if (!values.length) return null;
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 ? sorted[mid] : round((sorted[mid - 1] + sorted[mid]) / 2);
+}
+function round(n) {
+  return Math.round(n * 1e3) / 1e3;
+}
+function fmt(n) {
+  return n == null ? "n/a" : String(n);
+}
+
+// src/code/run-provenance.ts
+var RUN_PROVENANCE_SCHEMA_VERSION = "run-provenance/0";
+var CONTEXT_POLICY_VERSION = "context-policy@2026.07.0";
+function mutationOp(before, after) {
+  if (before === null && after !== null) return "create";
+  if (before !== null && after === null) return "delete";
+  return "edit";
+}
+function hashMutation(change) {
+  const op = mutationOp(change.before, change.after);
+  return {
+    file: change.file,
+    op,
+    beforeHash: change.before === null ? null : hashString(change.before),
+    afterHash: change.after === null ? null : hashString(change.after),
+    diffHash: change.diff ? hashString(change.diff) : null
+  };
+}
+function buildRunProvenance(input = {}) {
+  const mutations = (input.changes ?? []).map(hashMutation).sort((a, b) => a.file.localeCompare(b.file) || a.op.localeCompare(b.op));
+  const verification = input.verification?.length ? input.verification.map((v) => ({
+    kind: v.kind,
+    command: v.command ?? null,
+    passed: !!v.passed,
+    diagnosticHash: v.diagnostic ? hashString(v.diagnostic.slice(0, 4e3)) : null
+  })).sort(
+    (a, b) => a.kind.localeCompare(b.kind) || (a.command ?? "").localeCompare(b.command ?? "") || Number(a.passed) - Number(b.passed)
+  ) : void 0;
+  return {
+    schemaVersion: RUN_PROVENANCE_SCHEMA_VERSION,
+    policyVersion: input.policyVersion ?? CONTEXT_POLICY_VERSION,
+    rankingVersion: input.rankingVersion ?? CAPSULE_RANKING_VERSION,
+    modelProfileId: input.modelProfileId ?? null,
+    securityTier: input.securityTier ?? null,
+    graphCorpusHash: input.graphCorpusHash ?? null,
+    mutations,
+    mutationsRootHash: hashString(canonicalize(mutations)),
+    ...verification ? {
+      verification,
+      verificationRootHash: hashString(canonicalize(verification))
+    } : { verificationRootHash: null }
+  };
+}
+
+// src/code/patch-ir-grammar.ts
+function patchIrGbnf() {
+  return String.raw`root ::= ws patch
+ws ::= [ \t\n]*
+patch ::= "{" ws
+  "\"schemaVersion\"" ws ":" ws "\"patch-ir/0\"" ws "," ws
+  "\"operations\"" ws ":" ws operations ws "," ws
+  "\"assumptions\"" ws ":" ws array-any ws "," ws
+  "\"requestedVerification\"" ws ":" ws array-any ws "," ws
+  "\"provenance\"" ws ":" ws provenance
+  ws "}"
+operations ::= "[" ws operation (ws "," ws operation)* ws "]"
+operation ::= replace-range | replace-text | create-file | delete-file | replace-symbol
+replace-range ::= "{" ws
+  "\"op\"" ws ":" ws "\"replace-range\"" ws "," ws
+  "\"file\"" ws ":" ws string ws "," ws
+  "\"start\"" ws ":" ws number ws "," ws
+  "\"end\"" ws ":" ws number ws "," ws
+  "\"replacement\"" ws ":" ws string
+  (ws "," ws "\"expectedHash\"" ws ":" ws (string | null) )?
+  (ws "," ws "\"anchorSymbol\"" ws ":" ws (string | null) )?
+  ws "}"
+replace-text ::= "{" ws
+  "\"op\"" ws ":" ws "\"replace-text\"" ws "," ws
+  "\"file\"" ws ":" ws string ws "," ws
+  "\"search\"" ws ":" ws string ws "," ws
+  "\"replace\"" ws ":" ws string
+  (ws "," ws "\"anchorSymbol\"" ws ":" ws (string | null) )?
+  ws "}"
+create-file ::= "{" ws
+  "\"op\"" ws ":" ws "\"create-file\"" ws "," ws
+  "\"file\"" ws ":" ws string ws "," ws
+  "\"content\"" ws ":" ws string
+  ws "}"
+delete-file ::= "{" ws
+  "\"op\"" ws ":" ws "\"delete-file\"" ws "," ws
+  "\"file\"" ws ":" ws string
+  ws "}"
+replace-symbol ::= "{" ws
+  "\"op\"" ws ":" ws "\"replace-symbol\"" ws "," ws
+  "\"symbolId\"" ws ":" ws string ws "," ws
+  "\"replacement\"" ws ":" ws string
+  (ws "," ws "\"file\"" ws ":" ws (string | null) )?
+  (ws "," ws "\"expectedHash\"" ws ":" ws (string | null) )?
+  ws "}"
+provenance ::= "{" ws
+  "\"format\"" ws ":" ws format
+  (ws "," ws "\"modelId\"" ws ":" ws (string | null) )?
+  (ws "," ws "\"raw\"" ws ":" ws (string | null) )?
+  ws "}"
+format ::= "\"search-replace\"" | "\"whole-file\"" | "\"structured-json\"" | "\"grammar-constrained\"" | "\"code-edit\""
+array-any ::= "[" ws (value (ws "," ws value)*)? ws "]"
+value ::= object | array-any | string | number | "true" | "false" | null
+object ::= "{" ws (string ws ":" ws value (ws "," ws string ws ":" ws value)*)? ws "}"
+string ::= "\"" (
+  [^"\\] |
+  "\\" (["\\/bfnrt] | "u" [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F])
+)* "\""
+number ::= "-"? ("0" | [1-9] [0-9]*) ("." [0-9]+)? ([eE] [+-]? [0-9]+)?
+null ::= "null"
+`;
+}
+function shouldUsePatchIrGrammar(profile) {
+  if (!profile) return false;
+  if (profile.constrainedDecoding) return true;
+  if (profile.toolCalling === "grammar") return true;
+  if (profile.editFormat === "patch_ir_json" && profile.constrainedDecoding !== false) {
+    return !!profile.constrainedDecoding;
+  }
+  return false;
+}
+
+// src/code/agent.ts
+var DEFAULT_MAX_STEPS = 24;
+var DEFAULT_CONTEXT_BUDGET = 16e3;
+var KEEP_ROUNDS = 8;
+var NUDGE_AT = 3;
+var STOP_AT = 5;
+async function runAgent(options) {
+  const { root, instruction, providers } = options;
+  let graph = options.graph;
+  const maxSteps = options.maxSteps ?? DEFAULT_MAX_STEPS;
+  const budget = options.budget ?? options.modelProfile?.capsuleBudgetTokens ?? 3e3;
+  const contextBudget = options.contextBudget ?? DEFAULT_CONTEXT_BUDGET;
+  const now = options.now ?? (() => 0);
+  const onEvent = options.onEvent ?? (() => {
+  });
+  const verifyConfig = options.verify && options.modelProfile?.maxRepairRounds != null && options.verify.maxRounds == null ? { ...options.verify, maxRounds: options.modelProfile.maxRepairRounds } : options.verify;
+  const identifierTrie = options.identifierMask === false ? void 0 : buildIdentifierTrieFromGraph(graph);
+  const kvRegistry = new KvBlockRegistry();
+  const draftCandidates = graphDraftCandidates(
+    graph.nodes.flatMap((n) => [n.signature, n.qualifiedName, n.name].filter(Boolean)).filter((s) => s.includes("(") || s.includes("function") || s.includes("class") || s.length > 12),
+    12
+  );
+  const useWorktree = options.worktreeOverlay === true;
+  if (useWorktree) {
+    try {
+      const wt = await materializeWorktreeGraph(graph, root);
+      if (wt.reparsed.length || wt.deleted.length) {
+        graph = wt.graph;
+        onEvent({
+          type: "session-graph",
+          reparsed: wt.reparsed.length,
+          dirty: wt.dirtyFiles.length
+        });
+      }
+    } catch {
+    }
+  }
+  const useOverlay = options.overlay ?? !!options.capsule;
+  const overlay = useOverlay ? new SessionOverlay(options.fsImpl) : null;
+  const fsImpl = overlay ?? options.fsImpl;
+  const flushOverlay = () => {
+    overlay?.flush();
+  };
+  const advancedMode = options.advancedMode ?? !options.capsule;
+  const discoveryGate = createDiscoveryGateState();
+  const allTools = [...AGENT_TOOLS, ...options.externalTools?.specs ?? []];
+  const built = buildAgentContext(graph, instruction, { ...options, fsImpl, budget });
+  const context = built.context;
+  let capsule = built.capsule;
+  const useLadder = options.verifyLadder ?? !!capsule;
+  const messages = buildAgentMessages(context);
+  if (options.priorSummary) {
+    messages.push({ role: "user", content: options.priorSummary });
+  }
+  if (options.testCommand) {
+    messages.push({ role: "user", content: `When you want to verify a change, the project's test command is: \`${options.testCommand}\`` });
+  }
+  const spans = buildSpanIndex(graph);
+  const changes = [];
+  const repeats = /* @__PURE__ */ new Map();
+  let recordedSearch = false;
+  let commandCount = 0;
+  let verifyRounds = verifyConfig?.maxRounds ?? 2;
+  let lastVerifyPassed = true;
+  let lastVerification = [];
+  let lastFailureCapsule = null;
+  const usage = { promptTokens: 0, completionTokens: 0 };
+  let providerInfo = { id: providers[0]?.id ?? "none", model: providers[0]?.model ?? "", fellBack: false };
+  const trajectory = createTrajectoryCollector();
+  let currentStep = 0;
+  const capsuleSummary = capsule ? summarizeCapsule(capsule) : null;
+  if (capsuleSummary) onEvent({ type: "capsule", summary: capsuleSummary });
+  const runShell = (command) => {
+    if (options.executionEnv) return options.executionEnv.run(command, { cwd: root });
+    return options.run(command);
+  };
+  const ctx = {
+    root,
+    graph,
+    fsImpl,
+    spans,
+    run: runShell,
+    approve: options.approve,
+    auto: options.auto,
+    denyCommands: options.denyCommands,
+    capsule,
+    getTaskCapsule: () => capsule,
+    graphBackend: options.graphBackend,
+    dirtyFiles: () => overlay ? overlay.dirtyFiles() : [],
+    changedFiles: () => changes.map((c) => c.file),
+    // B3: enforce-before-apply against the live graph trie.
+    identifierTrie: identifierTrie ?? null,
+    enforceIdentifiers: options.identifierMask !== false
+  };
+  const refreshSessionGraph = async () => {
+    if (!overlay || !overlay.isDirty()) return;
+    try {
+      const session = await materializeSessionGraph(graph, overlay);
+      ctx.graph = session.graph;
+      ctx.graphBackend = localGraphBackend(session.graph);
+      if (options.identifierMask !== false) {
+        ctx.identifierTrie = buildIdentifierTrieFromGraph(session.graph);
+      }
+      const next = buildSpanIndex(session.graph);
+      ctx.spans.clear();
+      for (const [k, v] of next) ctx.spans.set(k, v);
+      onEvent({ type: "session-graph", reparsed: session.reparsed.length, dirty: session.deleted.length + session.rewritten.length });
+      if (options.capsule && capsule) {
+        try {
+          const nextCapsule = buildTaskCapsule(session.graph, instruction, {
+            budget,
+            files: options.files,
+            readFile: (rel) => fsImpl.read(rel),
+            repositoryId: repositoryIdFromRoot(root),
+            provenance: {
+              modelProfileId: options.modelProfile?.id ?? null,
+              securityTier: options.executionEnv?.tier ?? options.modelProfile?.securityTier ?? null
+            }
+          });
+          const delta = buildCapsuleDelta(capsule, nextCapsule);
+          capsule = nextCapsule;
+          ctx.capsule = nextCapsule;
+          if (!isEmptyCapsuleDelta(delta)) {
+            onEvent({ type: "capsule-delta", delta });
+            messages.push({ role: "user", content: delta.rendered.slice(0, 6e3) });
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  };
+  const emitFailure = (fc) => {
+    lastFailureCapsule = fc;
+    trajectory.markFailureCapsule();
+    onEvent({ type: "failure-capsule", capsule: fc });
+  };
+  const finish = (stopped, finalText, steps) => {
+    flushOverlay();
+    const solved = stopped === "finished" && lastVerifyPassed;
+    const traj = trajectory.finalize({
+      taskId: options.attribution?.client ? `${options.attribution.client}:${instruction.slice(0, 40)}` : instruction.slice(0, 48),
+      arm: capsule ? "capsule" : "metadata",
+      solved,
+      verified: lastVerifyPassed,
+      steps,
+      stopped,
+      inferenceTurns: currentStep || steps,
+      filesChanged: changes.length,
+      usedCapsule: !!capsule,
+      provider: { id: providerInfo.id, model: providerInfo.model }
+    });
+    const metrics = {
+      discoveryToolCalls: traj.discoveryToolCalls,
+      mutationToolCalls: traj.mutationToolCalls,
+      shellCommands: traj.shellCommands,
+      znsAt1: traj.znsAt1,
+      usedCapsule: !!capsule,
+      failureCapsuleBuilt: traj.failureCapsuleBuilt,
+      trajectory: traj
+    };
+    onEvent({ type: "metrics", metrics });
+    const result = {
+      finalText,
+      changes,
+      steps,
+      stopped,
+      provider: providerInfo,
+      usage,
+      metrics,
+      failureCapsule: lastFailureCapsule,
+      capsuleSummary: capsule ? summarizeCapsule(capsule) : capsuleSummary,
+      provenance: buildRunProvenance({
+        modelProfileId: options.modelProfile?.id ?? capsule?.provenance.modelProfileId ?? null,
+        securityTier: options.executionEnv?.tier ?? options.modelProfile?.securityTier ?? capsule?.provenance.securityTier ?? null,
+        graphCorpusHash: capsule?.provenance.graphCorpusHash ?? graph.provenance?.corpusHash ?? null,
+        rankingVersion: capsule?.provenance.rankingVersion ?? CAPSULE_RANKING_VERSION,
+        policyVersion: capsule?.provenance.policyVersion ?? CONTEXT_POLICY_VERSION,
+        changes,
+        verification: lastVerification
+      })
+    };
+    if (!options.noAudit) {
+      writeAgentAudit(
+        options.fsImpl,
+        {
+          instruction,
+          providerInfo,
+          changes,
+          commandCount,
+          steps,
+          stopped,
+          provenance: result.provenance
+        },
+        now()
+      );
+    }
+    return result;
+  };
+  const verifyOnFinish = () => {
+    if (changes.length === 0) return "done";
+    if (useLadder && capsule) {
+      const steps = compileVerificationLadder(capsule.verificationPlan, {
+        testCommand: verifyConfig?.command ?? options.testCommand
+      });
+      flushOverlay();
+      const ladder = runVerificationLadder(steps, {
+        readFile: (f) => options.fsImpl.read(f),
+        run: runShell,
+        // Prefer the dedicated verify command path below when both are set, so we
+        // don't double-run the same test command.
+        runCommands: !verifyConfig?.command
+      });
+      const summary = ladder.steps.map((s) => `${s.ok ? "\u2714" : "\u2717"} ${s.message}`).join("\n");
+      onEvent({ type: "ladder", ok: ladder.ok, summary });
+      lastVerification = ladder.steps.map((s) => ({
+        kind: s.step?.kind ?? "ladder",
+        command: s.step && "command" in s.step ? s.step.command ?? null : null,
+        passed: !!s.ok,
+        diagnostic: s.message ?? null
+      }));
+      if (!ladder.ok) {
+        lastVerifyPassed = false;
+        const fc2 = buildFailureCapsule({
+          ladderSteps: ladder.steps,
+          capsule,
+          changedFiles: changes.map((c) => c.file),
+          modelId: providerInfo.model,
+          policyVersion: CONTEXT_POLICY_VERSION
+        });
+        emitFailure(fc2);
+        if (verifyRounds <= 0) return "done";
+        verifyRounds--;
+        messages.push({
+          role: "user",
+          content: `The task isn't finished \u2014 verification ladder failed.
+
+${fc2.rendered.slice(0, 8e3)}
+
+Fix the issues, then call finish again.${verifyRounds === 0 ? " (last verification attempt)" : ""}`
+        });
+        return "retry";
+      }
+    }
+    const v = verifyConfig;
+    if (!v || verifyRounds <= 0) {
+      lastVerifyPassed = true;
+      return "done";
+    }
+    flushOverlay();
+    const res = runShell(v.command);
+    onEvent({ type: "verify", command: v.command, passed: res.exitCode === 0 });
+    lastVerification = [
+      ...lastVerification,
+      {
+        kind: "command",
+        command: v.command,
+        passed: res.exitCode === 0,
+        diagnostic: res.stdout?.slice(0, 4e3) ?? null
+      }
+    ];
+    if (res.exitCode === 0) {
+      lastVerifyPassed = true;
+      return "done";
+    }
+    lastVerifyPassed = false;
+    const fc = buildFailureCapsule({
+      verify: { command: v.command, exitCode: res.exitCode, stdout: res.stdout },
+      capsule,
+      changedFiles: changes.map((c) => c.file),
+      modelId: providerInfo.model,
+      policyVersion: CONTEXT_POLICY_VERSION
+    });
+    emitFailure(fc);
+    verifyRounds--;
+    messages.push({
+      role: "user",
+      content: `The task isn't finished \u2014 \`${v.command}\` failed (exit ${res.exitCode}).
+
+${fc.rendered.slice(0, 8e3)}
+
+Fix the failing tests, then call finish again.${verifyRounds === 0 ? " (last verification attempt)" : ""}`
+    });
+    return "retry";
+  };
+  for (let step = 1; step <= maxSteps; step++) {
+    currentStep = step;
+    onEvent({ type: "step", n: step });
+    const compacted = compact(messages, contextBudget, changes);
+    if (compacted.droppedRounds > 0) {
+      messages.length = 0;
+      messages.push(...compacted.messages);
+      onEvent({ type: "compact", droppedRounds: compacted.droppedRounds });
+    }
+    let result;
+    try {
+      if (kvRegistry.size() === 0 && messages.length >= 2) {
+        kvRegistry.commit(
+          messages.slice(0, Math.min(3, messages.length)).map((m, i) => ({
+            kind: i === 0 ? "system" : "context",
+            text: typeof m.content === "string" ? m.content : ""
+          }))
+        );
+      }
+      const promptSegments = messages.map((m, i) => ({
+        kind: m.role === "system" ? "system" : i < 3 ? "context" : m.role === "user" ? "user" : "assistant",
+        text: typeof m.content === "string" ? m.content : ""
+      }));
+      const c = await complete(
+        providers,
+        messages,
+        allTools,
+        onEvent,
+        options.stream,
+        options.modelProfile,
+        identifierTrie,
+        draftCandidates,
+        promptSegments
+      );
+      result = c.result;
+      providerInfo = { id: c.provider.id, model: c.provider.model, fellBack: c.fellBack };
+    } catch (e) {
+      const msg = redactSecrets(e.message);
+      onEvent({ type: "assistant", text: `error: ${msg}` });
+      return finish("error", msg, step);
+    }
+    if (result.usage) {
+      usage.promptTokens += result.usage.promptTokens ?? 0;
+      usage.completionTokens += result.usage.completionTokens ?? 0;
+      trajectory.recordUsage(result.usage.promptTokens ?? 0, result.usage.completionTokens ?? 0);
+      onEvent({ type: "usage", promptTokens: result.usage.promptTokens ?? 0, completionTokens: result.usage.completionTokens ?? 0 });
+    }
+    if (result.text) onEvent({ type: "assistant", text: result.text });
+    const toolCalls = result.toolCalls ?? [];
+    if (toolCalls.length === 0) {
+      messages.push({ role: "assistant", content: result.text });
+      return finish("no-tools", result.text, step);
+    }
+    messages.push({ role: "assistant", content: result.text, toolCalls });
+    for (const call of toolCalls) {
+      onEvent({ type: "tool-call", name: call.name, args: call.arguments });
+      if (call.name === "search_code" && options.attribution?.client && !recordedSearch) {
+        recordedSearch = true;
+        recordSearchSaving(root, context, options.attribution, now());
+      }
+      if (call.name === "run_command") flushOverlay();
+      if (!options.externalTools?.owns(call.name)) {
+        const gate = gateDiscoveryTool(call.name, discoveryGate, { advancedMode });
+        if (!gate.allow) {
+          const blocked = { content: gate.reason};
+          onEvent({ type: "tool-result", name: call.name, content: blocked.content, mutated: false });
+          messages.push({ role: "tool", content: blocked.content, toolCallId: call.id, name: call.name });
+          continue;
+        }
+        if (gate.note) {
+          call.__gateNote = gate.note;
+        }
+      }
+      const toolResult = options.externalTools?.owns(call.name) ? await options.externalTools.execute(call) : await executeTool(call, ctx);
+      if (!options.externalTools?.owns(call.name)) {
+        recordDiscoveryGateOutcome(call.name, discoveryGate, { mutated: toolResult.mutated });
+      }
+      const gateNote = call.__gateNote;
+      if (gateNote) toolResult.content = `${toolResult.content}
+
+${gateNote}`;
+      if (call.name === "run_command" && toolResult.mutated) commandCount++;
+      if (toolResult.change) {
+        changes.push(toolResult.change);
+        onEvent({ type: "change", change: toolResult.change });
+      }
+      if (toolResult.mutated && !toolResult.finished) {
+        await refreshSessionGraph();
+      }
+      const sig = `${call.name}:${stableArgs(call.arguments)}`;
+      let content = toolResult.content;
+      let stopNoProgress = false;
+      if (toolResult.mutated || toolResult.finished) {
+        repeats.delete(sig);
+      } else {
+        const n = (repeats.get(sig) ?? 0) + 1;
+        repeats.set(sig, n);
+        if (n >= STOP_AT) stopNoProgress = true;
+        else if (n >= NUDGE_AT) content += `
+
+(note: you have called this exact tool call ${n} times with no change \u2014 try a different approach, read more context, or call finish.)`;
+      }
+      trajectory.recordTool(call.name, step, toolResult.mutated);
+      onEvent({ type: "tool-result", name: call.name, content, mutated: toolResult.mutated });
+      messages.push({ role: "tool", content, toolCallId: call.id, name: call.name });
+      if (toolResult.finished) {
+        if (verifyOnFinish() === "retry") break;
+        return finish("finished", toolResult.finalSummary ?? "done", step);
+      }
+      if (stopNoProgress) return finish("no-progress", `stopped: the model repeated \`${call.name}\` without making progress`, step);
+    }
+  }
+  return finish("max-steps", "reached the step limit before finishing", maxSteps);
+}
+async function complete(providers, messages, tools, onEvent, stream, modelProfile, identifierTrie, draftCandidates, promptSegments) {
+  if (providers.length === 0) throw new Error("no model provider available");
+  const onToken = stream ? (t) => onEvent({ type: "token", text: t }) : void 0;
+  const grammar = shouldUsePatchIrGrammar(modelProfile) ? patchIrGbnf() : void 0;
+  const requireGrammar = !!(grammar && modelProfile?.constrainedDecoding && providers.some((p) => p.id === "llama-cpp"));
+  let lastErr;
+  for (let i = 0; i < providers.length; i++) {
+    try {
+      const result = await providers[i].chat(messages, {
+        temperature: 0,
+        tools,
+        stream,
+        onToken,
+        grammar,
+        // Only require grammar on the llama-cpp provider; HTTP providers ignore it.
+        requireGrammar: requireGrammar && providers[i].id === "llama-cpp",
+        identifierTrie,
+        draftCandidates,
+        promptSegments
+      });
+      return { result, provider: providers[i], fellBack: i > 0 };
+    } catch (e) {
+      lastErr = e;
+    }
+  }
+  throw new Error(lastErr instanceof Error ? redactSecrets(lastErr.message) : String(lastErr));
+}
+function compact(messages, budget, changes) {
+  if (estimateTokens(messages) <= budget) return { messages, droppedRounds: 0 };
+  const head = messages.slice(0, 3);
+  const body = messages.slice(3);
+  const rounds = [];
+  for (const m of body) {
+    if (m.role === "assistant" || rounds.length === 0) rounds.push([m]);
+    else rounds[rounds.length - 1].push(m);
+  }
+  if (rounds.length <= KEEP_ROUNDS) return { messages, droppedRounds: 0 };
+  const dropped = rounds.slice(0, rounds.length - KEEP_ROUNDS);
+  const kept = rounds.slice(-KEEP_ROUNDS).flat();
+  const toolCalls = dropped.flat().reduce((n, m) => n + (m.role === "assistant" ? m.toolCalls?.length ?? 0 : 0), 0);
+  const filesChanged = [...new Set(changes.map((c) => c.file))];
+  const note = {
+    role: "user",
+    content: `[earlier steps summarized to save context: ${dropped.length} round(s), ${toolCalls} tool call(s) omitted.${filesChanged.length ? ` Files changed so far: ${filesChanged.join(", ")}.` : ""} Continue the task.]`
+  };
+  return { messages: [...head, note, ...kept], droppedRounds: dropped.length };
+}
+function buildAgentContext(graph, instruction, options) {
+  const budget = options.budget ?? 3e3;
+  const files = options.files;
+  if (!options.capsule) {
+    return { context: buildCodeContext(graph, instruction, { budget, files }), capsule: null };
+  }
+  const capsule = buildTaskCapsule(graph, instruction, {
+    budget,
+    files,
+    readFile: (rel) => options.fsImpl.read(rel),
+    repositoryId: repositoryIdFromRoot(options.root),
+    extraPinnedFacts: options.extraPinnedFacts,
+    provenance: {
+      modelProfileId: options.modelProfile?.id ?? null,
+      securityTier: options.executionEnv?.tier ?? options.modelProfile?.securityTier ?? null,
+      policyVersion: CONTEXT_POLICY_VERSION
+    }
+  });
+  return { context: capsuleToCodeContext(capsule), capsule };
+}
+function recordSearchSaving(root, context, attribution, ts) {
+  const files = new Set(context.seeds.map((s) => s.node.file).filter(Boolean));
+  recordCliCall(
+    root,
+    {
+      tool: CLI_TOOL_ALIASES.ask,
+      client: attribution.client,
+      provider: attribution.provider,
+      model: attribution.model,
+      outcome: context.seeds.length ? "complete" : "miss",
+      vgTokens: context.tokensEstimate,
+      baselineFiles: files.size
+    },
+    ts
+  );
+}
+function writeAgentAudit(fsImpl, rec, ts) {
+  try {
+    fsImpl.appendAudit(
+      JSON.stringify({
+        ts,
+        kind: "agent",
+        instruction: rec.instruction.slice(0, 500),
+        provider: rec.providerInfo.id,
+        model: rec.providerInfo.model,
+        steps: rec.steps,
+        stopped: rec.stopped,
+        commands: rec.commandCount,
+        files: rec.changes.map((c) => ({ file: c.file, statuses: c.outcomes.map((o) => o.status) })),
+        // Content hashes only — never file bodies or secrets.
+        provenance: rec.provenance ? {
+          schemaVersion: rec.provenance.schemaVersion,
+          policyVersion: rec.provenance.policyVersion,
+          rankingVersion: rec.provenance.rankingVersion,
+          modelProfileId: rec.provenance.modelProfileId,
+          securityTier: rec.provenance.securityTier,
+          graphCorpusHash: rec.provenance.graphCorpusHash,
+          mutationsRootHash: rec.provenance.mutationsRootHash,
+          verificationRootHash: rec.provenance.verificationRootHash ?? null,
+          mutationCount: rec.provenance.mutations.length,
+          verificationCount: rec.provenance.verification?.length ?? 0
+        } : void 0
+      })
+    );
+  } catch {
+  }
+}
+function stableArgs(args) {
+  const keys = Object.keys(args).sort();
+  return JSON.stringify(keys.map((k) => [k, args[k]]));
+}
+function estimateTokens(messages) {
+  let chars = 0;
+  for (const m of messages) {
+    chars += m.content.length;
+    if (m.role === "assistant" && m.toolCalls) chars += JSON.stringify(m.toolCalls).length;
+  }
+  return Math.ceil(chars / 4);
+}
+function buildSpanIndex(graph) {
+  const map = /* @__PURE__ */ new Map();
+  for (const n of graph.nodes) {
+    if (n.kind === "file" || n.kind === "external") continue;
+    const file = n.file.replace(/\\/g, "/").replace(/^\.\//, "");
+    const list = map.get(file) ?? [];
+    list.push({ qualifiedName: n.qualifiedName, file, start: n.span.start, end: n.span.end });
+    map.set(file, list);
+  }
+  return map;
+}
+
+export { CONTEXT_POLICY_VERSION, computeFcsReport, createTrajectoryCollector, renderFcsReportMarkdown, runAgent };
+//# sourceMappingURL=chunk-3BVSDMHV.js.map
+//# sourceMappingURL=chunk-3BVSDMHV.js.map