veefore 1.4.1 → 1.6.0

package/dist/veefore.mjs

@@ -236,29 +236,29 @@ var ApiClient = class {
   setToken(token) {
     this.token = token;
   }
-  async get(path13, query = {}) {
+  async get(path14, query = {}) {
     const search = new URLSearchParams();
     for (const [key, value] of Object.entries(query)) {
       if (value !== void 0) search.set(key, String(value));
     }
     const suffix = search.toString() === "" ? "" : `?${search.toString()}`;
-    return this.send("GET", `${path13}${suffix}`);
+    return this.send("GET", `${path14}${suffix}`);
   }
-  async post(path13, body) {
-    return this.send("POST", path13, body);
+  async post(path14, body) {
+    return this.send("POST", path14, body);
   }
-  async patch(path13, body) {
-    return this.send("PATCH", path13, body);
+  async patch(path14, body) {
+    return this.send("PATCH", path14, body);
   }
-  async delete(path13) {
-    return this.send("DELETE", path13);
+  async delete(path14) {
+    return this.send("DELETE", path14);
   }
   /** Raw request for endpoints that return a non-JSON body (exports). */
-  async raw(method, path13, body) {
-    return this.fetchWithTimeout(method, path13, body);
+  async raw(method, path14, body) {
+    return this.fetchWithTimeout(method, path14, body);
   }
-  async send(method, path13, body) {
-    const response = await this.fetchWithTimeout(method, path13, body);
+  async send(method, path14, body) {
+    const response = await this.fetchWithTimeout(method, path14, body);
     const text = await response.text();
     const parsed = parseJson(text);
     if (response.ok) {
@@ -266,14 +266,14 @@ var ApiClient = class {
       if (parsed && "data" in parsed) return parsed.data;
       throw new CliApiError(
         "UNEXPECTED_RESPONSE",
-        `The control plane returned an unexpected body for ${method} ${path13}.`,
+        `The control plane returned an unexpected body for ${method} ${path14}.`,
         response.status,
         response.headers.get("x-request-id")
       );
     }
     const error = new CliApiError(
       parsed?.error?.code ?? `HTTP_${response.status}`,
-      parsed?.error?.message ?? `${method} ${path13} failed with ${response.status} ${response.statusText}.`,
+      parsed?.error?.message ?? `${method} ${path14} failed with ${response.status} ${response.statusText}.`,
       response.status,
       parsed?.error?.request_id ?? response.headers.get("x-request-id"),
       parsed?.error?.details ?? {}
@@ -291,7 +291,7 @@ var ApiClient = class {
     }
     throw error;
   }
-  async fetchWithTimeout(method, path13, body) {
+  async fetchWithTimeout(method, path14, body) {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), this.timeoutMs);
     const headers = { accept: "application/json" };
@@ -300,7 +300,7 @@ var ApiClient = class {
     if (this.workspaceId) headers["x-veefore-workspace"] = this.workspaceId;
     if (this.environmentId) headers["x-veefore-environment"] = this.environmentId;
     try {
-      return await fetch(`${this.controlPlaneUrl}${path13}`, {
+      return await fetch(`${this.controlPlaneUrl}${path14}`, {
         method,
         headers,
         body: body === void 0 ? void 0 : JSON.stringify(body),
@@ -1030,6 +1030,97 @@ async function select(question, real, settings = {}) {
     draw();
   });
 }
+async function selectMany(question, options, settings = {}) {
+  if (options.length === 0) return [];
+  const ticked = options.map((option) => settings.selected?.(option) ?? true);
+  if (!isInteractive()) return options.filter((_, index) => ticked[index]).map((o) => o.value);
+  flushCapture();
+  let cursor = 0;
+  let rendered = 0;
+  const stdin = process.stdin;
+  const stdout = process.stdout;
+  const labelWidth = Math.max(...options.map((option) => [...option.label].length));
+  const draw = () => {
+    const width = columns();
+    const count = ticked.filter(Boolean).length;
+    const lines = [];
+    lines.push(
+      `${brand("?")} ${style.bold(question)} ${style.grey(`(${count}/${options.length})`)}`
+    );
+    if (settings.help) lines.push(`  ${style.grey(settings.help)}`);
+    const room = Math.max(3, (process.stdout.rows || 24) - lines.length - 3);
+    const window = Math.min(options.length, room);
+    let first = Math.max(0, Math.min(cursor - (window >> 1), options.length - window));
+    if (window === options.length) first = 0;
+    if (first > 0) lines.push(style.grey(`    \u2191 ${first} more`));
+    for (let index = first; index < first + window; index += 1) {
+      const option = options[index];
+      const active = index === cursor;
+      const pointer = active ? brand("\u276F") : " ";
+      const box = ticked[index] ? style.green("\u25C9") : style.grey("\u25EF");
+      const text = option.hint ? option.label.padEnd(labelWidth) : option.label;
+      const hint = option.hint ? `  ${style.grey(option.hint)}` : "";
+      const label = active ? brand(text) : ticked[index] ? text : style.grey(text);
+      lines.push(fit(`${pointer} ${box} ${label}${hint}`, width - 1));
+    }
+    const rest = options.length - (first + window);
+    if (rest > 0) lines.push(style.grey(`    \u2193 ${rest} more`));
+    lines.push(style.grey("  \u2191\u2193 move \xB7 space toggle \xB7 a all/none \xB7 enter confirm \xB7 esc cancel"));
+    if (rendered > 0) stdout.write(`\x1B[${rendered}A\r\x1B[J`);
+    stdout.write(`${lines.join("\n")}
+`);
+    rendered = lines.length;
+  };
+  return new Promise((resolve, reject) => {
+    const wasRaw = stdin.isRaw;
+    const restoreCursor = () => {
+      if (!inApp()) stdout.write("\x1B[?25h");
+    };
+    const onResize = () => draw();
+    const finish = (confirmed) => {
+      stdin.off("keypress", onKey);
+      stdin.setRawMode(wasRaw);
+      stdin.pause();
+      process.stdout.off("resize", onResize);
+      process.off("exit", restoreCursor);
+      if (rendered > 0) stdout.write(`\x1B[${rendered}A\r\x1B[J`);
+      restoreCursor();
+      if (!confirmed) {
+        stdout.write(`${style.grey("\u2717")} ${question} ${style.grey("cancelled")}
+`);
+        reject(new MenuCancelled());
+        return;
+      }
+      const chosen = options.filter((_, index) => ticked[index]);
+      const summary = chosen.length === options.length ? `all ${options.length}` : chosen.length === 0 ? "none" : `${chosen.length} of ${options.length}`;
+      stdout.write(`${style.green("\u2713")} ${question} ${brand(summary)}
+`);
+      resolve(chosen.map((option) => option.value));
+    };
+    const onKey = (input, key = {}) => {
+      if (key.ctrl && key.name === "c" || key.name === "escape") return finish(false);
+      if (key.name === "return" || key.name === "enter") return finish(true);
+      if (key.name === "space") ticked[cursor] = !ticked[cursor];
+      else if (input === "a" || input === "A") {
+        const all = ticked.every(Boolean);
+        ticked.fill(!all);
+      } else if (key.name === "up" || key.name === "k") {
+        cursor = (cursor - 1 + options.length) % options.length;
+      } else if (key.name === "down" || key.name === "j" || key.name === "tab") {
+        cursor = (cursor + 1) % options.length;
+      } else return;
+      draw();
+    };
+    process.once("exit", restoreCursor);
+    emitKeypressEvents(stdin);
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdout.write("\x1B[?25l");
+    stdin.on("keypress", onKey);
+    process.stdout.on("resize", onResize);
+    draw();
+  });
+}
 async function selectYesNo(question, defaultYes = false) {
   return select(
     question,
@@ -1946,11 +2037,11 @@ function renderRevokeConfirmation(agent, environment, preview) {
   out(`  ${style.red("This action is irreversible for this identity.")}`);
   out();
 }
-async function lifecycle(args, flags, path13, resultingStatus) {
+async function lifecycle(args, flags, path14, resultingStatus) {
   const context = await resolveContext(flags);
   const agentId = positional(args) ?? context.config.agentId;
   const agent = await context.api.get(`/v1/agents/${agentId}`);
-  const reasonRequired = path13 === "suspend";
+  const reasonRequired = path14 === "suspend";
   const reason = valueFor(args, "--reason");
   if (reasonRequired && (!reason || reason.trim().length < 10)) {
     throw new CliError(
@@ -1960,24 +2051,24 @@ async function lifecycle(args, flags, path13, resultingStatus) {
   }
   out();
   out(
-    `${symbol.info} ${path13} ${style.bold(agent.name)} ${style.grey(`(${agent.status} \u2192 ${resultingStatus})`)}`
+    `${symbol.info} ${path14} ${style.bold(agent.name)} ${style.grey(`(${agent.status} \u2192 ${resultingStatus})`)}`
   );
-  if (path13 !== "resume") {
+  if (path14 !== "resume") {
     const confirmed = await confirm("Continue?", { yes: flags.yes });
     if (!confirmed) {
       out(style.grey("Cancelled."));
       return 1;
     }
   }
-  const actionSpinner = spinner(`Applying ${path13}`);
+  const actionSpinner = spinner(`Applying ${path14}`);
   try {
     await withStepUp(
       context.api,
-      () => context.api.post(`/v1/agents/${agentId}/${path13}`, reason ? { reason } : {})
+      () => context.api.post(`/v1/agents/${agentId}/${path14}`, reason ? { reason } : {})
     );
     actionSpinner.succeed(`${agent.name} is ${resultingStatus}`);
   } catch (error) {
-    actionSpinner.fail(`Could not ${path13} the agent`);
+    actionSpinner.fail(`Could not ${path14} the agent`);
     throw error;
   }
   out();
@@ -2289,6 +2380,7 @@ import { spawnSync } from "node:child_process";
 import { existsSync as existsSync2, readFileSync as readFileSync2, realpathSync } from "node:fs";
 import path3 from "node:path";
 var MIN_APPROVAL_WAIT_SDK = "1.1.0";
+var MIN_CHECKPOINT_SDK = "1.2.0";
 function versionLessThan(a, b) {
   if (!a) return true;
   const left = a.split(/[.+-]/).slice(0, 3).map(Number);
@@ -2335,7 +2427,8 @@ function installedSdks(root, options = {}) {
       language: "js",
       location: path3.relative(top, path3.dirname(manifest)) || ".",
       version,
-      waitsForApproval: !versionLessThan(version, MIN_APPROVAL_WAIT_SDK)
+      waitsForApproval: !versionLessThan(version, MIN_APPROVAL_WAIT_SDK),
+      hasCheckpoint: !versionLessThan(version, MIN_CHECKPOINT_SDK)
     });
   }
   if (options.python) {
@@ -2352,7 +2445,8 @@ function installedSdks(root, options = {}) {
           language: "py",
           location: "python: veefore-py",
           version,
-          waitsForApproval: !versionLessThan(version, MIN_APPROVAL_WAIT_SDK)
+          waitsForApproval: !versionLessThan(version, MIN_APPROVAL_WAIT_SDK),
+          hasCheckpoint: !versionLessThan(version, MIN_CHECKPOINT_SDK)
         });
       }
     }
@@ -3300,12 +3394,12 @@ function isLoosening(from, to) {
 }
 
 // src/commands/init.ts
-import { readFileSync as readFileSync9 } from "node:fs";
-import path12 from "node:path";
+import { readFileSync as readFileSync10 } from "node:fs";
+import path13 from "node:path";
 
 // src/integrate.ts
-import { readFileSync as readFileSync8 } from "node:fs";
-import path9 from "node:path";
+import { readFileSync as readFileSync9 } from "node:fs";
+import path10 from "node:path";
 
 // ../types/src/permissions.ts
 var PERMISSIONS = [
@@ -4189,10 +4283,33 @@ function printDispatchInstructions(items, where) {
   out(
     `  ${items.length} tool${items.length === 1 ? " is" : "s are"} defined as data, so no one function performs each tool.`
   );
-  if (where) {
-    out(
-      `  Your code runs them in ${style.bold(`${where.file}:${where.line}`)}${where.functionName ? ` (${where.functionName})` : ""}.`
-    );
+  const keys = [...new Set(items.map((item) => item.key))];
+  const sites = new Map(
+    keys.flatMap((key) => {
+      const site = where?.sites?.get(key);
+      return site ? [[key, site]] : [];
+    })
+  );
+  const places = new Set([...sites.values()].map((site) => `${site.file}:${site.line}`));
+  const only = places.size === 1 && sites.size === keys.length ? [...sites.values()][0] : null;
+  if (sites.size > 0 && !only) {
+    out("  Wrap the call that performs each one, where your code runs it:");
+    out();
+    for (const key of keys) {
+      const site = sites.get(key);
+      out(
+        `    ${style.bold(key)} ${style.grey(site ? `${site.file}:${site.line}` : "where it is run; this could not be found")}`
+      );
+      if (site) out(`      ${style.grey(site.code)}`);
+    }
+    out();
+    out("  The change is the same shape in each place:");
+  } else if (only || where) {
+    const file = only?.file ?? where?.file;
+    const line = only?.line ?? where?.line ?? 1;
+    const named = where?.functionName && file === where.file ? ` (${where.functionName})` : "";
+    out(`  Your code runs them in ${style.bold(`${file}:${line}`)}${named}.`);
+    if (only) out(`      ${style.grey(only.code)}`);
     out("  Wrap the call there that performs the chosen tool, once:");
   } else {
     out("  Wrap the code that runs whichever tool the model picked, once:");
@@ -4210,7 +4327,9 @@ function printDispatchInstructions(items, where) {
     out(`    ${style.cyan("import { guard } from '@veefore/sdk';")}`);
     out();
     out(`    ${style.grey("// before:  const result = await runTool(call);")}`);
-    out(`    ${style.cyan("const result = await runTool(call);")}`);
+    out(
+      `    ${style.cyan("const result = await guard(call.name, (_args) => runTool(call))(call.args);")}`
+    );
   }
   out();
   out(
@@ -4230,6 +4349,9 @@ function findDispatchGuards(sources) {
   const dynamic = /(?<![\w$.])[A-Za-z_$]*[gG]uard\(\s*(?!['"`])[A-Za-z_$][\w$.]*(?:\[[^\]\n]{1,40}\])?\s*[,)]/;
   return sources.filter(({ text }) => imports.test(text) && dynamic.test(stripDefinitions(text))).map(({ file }) => file);
 }
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&");
+}
 function stripDefinitions(text) {
   return text.replace(/\b(?:function|def)\s+[A-Za-z_$]*[gG]uard\s*\(/g, "");
 }
@@ -4238,7 +4360,12 @@ function toCamel(key) {
 }
 function findGuardedKeys(sources) {
   const found = /* @__PURE__ */ new Map();
-  const pattern = /(?:\b|@)[A-Za-z_$]*[gG]uard\(\s*['"]([a-z][a-z0-9_]*)['"]/g;
+  const pattern = /(?:\b|@)(?:[A-Za-z_$]*[gG]uard|[A-Za-z_$]*[cC]heckpoint)\(\s*['"]([a-z][a-z0-9_]*)['"]/g;
+  for (const { file, text } of sources) {
+    for (const [key, where] of dynamicCheckpointKeys(text, file)) {
+      if (!found.has(key)) found.set(key, where);
+    }
+  }
   for (const { file, text } of sources) {
     for (const match of text.matchAll(pattern)) {
       const key = match[1];
@@ -4247,6 +4374,24 @@ function findGuardedKeys(sources) {
   }
   return found;
 }
+function dynamicCheckpointKeys(text, file) {
+  const found = [];
+  const calls = /(?:\b)[A-Za-z_$]*[cC]heckpoint\(\s*([A-Za-z_$][\w$]*(?:\s*(?:\?\.|\.)\s*[A-Za-z_$][\w$]*)+)\s*[,)]/g;
+  for (const call of text.matchAll(calls)) {
+    const expression = (call[1] ?? "").replace(/\s+/g, "");
+    if (expression === "") continue;
+    const head = text.slice(Math.max(0, (call.index ?? 0) - 600), call.index ?? 0);
+    const [object, ...rest] = expression.split(".");
+    if (object === void 0 || rest.length === 0) continue;
+    const access = rest.map((part) => `\\s*(?:\\?\\.|\\.)\\s*${escapeRegex(part)}`).join("");
+    const pattern = new RegExp(
+      `(?<![\\w$.])${escapeRegex(object)}${access}\\s*={2,3}\\s*['"\`]([a-z][a-z0-9_]*)['"\`]`,
+      "g"
+    );
+    for (const match of head.matchAll(pattern)) found.push([match[1], file]);
+  }
+  return found;
+}
 var PROVIDER_ENV = {
   anthropic: "ANTHROPIC_API_KEY",
   openai: "OPENAI_API_KEY"
@@ -4651,12 +4796,95 @@ function restoreBackup(root, backup, options = {}) {
 }
 
 // src/rewrite.ts
-import { readFileSync as readFileSync7 } from "node:fs";
-import path8 from "node:path";
+import { readFileSync as readFileSync8 } from "node:fs";
+import path9 from "node:path";
 
 // src/scan.ts
-import { existsSync as existsSync6, readFileSync as readFileSync6, readdirSync as readdirSync3, statSync as statSync4 } from "node:fs";
-import path7 from "node:path";
+import { existsSync as existsSync6, readFileSync as readFileSync7 } from "node:fs";
+import path8 from "node:path";
+
+// src/anchors.ts
+var TOOL_ANCHORS = [
+  // Schema-defined tools: findToolSchemas requires one of these keys.
+  "parameters",
+  "input_schema",
+  "inputSchema",
+  "parametersJsonSchema",
+  // The OpenAI function shape, which may carry no description at all.
+  "'function'",
+  '"function"',
+  "`function`",
+  // Framework calls and decorators.
+  "tool(",
+  "Tool(",
+  "tool (",
+  "Tool (",
+  "registerTool",
+  // Python decorators, including the `@mcp.tool` / `@agent.tool` forms, which
+  // carry neither `@tool` nor `tool(`.
+  "@tool",
+  ".tool",
+  "function_tool",
+  "StructuredTool",
+  "DynamicTool"
+];
+var AGENT_ANCHORS = [
+  // Model SDKs and agent frameworks.
+  "openai",
+  "OpenAI",
+  "@anthropic-ai/sdk",
+  "anthropic",
+  "Anthropic",
+  "@google/genai",
+  "@google/generative-ai",
+  "google.generativeai",
+  "google-generativeai",
+  "langchain",
+  "langgraph",
+  "crewai",
+  "llama_index",
+  "llamaindex",
+  "autogen",
+  "litellm",
+  "mistralai",
+  "ollama",
+  "bedrock-runtime",
+  "bedrock_runtime",
+  "@modelcontextprotocol",
+  "mcp.server",
+  // The vocabulary of a tool call, whatever produced it.
+  "tool_calls",
+  "toolCalls",
+  "tool_call",
+  "toolCall",
+  "function_call",
+  "functionCall",
+  "tool_choice",
+  "toolChoice",
+  "toolUse",
+  "tool_use"
+];
+var GUARD_ANCHORS = ["uard(", "uard (", "checkpoint("];
+var RISK_ANCHORS = [
+  "://",
+  "process.env",
+  "import.meta.env",
+  "os.environ",
+  "getenv",
+  "Deno.env"
+];
+function toolKeyAnchors(toolKeys) {
+  const anchors = /* @__PURE__ */ new Set();
+  for (const key of toolKeys) {
+    anchors.add(key);
+    const camel = key.replace(/_([a-z0-9])/g, (_match, char) => char.toUpperCase());
+    if (camel !== key) anchors.add(camel);
+  }
+  return [...anchors];
+}
+var SCAN_ANCHORS = [
+  .../* @__PURE__ */ new Set([...TOOL_ANCHORS, ...AGENT_ANCHORS, ...GUARD_ANCHORS, ...RISK_ANCHORS])
+];
 
 // src/framework.ts
 import { existsSync as existsSync5, readFileSync as readFileSync5, readdirSync as readdirSync2 } from "node:fs";
@@ -4852,19 +5080,11 @@ function integrationSnippet(framework) {
   ].join("\n");
 }
 
-// src/scan.ts
-var MINOR_AMOUNT_PARAMETER = /["']?\b(amount_minor|amountMinor|amount_cents|amountCents|amount_in_cents|amountInCents|amount_minor_units|amountMinorUnits)\b["']?\s*[:=(]/;
-var CURRENCY_PARAMETER = /["']?\b(currency_code|currencyCode|currency)\b["']?\s*[:=(]/;
-function inferMoneyMapping(definition) {
-  const amount = MINOR_AMOUNT_PARAMETER.exec(definition)?.[1] ?? null;
-  const currency = CURRENCY_PARAMETER.exec(definition)?.[1] ?? null;
-  if (!amount && !currency) return null;
-  return {
-    amountParameter: amount,
-    amountUnit: amount ? "MINOR" : null,
-    currencyParameter: currency
-  };
-}
+// src/search.ts
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, readFileSync as readFileSync6, readdirSync as readdirSync3, rmSync as rmSync3, statSync as statSync4, writeFileSync as writeFileSync4 } from "node:fs";
+import { tmpdir } from "node:os";
+import path7 from "node:path";
 var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
   ".ts",
   ".tsx",
@@ -4900,8 +5120,260 @@ var SKIP_DIRECTORIES = /* @__PURE__ */ new Set([
   "tests",
   "test"
 ]);
-var MAX_FILES = 2e3;
-var MAX_FILE_BYTES = 512 * 1024;
+var SKIP_FILES = /\.(test|spec)\.[cm]?[jt]sx?$|^test_.*\.py$|_test\.py$|\.d\.ts$|\.min\.[cm]?js$/;
+var DEFAULT_BUDGET_MS = 6e4;
+var MAX_PARSE_BYTES = 4 * 1024 * 1024;
+var cache = /* @__PURE__ */ new Map();
+function forgetIndex(root) {
+  if (root === void 0) cache.clear();
+  else cache.delete(path7.resolve(root));
+}
+function indexFiles(root, options = {}) {
+  const key = path7.resolve(root);
+  const hit = cache.get(key);
+  if (hit) return hit;
+  const built = buildIndex(root, options);
+  if (!built.truncated) cache.set(key, built);
+  return built;
+}
+function buildIndex(root, options) {
+  const deadline2 = Date.now() + (options.budgetMs ?? DEFAULT_BUDGET_MS);
+  const fromGit = gitFiles(root, deadline2);
+  if (fromGit) {
+    return {
+      files: fromGit.tracked.filter(isCandidate),
+      method: "git",
+      truncated: false,
+      unsearchable: fromGit.unsearchable.filter(isCandidate)
+    };
+  }
+  const files = [];
+  const truncated = walk(root, root, files, deadline2);
+  return { files, method: "walk", truncated, unsearchable: [] };
+}
+function gitFiles(root, deadline2) {
+  const output = git(
+    root,
+    ["ls-files", "-z", "--cached", "--others", "--exclude-standard"],
+    deadline2
+  );
+  if (output === null) return null;
+  const tracked = new Set(output.split("\0").filter((entry) => entry !== ""));
+  const unsearchable = /* @__PURE__ */ new Set();
+  const submodules = git(root, ["ls-files", "-z", "--cached", "--recurse-submodules"], deadline2);
+  if (submodules !== null) {
+    for (const entry of submodules.split("\0")) {
+      if (entry !== "" && !tracked.has(entry)) unsearchable.add(entry);
+    }
+  }
+  for (const file of ignoredSources(root, deadline2)) {
+    if (!tracked.has(file)) unsearchable.add(file);
+  }
+  return { tracked: [...tracked, ...unsearchable], unsearchable: [...unsearchable] };
+}
+function ignoredSources(root, deadline2) {
+  const output = git(
+    root,
+    ["ls-files", "-z", "--others", "--ignored", "--exclude-standard", "--directory"],
+    deadline2
+  );
+  if (output === null) return [];
+  const files = [];
+  for (const entry of output.split("\0")) {
+    if (entry === "") continue;
+    if (entry.endsWith("/")) {
+      const name = entry.replace(/\/$/, "").split("/").pop() ?? "";
+      if (SKIP_DIRECTORIES.has(name) || name.startsWith(".")) continue;
+      const nested = [];
+      walk(root, path7.join(root, entry), nested, deadline2);
+      files.push(...nested);
+      continue;
+    }
+    if (isCandidate(entry)) files.push(entry);
+  }
+  return files;
+}
+function git(root, args, deadline2) {
+  const timeout = deadline2 - Date.now();
+  if (timeout <= 0) return null;
+  try {
+    return execFileSync("git", ["-c", "core.quotepath=off", ...args], {
+      cwd: root,
+      encoding: "utf8",
+      timeout,
+      maxBuffer: 512 * 1024 * 1024,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+  } catch {
+    return null;
+  }
+}
+function isCandidate(file) {
+  if (!SOURCE_EXTENSIONS.has(path7.extname(file))) return false;
+  const segments = file.split(/[/\\]/);
+  const name = segments[segments.length - 1] ?? "";
+  if (SKIP_FILES.test(name)) return false;
+  return !segments.slice(0, -1).some((segment) => SKIP_DIRECTORIES.has(segment) || segment.startsWith("."));
+}
+function walk(root, dir, out2, deadline2) {
+  let entries;
+  try {
+    entries = readdirSyncSafe(dir);
+  } catch {
+    return false;
+  }
+  for (const entry of entries) {
+    if (Date.now() > deadline2) return true;
+    if (entry.startsWith(".")) continue;
+    const full = path7.join(dir, entry);
+    let directory;
+    try {
+      directory = statSync4(full).isDirectory();
+    } catch {
+      continue;
+    }
+    if (directory) {
+      if (SKIP_DIRECTORIES.has(entry)) continue;
+      if (walk(root, full, out2, deadline2)) return true;
+      continue;
+    }
+    const relative = path7.relative(root, full);
+    if (isCandidate(relative)) out2.push(relative);
+  }
+  return false;
+}
+function readdirSyncSafe(dir) {
+  return readdirSync3(dir).sort();
+}
+function shortlist(root, index, anchors, options = {}) {
+  const considered = index.files.length;
+  if (anchors.length === 0 || considered === 0) {
+    return { files: [], method: "in-process", considered, truncated: false };
+  }
+  const deadline2 = Date.now() + (options.budgetMs ?? DEFAULT_BUDGET_MS);
+  const allowed = new Set(index.files);
+  const reached = index.unsearchable.filter((file) => allowed.has(file));
+  const extra = reached.length > 0 ? inProcessSearch(root, reached, anchors, deadline2, reached.length) : null;
+  const combine = (files, method) => ({
+    files: [.../* @__PURE__ */ new Set([...files, ...extra?.files ?? []])],
+    method,
+    considered,
+    truncated: extra?.truncated ?? false
+  });
+  if (index.method === "git") {
+    const matched = searchWith(
+      "git",
+      root,
+      ["-c", "core.quotepath=off", "grep", "--no-color", "-l", "-I", "-z", "-F", "--untracked"],
+      anchors,
+      deadline2
+    );
+    if (matched) {
+      return combine(
+        matched.filter((file) => allowed.has(file)),
+        "git-grep"
+      );
+    }
+  }
+  const ripgrep = searchWith(
+    "rg",
+    root,
+    ["--files-with-matches", "--fixed-strings", "--null", "--no-messages"],
+    anchors,
+    deadline2
+  );
+  if (ripgrep) {
+    return combine(
+      ripgrep.map(normalise).filter((file) => allowed.has(file)),
+      "ripgrep"
+    );
+  }
+  return inProcessSearch(root, index.files, anchors, deadline2, considered);
+}
+function searchWith(command, root, args, anchors, deadline2) {
+  const timeout = deadline2 - Date.now();
+  if (timeout <= 0) return null;
+  let directory = null;
+  try {
+    directory = mkdtempSync(path7.join(tmpdir(), "veefore-search-"));
+    const patterns = path7.join(directory, "anchors.txt");
+    writeFileSync4(patterns, `${anchors.join("\n")}
+`);
+    const output = execFileSync(command, [...args, "-f", patterns], {
+      cwd: root,
+      encoding: "utf8",
+      timeout,
+      maxBuffer: 512 * 1024 * 1024,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return output.split("\0").filter((entry) => entry !== "");
+  } catch (error) {
+    const status = error.status;
+    if (status === 1) return [];
+    return null;
+  } finally {
+    if (directory) rmSync3(directory, { recursive: true, force: true });
+  }
+}
+function inProcessSearch(root, files, anchors, deadline2, considered) {
+  const needles = anchors.map((anchor) => Buffer.from(anchor, "utf8"));
+  const matched = [];
+  let truncated = false;
+  for (const [position, file] of files.entries()) {
+    if ((position & 63) === 0 && Date.now() > deadline2) {
+      truncated = true;
+      break;
+    }
+    let buffer;
+    try {
+      buffer = readFileSync6(path7.join(root, file));
+    } catch {
+      continue;
+    }
+    const nul = buffer.indexOf(0);
+    if (nul >= 0 && nul < 8192) continue;
+    if (needles.some((needle) => buffer.includes(needle))) matched.push(file);
+  }
+  return { files: matched, method: "in-process", considered, truncated };
+}
+function normalise(file) {
+  return file.startsWith(`.${path7.sep}`) || file.startsWith("./") ? file.slice(2) : file;
+}
+function tooBigToParse(text) {
+  if (text.length > MAX_PARSE_BYTES) return true;
+  if (text.length < 128 * 1024) return false;
+  const head = text.slice(0, 128 * 1024);
+  const lines = head.split("\n").length;
+  return head.length / lines > 500;
+}
+function readFiles(root, files) {
+  const out2 = [];
+  for (const file of files) {
+    let text;
+    try {
+      text = readFileSync6(path7.join(root, file), "utf8");
+    } catch {
+      continue;
+    }
+    if (tooBigToParse(text)) continue;
+    out2.push({ file, text });
+  }
+  return out2;
+}
+
+// src/scan.ts
+var MINOR_AMOUNT_PARAMETER = /["']?\b(amount_minor|amountMinor|amount_cents|amountCents|amount_in_cents|amountInCents|amount_minor_units|amountMinorUnits)\b["']?\s*[:=(]/;
+var CURRENCY_PARAMETER = /["']?\b(currency_code|currencyCode|currency)\b["']?\s*[:=(]/;
+function inferMoneyMapping(definition) {
+  const amount = MINOR_AMOUNT_PARAMETER.exec(definition)?.[1] ?? null;
+  const currency = CURRENCY_PARAMETER.exec(definition)?.[1] ?? null;
+  if (!amount && !currency) return null;
+  return {
+    amountParameter: amount,
+    amountUnit: amount ? "MINOR" : null,
+    currencyParameter: currency
+  };
+}
 var MODEL_HOSTS = [
   "api.openai.com",
   "api.anthropic.com",
@@ -4918,24 +5390,74 @@ var MODEL_SECRET = /^(OPENAI|ANTHROPIC|GOOGLE|GEMINI|AZURE_OPENAI|MISTRAL|GROQ|C
 var SECRET_NAME = /(KEY|TOKEN|SECRET|PASSWORD|PASSWD|PRIVATE|CREDENTIAL|AUTH|DSN)(_|$)|^DATABASE_URL$|_CONNECTION_STRING$/;
 var NOT_SECRET = /^(VEEFORE_|NODE_|NEXT_PUBLIC_|VITE_|PUBLIC_|NPM_)/;
 function listSourceFiles(root = process.cwd()) {
-  const files = [];
-  walk(root, root, files);
-  return files;
+  return listSources(root).files;
+}
+function listSources(root = process.cwd()) {
+  const index = indexFiles(root);
+  return { files: index.files, truncated: index.truncated, method: index.method };
+}
+function discoverAgents(root = process.cwd(), reuse) {
+  const scan = reuse ?? scanProject(root);
+  const index = indexFiles(root);
+  const byDirectory = /* @__PURE__ */ new Map();
+  for (const tool of scan.tools) {
+    const directory = nearestManifest(root, tool.location.file);
+    const existing = byDirectory.get(directory);
+    const agent = existing ?? {
+      directory,
+      name: readProjectName(path8.join(root, directory)),
+      files: [],
+      tools: []
+    };
+    if (!agent.files.includes(tool.location.file)) agent.files.push(tool.location.file);
+    agent.tools.push(tool);
+    byDirectory.set(directory, agent);
+  }
+  const known = new Set(scan.tools.map((tool) => tool.location.file));
+  const agentFiles = shortlist(root, index, [...AGENT_ANCHORS]);
+  const unreadable = [];
+  for (const { file, text } of readFiles(root, agentFiles.files)) {
+    if (known.has(file)) continue;
+    const python = file.endsWith(".py");
+    if ((python ? findPythonTools(text) : findJsTools(text)).length > 0) continue;
+    const hint = /\btools?\s*[:=]|\btool_calls\b|\btoolCalls\b|\bfunction_call\b/.exec(text);
+    if (!hint) continue;
+    unreadable.push({
+      file,
+      line: lineLocator(text)(hint.index),
+      reason: `passes tools to a model, but none could be read from this file`
+    });
+  }
+  return {
+    agents: [...byDirectory.values()].sort((a, b) => a.directory.localeCompare(b.directory)),
+    unreadable,
+    filesScanned: scan.filesScanned,
+    truncated: scan.truncated || agentFiles.truncated
+  };
+}
+function nearestManifest(root, file) {
+  const MANIFESTS = ["package.json", "pyproject.toml", "go.mod", "Cargo.toml", "setup.py"];
+  let dir = path8.dirname(file);
+  for (let depth = 0; depth < 32; depth += 1) {
+    const absolute = path8.join(root, dir);
+    if (MANIFESTS.some((manifest) => existsSync6(path8.join(absolute, manifest)))) {
+      return dir === "" ? "." : dir;
+    }
+    const parent = path8.dirname(dir);
+    if (parent === dir || dir === "." || dir === "") break;
+    dir = parent;
+  }
+  return ".";
 }
 function scanProject(root = process.cwd()) {
   const framework = detectFramework(root);
-  const files = [];
-  const truncated = walk(root, root, files);
+  const index = indexFiles(root);
+  const candidates = shortlist(root, index, [...SCAN_ANCHORS]);
+  const truncated = index.truncated || candidates.truncated;
   const tools = [];
   const hosts = /* @__PURE__ */ new Map();
   const secrets = /* @__PURE__ */ new Map();
-  for (const relative of files) {
-    let text;
-    try {
-      text = readFileSync6(path7.join(root, relative), "utf8");
-    } catch {
-      continue;
-    }
+  for (const { file: relative, text } of readFiles(root, candidates.files)) {
     const python = relative.endsWith(".py");
     const lineOf = lineLocator(text);
     const fileHosts = findHosts(text).map((hit) => ({ ...hit, line: lineOf(hit.index) }));
@@ -4951,7 +5473,7 @@ function scanProject(root = process.cwd()) {
     found.forEach((hit, position) => {
       const end = found[position + 1]?.index ?? text.length;
       const start = hit.index;
-      const inRegion = (index) => index >= start && index < end;
+      const inRegion = (index2) => index2 >= start && index2 < end;
       const ownHosts = unique(fileHosts.filter((h) => inRegion(h.index)).map((h) => h.host));
       const ownSecrets = unique(
         fileSecrets.filter((s) => inRegion(s.index) && classifySecret(s.name) === "service").map((s) => s.name)
@@ -4979,7 +5501,9 @@ function scanProject(root = process.cwd()) {
     projectName: readProjectName(root),
     framework,
     entryPoints: findEntryPoints(root),
-    filesScanned: files.length,
+    filesScanned: index.files.length,
+    filesParsed: candidates.files.length,
+    searchMethod: candidates.method,
     truncated,
     tools: dedupeTools(tools),
     hosts: [...hosts.entries()].map(([host, locations]) => ({ host, locations })).sort((a, b) => a.host.localeCompare(b.host)),
@@ -4997,7 +5521,7 @@ function combineRisk(inferred, declared) {
 function findJsTools(text) {
   const hits = [];
   const importsFrom = (pkg) => new RegExp(
-    `from\\s+['"]${escapeRegex(pkg)}(/[^'"]*)?['"]|require\\(\\s*['"]${escapeRegex(pkg)}`
+    `from\\s+['"]${escapeRegex2(pkg)}(/[^'"]*)?['"]|require\\(\\s*['"]${escapeRegex2(pkg)}`
   ).test(text);
   const vercel = importsFrom("ai");
   const langchain = importsFrom("@langchain/core") || importsFrom("langchain");
@@ -5053,18 +5577,8 @@ function findJsTools(text) {
       }
     }
   }
-  for (const match of text.matchAll(/type\s*:\s*['"]function['"]/g)) {
-    const index = match.index ?? 0;
-    const body = text.slice(index, index + 400);
-    const name = stringField(body, "name");
-    if (name) {
-      hits.push({
-        name,
-        source: "openai-function",
-        index,
-        description: stringField(body, "description")
-      });
-    }
+  for (const hit of findFunctionToolSchemas(text)) {
+    hits.push({ ...hit, source: "openai-function" });
   }
   addSchemaTools(hits, text, false);
   if (mcp) {
@@ -5128,13 +5642,78 @@ function findToolSchemas(text, python) {
   }
   return hits;
 }
-function addSchemaTools(hits, text, python) {
-  const known = new Set(hits.map((hit) => toToolKey(hit.name)));
-  for (const hit of findToolSchemas(text, python)) {
-    const key = toToolKey(hit.name);
-    if (known.has(key)) continue;
-    known.add(key);
-    hits.push({ ...hit, source: "tool-schema" });
+function findFunctionToolSchemas(text) {
+  const hits = [];
+  const NAME = /\bname\s*:\s*(['"`])([\w.-]{1,80})\1/;
+  for (const match of text.matchAll(/\btype\s*:\s*(['"`])function\1/g)) {
+    const at = match.index ?? 0;
+    const from = at + match[0].length;
+    const sibling = /^[^{}]{0,400}?(?<![\w$.])function\s*:\s*\{/.exec(text.slice(from));
+    if (sibling) {
+      const open = from + sibling[0].length - 1;
+      const close = matchingBrace(text, open);
+      if (close > open) {
+        const inner = text.slice(open, close + 1);
+        const found = NAME.exec(inner);
+        if (found) {
+          hits.push({
+            name: found[2],
+            index: open + found.index,
+            description: stringField(inner, "description")
+          });
+          continue;
+        }
+      }
+    }
+    const opener = text.lastIndexOf("{", at);
+    const windows = [
+      [
+        Math.max(opener + 1, at - 400),
+        opener < 0 ? "" : text.slice(Math.max(opener + 1, at - 400), at)
+      ],
+      [from, text.slice(from, from + 400).split(/[{}]/)[0] ?? ""]
+    ];
+    for (const [offset, window] of windows) {
+      const found = NAME.exec(window);
+      if (!found) continue;
+      hits.push({
+        name: found[2],
+        index: offset + found.index,
+        description: stringField(window, "description")
+      });
+      break;
+    }
+  }
+  return hits;
+}
+function matchingBrace(text, open) {
+  let depth = 0;
+  for (let index = open; index < text.length; index += 1) {
+    const char = text[index];
+    if (char === '"' || char === "'" || char === "`") {
+      const quote2 = char;
+      index += 1;
+      while (index < text.length && text[index] !== quote2) {
+        if (text[index] === "\\") index += 1;
+        index += 1;
+      }
+      continue;
+    }
+    if (char === "{") depth += 1;
+    else if (char === "}") {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+  }
+  return -1;
+}
+function addSchemaTools(hits, text, python) {
+  const known = new Set(hits.map((hit) => toToolKey(hit.name)));
+  for (const hit of findToolSchemas(text, python)) {
+    const key = toToolKey(hit.name);
+    if (known.has(key)) continue;
+    known.add(key);
+    hits.push({ ...hit, source: "tool-schema" });
   }
 }
 function objectLiterals(text, python) {
@@ -5419,52 +5998,21 @@ function toToolKey(name) {
   const safe = /^[a-z]/.test(key) ? key : `tool_${key}`;
   return safe.slice(0, 80) || "tool";
 }
-function walk(root, dir, out2) {
-  let entries;
-  try {
-    entries = readdirSync3(dir).sort();
-  } catch {
-    return false;
-  }
-  for (const entry of entries) {
-    if (out2.length >= MAX_FILES) return true;
-    if (entry.startsWith(".") && entry !== ".") {
-      continue;
-    }
-    const full = path7.join(dir, entry);
-    let stats;
-    try {
-      stats = statSync4(full);
-    } catch {
-      continue;
-    }
-    if (stats.isDirectory()) {
-      if (SKIP_DIRECTORIES.has(entry)) continue;
-      if (walk(root, full, out2)) return true;
-      continue;
-    }
-    if (!stats.isFile() || stats.size > MAX_FILE_BYTES) continue;
-    if (!SOURCE_EXTENSIONS.has(path7.extname(entry))) continue;
-    if (/\.(test|spec)\.[cm]?[jt]sx?$|^test_.*\.py$|_test\.py$|\.d\.ts$/.test(entry)) continue;
-    out2.push(path7.relative(root, full));
-  }
-  return false;
-}
 function readProjectName(root) {
-  const pkg = path7.join(root, "package.json");
+  const pkg = path8.join(root, "package.json");
   if (existsSync6(pkg)) {
     try {
-      const name = JSON.parse(readFileSync6(pkg, "utf8")).name;
+      const name = JSON.parse(readFileSync7(pkg, "utf8")).name;
       if (typeof name === "string" && name.trim()) return name.replace(/^@[^/]+\//, "").trim();
     } catch {
     }
   }
-  const pyproject = path7.join(root, "pyproject.toml");
+  const pyproject = path8.join(root, "pyproject.toml");
   if (existsSync6(pyproject)) {
-    const name = /^\s*name\s*=\s*["']([^"']+)["']/m.exec(readFileSync6(pyproject, "utf8"))?.[1];
+    const name = /^\s*name\s*=\s*["']([^"']+)["']/m.exec(readFileSync7(pyproject, "utf8"))?.[1];
     if (name) return name.trim();
   }
-  return path7.basename(root) || null;
+  return path8.basename(root) || null;
 }
 function stringField(body, field) {
   const match = new RegExp(`\\b${field}\\s*:\\s*(['"\`])([^]{1,300}?)\\1`).exec(body);
@@ -5506,7 +6054,7 @@ function push(map, key, value) {
 function unique(values) {
   return [...new Set(values)];
 }
-function escapeRegex(value) {
+function escapeRegex2(value) {
   return value.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&");
 }
 
@@ -5519,7 +6067,7 @@ function planRewrite(root, files, toolKeys) {
   for (const file of files) {
     let before;
     try {
-      before = readFileSync7(path8.join(root, file), "utf8");
+      before = readFileSync8(path9.join(root, file), "utf8");
     } catch {
       continue;
     }
@@ -5624,27 +6172,20 @@ function rewriteJs(source, wanted) {
       wrap3(key, match.index ?? 0, start, trimEnd(source, start, handler.end));
     }
   }
-  for (const match of source.matchAll(/type\s*:\s*['"]function['"]/g)) {
-    const name = /\bname\s*:\s*['"]([\w.-]{1,80})['"]/.exec(
-      source.slice(match.index ?? 0, (match.index ?? 0) + 400)
-    )?.[1];
-    if (!name || !wanted.has(toToolKey(name))) continue;
-    changes.push({
-      key: toToolKey(name),
-      line: lineOf(match.index ?? 0),
-      status: "manual",
-      reason: `this is only the schema; wrap the function your code calls for it, e.g. \`guard(${quote(toToolKey(name))}, yourFunction)\``
-    });
-  }
-  changes.push(...schemaOnly(source, false, wanted));
+  changes.push(...schemaOnly(source, false, wanted, new Set(changes.map((c) => c.key))));
   const wrapped = edits.length > 0;
   let after = applyEdits(source, edits);
   if (wrapped) after = addJsImport(after, alias);
   return { after, changes: dedupeChanges(changes) };
 }
 function addJsImport(source, alias) {
-  if (existingGuardImport(source, "js")) return source;
-  const specifier = alias === "guard" ? "guard" : `guard as ${alias}`;
+  return addJsSdkImport(source, "guard", alias);
+}
+function addJsSdkImport(source, name, alias) {
+  if (existingImport(source, name, "js")) return source;
+  const specifier = alias === name ? name : `${name} as ${alias}`;
+  const joined = joinExistingSdkImport(source, specifier, alias, name);
+  if (joined) return joined;
   const imports = [
     ...source.matchAll(
       /^import\s+(?:type\s+)?(?:[\s\S]*?\sfrom\s*)?['"][^'"\n]+['"]\s*;?[^\S\n]*$/gm
@@ -5657,11 +6198,33 @@ function addJsImport(source, alias) {
 import { ${specifier} } from '@veefore/sdk';${source.slice(at)}`;
   }
   const cjs = /\brequire\(\s*['"][^'"]+['"]\s*\)/.test(source) && !/^\s*export\s/m.test(source);
-  const line = cjs ? `const { ${alias === "guard" ? "guard" : `guard: ${alias}`} } = require('@veefore/sdk');` : `import { ${specifier} } from '@veefore/sdk';`;
+  const line = cjs ? `const { ${alias === name ? name : `${name}: ${alias}`} } = require('@veefore/sdk');` : `import { ${specifier} } from '@veefore/sdk';`;
   const prologue = /^(?:#![^\n]*\n)?(?:\s*(['"])use [a-z ]+\1;?[^\S\n]*\n)*/.exec(source)?.[0] ?? "";
   return `${source.slice(0, prologue.length)}${line}
 ${source.slice(prologue.length)}`;
 }
+function joinExistingSdkImport(source, specifier, alias, name) {
+  const esm = /import\s*\{([^}]*)\}\s*from\s*(['"])@veefore\/sdk\2/.exec(source);
+  if (esm) {
+    const names = (esm[1] ?? "").trim();
+    const replacement = esm[0].replace(
+      `{${esm[1] ?? ""}}`,
+      names === "" ? `{ ${specifier} }` : `{ ${names}, ${specifier} }`
+    );
+    return source.replace(esm[0], replacement);
+  }
+  const cjs = /const\s*\{([^}]*)\}\s*=\s*require\(\s*(['"])@veefore\/sdk\2\s*\)/.exec(source);
+  if (cjs) {
+    const names = (cjs[1] ?? "").trim();
+    const entry = alias === name ? name : `${name}: ${alias}`;
+    const replacement = cjs[0].replace(
+      `{${cjs[1] ?? ""}}`,
+      names === "" ? `{ ${entry} }` : `{ ${names}, ${entry} }`
+    );
+    return source.replace(cjs[0], replacement);
+  }
+  return null;
+}
 function rewritePython(source, wanted) {
   const changes = [];
   const lines = source.split("\n");
@@ -5704,7 +6267,7 @@ function rewritePython(source, wanted) {
       reason: `decorate the function passed as func= with @guard(${JSON.stringify(toToolKey(name))})`
     });
   }
-  changes.push(...schemaOnly(source, true, wanted));
+  changes.push(...schemaOnly(source, true, wanted, new Set(changes.map((c) => c.key))));
   if (inserts.length === 0) return { after: source, changes: dedupeChanges(changes) };
   const out2 = [...lines];
   for (const insert of [...inserts].sort((a, b) => b.before - a.before)) {
@@ -5914,9 +6477,63 @@ function topLevelString(text, open, close, name) {
   const literal = /^(['"`])([\w .-]{1,80})\1$/.exec(text.slice(value.start, value.end));
   return literal?.[2] ?? null;
 }
-var DISPATCH_NAME = /^(?:execute|run|call|dispatch|handle|invoke|perform)_?(?:tool|tool_?call|function_?call)s?$/i;
+var DISPATCH_NAME = /^(?:execute|run|call|dispatch|handle|invoke|perform)[A-Za-z0-9_]*?_?(?:tool|tool_?call|function_?call)s?$/i;
 var KEY_PROPERTIES = ["tool", "name", "toolName", "tool_name"];
 var ARG_PROPERTIES = ["params", "args", "arguments", "input", "parameters"];
+function findRunSites(files, read, toolNames) {
+  const sites = /* @__PURE__ */ new Map();
+  if (toolNames.length === 0) return sites;
+  const patterns = (name) => {
+    const quoted = `['"\`]${escapeForRegex(name)}['"\`]`;
+    return [
+      // `switch (call.tool) { case 'x':` — unmistakable.
+      new RegExp(`case\\s+${quoted}`),
+      // `call.name === 'x'`: the key read off the call being run, which is
+      // what a dispatch does and what a view's own state does not.
+      new RegExp(
+        `\\.\\s*[A-Za-z_$][\\w$]*\\s*={2,3}\\s*${quoted}|${quoted}\\s*={2,3}\\s*[A-Za-z_$][\\w$]*\\s*\\.`
+      ),
+      // `handlers['x']`, `executors['x']`
+      new RegExp(`\\[\\s*${quoted}\\s*\\]`),
+      // `'x': async (args) => …`, a map of handlers by key.
+      new RegExp(`${quoted}\\s*:\\s*(?:async\\b|function\\b|\\(|[\\w$]+\\s*=>)`),
+      // Any other comparison against the key. `!==` is deliberately not one:
+      // a tool is not run where its name is ruled out, and taking the first
+      // of those sent the instruction to a view that merely checks which
+      // tool is selected.
+      new RegExp(`(?<![!<>=])={2,3}\\s*${quoted}|${quoted}\\s*={2,3}`)
+    ];
+  };
+  const best = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const source = read(file);
+    if (source === null) continue;
+    const lineOf = lineLocator2(source);
+    for (const name of toolNames) {
+      if (!source.includes(name)) continue;
+      for (const [rank, pattern] of patterns(name).entries()) {
+        const found = pattern.exec(source);
+        if (!found) continue;
+        const current = best.get(name);
+        if (current && current.rank <= rank) break;
+        const at = found.index;
+        const start = source.lastIndexOf("\n", at) + 1;
+        const end = source.indexOf("\n", at);
+        best.set(name, {
+          rank,
+          site: {
+            file,
+            line: lineOf(at),
+            code: source.slice(start, end < 0 ? source.length : end).trim().slice(0, 160)
+          }
+        });
+        break;
+      }
+    }
+  }
+  for (const [name, entry] of best) sites.set(name, entry.site);
+  return sites;
+}
 function planDispatch(files, read, toolNames) {
   let best = null;
   for (const file of files) {
@@ -5938,27 +6555,36 @@ function planDispatch(files, read, toolNames) {
           };
         }
       }
-      if (!best || best.fn === null) {
-        best = { file, line: lineOf(found.index), score: Number.MAX_SAFE_INTEGER, fn: found.name };
-      }
+      best ??= { file, line: lineOf(found.index), fn: found.name };
     }
-    const named = toolNames.filter(
-      (name) => new RegExp(
-        `['"\`]${escapeForRegex(name)}['"\`]\\s*[:)]|case\\s+['"\`]${escapeForRegex(name)}['"\`]`
-      ).test(source)
-    ).length;
-    if (named >= 2 && (!best || named > best.score)) {
-      const first = toolNames.map((name) => source.search(new RegExp(`case\\s+['"\`]${escapeForRegex(name)}['"\`]`))).filter((index) => index >= 0).sort((a, b) => a - b)[0];
-      best = { file, line: first === void 0 ? 1 : lineOf(first), score: named, fn: null };
+  }
+  const sites = findRunSites(files, read, toolNames);
+  if (!best) {
+    const byFile = /* @__PURE__ */ new Map();
+    for (const site of sites.values()) {
+      byFile.set(site.file, [...byFile.get(site.file) ?? [], site]);
     }
+    const chosen = [...byFile.entries()].sort(
+      (a, b) => b[1].length - a[1].length || a[0].localeCompare(b[0])
+    )[0];
+    if (!chosen) return null;
+    const line = Math.min(...chosen[1].map((site) => site.line));
+    return {
+      file: chosen[0],
+      line,
+      functionName: null,
+      after: null,
+      reason: "this file runs the tools by name",
+      sites
+    };
   }
-  if (!best) return null;
   return {
     file: best.file,
     line: best.line,
     functionName: best.fn,
     after: null,
-    reason: best.fn ? `${best.fn}() runs the tools, but where to put the guard inside it is not certain` : "this file runs the tools by name"
+    reason: `${best.fn}() runs the tools, but where to put the guard inside it is not certain`,
+    sites
   };
 }
 function dispatchFunctions(source, python) {
@@ -6031,13 +6657,396 @@ function guardDispatch(source, fn, typescript) {
   );
   return { after, at: target.start };
 }
+var CHECKPOINT_ARG_PROPERTIES = ["args", "arguments", "params", "parameters", "input", "payload"];
+var CONTROL_KEYWORDS = /* @__PURE__ */ new Set([
+  "if",
+  "else",
+  "for",
+  "while",
+  "do",
+  "switch",
+  "catch",
+  "with",
+  "return",
+  "typeof",
+  "await",
+  "new",
+  "throw",
+  "case",
+  "function",
+  "delete",
+  "void",
+  "in",
+  "of",
+  "yield"
+]);
+var BRANCH_KEYWORDS = /* @__PURE__ */ new Set(["if", "for", "while"]);
+function readStructure(source) {
+  const parens = [];
+  const blocks = [];
+  const parenStack = [];
+  const braceStack = [];
+  const closedAt = /* @__PURE__ */ new Map();
+  let awaitingBody = null;
+  let previous = "";
+  let index = 0;
+  while (index < source.length) {
+    const char = source[index];
+    const next = source[index + 1];
+    if (char === "/" && next === "/") {
+      const stop = source.indexOf("\n", index);
+      index = stop < 0 ? source.length : stop;
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      const stop = source.indexOf("*/", index + 2);
+      index = stop < 0 ? source.length : stop + 2;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      const stop = skipString(source, index);
+      index = stop < 0 ? nextLine(source, index) : stop;
+      previous = "a";
+      continue;
+    }
+    if (char === "`") {
+      const stop = skipTemplate(source, index);
+      index = stop < 0 ? nextLine(source, index) : stop;
+      previous = "a";
+      continue;
+    }
+    if (char === "/" && regexAllowed(source, index, previous)) {
+      const stop = skipRegex(source, index);
+      index = stop < 0 ? nextLine(source, index) : stop;
+      previous = "a";
+      continue;
+    }
+    if (char === "(") parenStack.push(index);
+    else if (char === ")") {
+      const open = parenStack.pop();
+      if (open !== void 0) {
+        const head = headBefore(source, open);
+        const group = { open, close: index, name: head.name, async: head.async };
+        parens.push(group);
+        closedAt.set(index, group);
+        if (!CONTROL_KEYWORDS.has(group.name) && /^\s*:/.test(source.slice(index + 1, index + 40))) {
+          awaitingBody = { async: group.async, depth: braceStack.length, params: group };
+        }
+      }
+    } else if (char === ";" || char === "=") {
+      if (awaitingBody && braceStack.length === awaitingBody.depth) awaitingBody = null;
+    } else if (char === "{") {
+      const kind = bodyKind(source, index, closedAt, awaitingBody);
+      if (kind.fn) awaitingBody = null;
+      braceStack.push({ open: index, ...kind });
+    } else if (char === "}") {
+      const open = braceStack.pop();
+      if (open !== void 0) blocks.push({ ...open, close: index });
+    }
+    if (!/\s/.test(char)) previous = char;
+    index += 1;
+  }
+  for (const open of braceStack) blocks.push({ ...open, close: source.length });
+  return { parens, blocks };
+}
+function nextLine(source, from) {
+  const stop = source.indexOf("\n", from);
+  return stop < 0 ? source.length : stop + 1;
+}
+function bodyKind(source, index, closedAt, awaitingBody) {
+  const before = significantBefore(source, index);
+  if (before.text === "=>") {
+    let cursor = before.at - 1;
+    while (cursor >= 0 && /\s/.test(source[cursor])) cursor -= 1;
+    const group = source[cursor] === ")" ? closedAt.get(cursor) : void 0;
+    if (group) return { fn: true, async: group.async, params: group };
+    return { fn: true, async: asyncBefore(source, cursor + 1), params: null };
+  }
+  if (before.text === ")") {
+    const group = closedAt.get(before.at);
+    if (!group) return { fn: false, async: false, params: null };
+    if (CONTROL_KEYWORDS.has(group.name)) return { fn: false, async: false, params: null };
+    return { fn: true, async: group.async, params: group };
+  }
+  if (awaitingBody && /[>\])\w$]/.test(before.text)) {
+    return { fn: true, async: awaitingBody.async, params: awaitingBody.params };
+  }
+  return { fn: false, async: false, params: null };
+}
+function significantBefore(source, index) {
+  let cursor = index - 1;
+  for (; ; ) {
+    while (cursor >= 0 && /\s/.test(source[cursor])) cursor -= 1;
+    if (cursor >= 1 && source[cursor] === "/" && source[cursor - 1] === "*") {
+      const open = source.lastIndexOf("/*", cursor - 1);
+      if (open < 0) break;
+      cursor = open - 1;
+      continue;
+    }
+    break;
+  }
+  if (cursor < 0) return { text: "", at: 0 };
+  if (cursor >= 1 && source[cursor] === ">" && source[cursor - 1] === "=") {
+    return { text: "=>", at: cursor - 1 };
+  }
+  return { text: source[cursor], at: cursor };
+}
+function headBefore(source, parenOpen) {
+  let cursor = parenOpen - 1;
+  while (cursor >= 0 && /\s/.test(source[cursor])) cursor -= 1;
+  let end = cursor + 1;
+  while (cursor >= 0 && /[\w$]/.test(source[cursor])) cursor -= 1;
+  const name = source.slice(cursor + 1, end);
+  let before = cursor;
+  if (name === "") {
+    return { name: "", async: asyncBefore(source, parenOpen) };
+  }
+  if (name === "async") return { name: "", async: true };
+  while (before >= 0 && /[\s*]/.test(source[before])) before -= 1;
+  end = before + 1;
+  while (before >= 0 && /[\w$]/.test(source[before])) before -= 1;
+  const keyword = source.slice(before + 1, end);
+  if (keyword === "function") return { name, async: asyncBefore(source, before + 1) };
+  return { name, async: asyncBefore(source, cursor + 1) };
+}
+function asyncBefore(source, at) {
+  let cursor = at - 1;
+  while (cursor >= 0 && /[\s*]/.test(source[cursor])) cursor -= 1;
+  const end = cursor + 1;
+  while (cursor >= 0 && /[\w$]/.test(source[cursor])) cursor -= 1;
+  return source.slice(cursor + 1, end) === "async";
+}
+function innermost(list, at) {
+  return enclosing(list, at)[0] ?? null;
+}
+function enclosing(list, at) {
+  return list.filter((item) => at > item.open && at <= item.close).sort((a, b) => b.open - a.open);
+}
+function enclosingArguments(source, structure, at) {
+  const body = innermost(
+    structure.blocks.filter((block) => block.fn && block.params !== null),
+    at
+  );
+  if (!body?.params) return null;
+  return parameterExpression(source.slice(body.params.open + 1, body.params.close));
+}
+function awaitAllowed(structure, at) {
+  const body = innermost(
+    structure.blocks.filter((block) => block.fn),
+    at
+  );
+  return body ? body.async : null;
+}
+function planCheckpoints(files, read, toolKeys) {
+  const plans = [];
+  const outstanding = new Set(toolKeys);
+  if (outstanding.size === 0) return plans;
+  for (const file of files) {
+    if (outstanding.size === 0) break;
+    if (file.endsWith(".py") || !JS_EXTENSIONS.test(file)) continue;
+    const source = read(file);
+    if (source === null) continue;
+    const present = [...outstanding].filter(
+      (key) => source.includes(key) || source.includes(camelOf(key))
+    );
+    if (present.length === 0) continue;
+    const structure = readStructure(source);
+    const lineOf = lineLocator2(source);
+    const alias = chooseAliasFor(source, "checkpoint", "js");
+    const sites = /* @__PURE__ */ new Map();
+    for (const key of present) {
+      const site = checkpointSite(source, key, structure);
+      if (!site) continue;
+      const existing = sites.get(site.at);
+      if (existing) existing.keys.push(key);
+      else sites.set(site.at, { keys: [key], site });
+    }
+    if (sites.size === 0) continue;
+    const edits = [];
+    const placed = [];
+    for (const [at, { keys, site }] of sites) {
+      if (/^\s*(?:await\s+)?[A-Za-z_$]*[cC]heckpoint\(/.test(source.slice(at, at + 200))) continue;
+      const many = keys.length > 1;
+      const keyExpression = many && site.keyExpression ? site.keyExpression : quote(keys[0] ?? "");
+      if (many && !site.keyExpression) continue;
+      const args = site.argsExpression ? `, ${site.argsExpression}` : "";
+      edits.push({
+        start: at,
+        end: at,
+        text: `
+${blockIndent(source, at)}await ${alias}(${keyExpression}${args});`
+      });
+      for (const key of keys) {
+        placed.push({
+          key,
+          line: lineOf(at),
+          shape: site.shape,
+          ...many ? { dynamic: true } : {}
+        });
+        outstanding.delete(key);
+      }
+    }
+    if (edits.length === 0) continue;
+    const after = addJsSdkImport(applyEdits(source, edits), "checkpoint", alias);
+    plans.push({ file, before: source, after, placed });
+  }
+  return plans;
+}
+function checkpointSite(source, key, structure) {
+  const quoted = `['"\`]${escapeForRegex(key)}['"\`]`;
+  const usable = (at) => awaitAllowed(structure, at) === true;
+  const bodyAfter = (close) => {
+    const brace = /^\s*\{/.exec(source.slice(close + 1, close + 200));
+    return brace ? close + 1 + brace[0].length : null;
+  };
+  for (const match of source.matchAll(new RegExp(`\\bcase\\s+${quoted}\\s*:`, "g"))) {
+    const colon = (match.index ?? 0) + match[0].length;
+    const braced = /^\s*\{/.exec(source.slice(colon));
+    const at = braced ? colon + braced[0].length : colon;
+    if (!usable(at)) continue;
+    const discriminant = switchKey(source, match.index ?? 0);
+    return {
+      at,
+      shape: "case",
+      argsExpression: discriminant ? argumentsOf(source, discriminant.object) : null,
+      keyExpression: discriminant?.expression ?? null
+    };
+  }
+  for (const match of source.matchAll(new RegExp(quoted, "g"))) {
+    const at = match.index ?? 0;
+    if (!positiveComparison(source, at)) continue;
+    const group = enclosing(structure.parens, at).find(
+      (candidate) => BRANCH_KEYWORDS.has(candidate.name)
+    );
+    if (!group) continue;
+    const insertAt = bodyAfter(group.close);
+    if (insertAt === null || !usable(insertAt)) continue;
+    const compared = comparedExpression(source, at);
+    const loop = group.name === "for" ? loopVariable(source, group.open) : null;
+    const subject = loop ?? compared?.object ?? null;
+    return {
+      at: insertAt,
+      shape: group.name === "if" ? "branch" : "loop",
+      argsExpression: subject ? argumentsOf(source, subject) : enclosingArguments(source, structure, insertAt),
+      keyExpression: loop ? `${loop}.name` : compared?.expression ?? null
+    };
+  }
+  const declaration = new RegExp(
+    `\\b(?:const|let|var)\\s+([A-Za-z_$][\\w$]*)\\s*(?::[^=\\n]{0,120})?=[^;\\n]{0,400}?${quoted}[^;]{0,200}?;`,
+    "g"
+  );
+  for (const match of source.matchAll(declaration)) {
+    const name = match[1];
+    const end = (match.index ?? 0) + match[0].length;
+    const block = innermost(structure.blocks, end);
+    const limit = block ? block.close : source.length;
+    const head = new RegExp(`\\bif\\s*\\(\\s*${escapeForRegex(name)}\\b`).exec(
+      source.slice(end, limit)
+    );
+    if (!head) continue;
+    const parenOpen = end + (head.index ?? 0) + head[0].indexOf("(");
+    const group = structure.parens.find((candidate) => candidate.open === parenOpen);
+    if (!group) continue;
+    const insertAt = bodyAfter(group.close);
+    if (insertAt === null || !usable(insertAt)) continue;
+    return {
+      at: insertAt,
+      shape: "found",
+      argsExpression: argumentsOf(source, name),
+      keyExpression: `${name}.name`
+    };
+  }
+  const handler = new RegExp(
+    `${quoted}\\s*:\\s*(?:async\\s*)?\\(([^)]{0,200})\\)\\s*(?::[^=>{]{0,120})?=>\\s*\\{`,
+    "g"
+  );
+  for (const match of source.matchAll(handler)) {
+    const at = (match.index ?? 0) + match[0].length;
+    if (!usable(at)) continue;
+    return {
+      at,
+      shape: "handler",
+      argsExpression: parameterExpression(match[1] ?? ""),
+      keyExpression: null
+    };
+  }
+  const named = new RegExp(
+    `\\basync\\s+function\\s+(?:${escapeForRegex(camelOf(key))}|${escapeForRegex(key)})\\s*\\(`,
+    "g"
+  );
+  for (const match of source.matchAll(named)) {
+    const parenOpen = (match.index ?? 0) + match[0].length - 1;
+    const group = structure.parens.find((candidate) => candidate.open === parenOpen);
+    if (!group) continue;
+    const body = structure.blocks.filter((block) => block.fn && block.open > group.close).sort((a, b) => a.open - b.open)[0];
+    if (!body) continue;
+    return {
+      at: body.open + 1,
+      shape: "function",
+      argsExpression: parameterExpression(source.slice(group.open + 1, group.close)),
+      keyExpression: null
+    };
+  }
+  return null;
+}
+function positiveComparison(source, at) {
+  const before = source.slice(Math.max(0, at - 96), at);
+  return /(?<![!<>])={2,3}\s*$/.test(before);
+}
+function comparedExpression(source, at) {
+  const before = source.slice(Math.max(0, at - 160), at);
+  const match = /([A-Za-z_$][\w$]*)\s*(?:\?\.|\.)\s*([A-Za-z_$][\w$]*)\s*={2,3}\s*$/.exec(before);
+  if (!match) return null;
+  return { object: match[1], expression: `${match[1]}.${match[2]}` };
+}
+function switchKey(source, at) {
+  const before = source.slice(Math.max(0, at - 4e3), at);
+  const found = [
+    ...before.matchAll(/\bswitch\s*\(\s*([A-Za-z_$][\w$]*)\s*(?:\?\.|\.)\s*([A-Za-z_$][\w$]*)/g)
+  ];
+  const last = found[found.length - 1];
+  return last ? { object: last[1], expression: `${last[1]}.${last[2]}` } : null;
+}
+function loopVariable(source, parenOpen) {
+  return /^\s*\(\s*(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s+of\b/.exec(
+    source.slice(parenOpen, parenOpen + 120)
+  )?.[1] ?? null;
+}
+function parameterExpression(parameters) {
+  const names = parameters.split(",").map((part) => /^\s*(?:\.\.\.)?([A-Za-z_$][\w$]*)/.exec(part)?.[1]).filter((name) => name !== void 0);
+  const named = names.find((name) => CHECKPOINT_ARG_PROPERTIES.includes(name));
+  if (named) return named;
+  return names.length === 1 ? names[0] : null;
+}
+function camelOf(key) {
+  return key.replace(/_([a-z0-9])/g, (_match, char) => char.toUpperCase());
+}
+function argumentsOf(source, object) {
+  for (const property of CHECKPOINT_ARG_PROPERTIES) {
+    const pattern = new RegExp(`\\b${escapeForRegex(object)}\\s*(?:\\?\\.|\\.)\\s*${property}\\b`);
+    if (pattern.test(source)) return `${object}.${property}`;
+  }
+  return null;
+}
+function blockIndent(source, at) {
+  const lineEnd = source.indexOf("\n", at);
+  if (lineEnd >= 0) {
+    const next = /^([ \t]*)\S/.exec(source.slice(lineEnd + 1, lineEnd + 200));
+    if (next && !source.slice(lineEnd + 1).trimStart().startsWith("}"))
+      return next[1];
+  }
+  const lineStart = source.lastIndexOf("\n", at) + 1;
+  return `${/^[ \t]*/.exec(source.slice(lineStart, at))?.[0] ?? ""}  `;
+}
 function unguardJs(source) {
-  const imported = jsGuardImport(source);
-  if (!imported) return { after: source, removed: 0, leftovers: [] };
+  const checkpoints = uncheckpointJs(source);
+  const imported = jsGuardImport(checkpoints.after);
+  if (!imported) return checkpoints;
+  source = checkpoints.after;
   const { alias } = imported;
   const lineOf = lineLocator2(source);
   const edits = [];
-  const leftovers = [];
+  const leftovers = [...checkpoints.leftovers];
   const calls = new RegExp(`(?<![\\w$.])${escapeForRegex(alias)}\\s*\\(`, "g");
   for (const match of source.matchAll(calls)) {
     const start = match.index ?? 0;
@@ -6076,14 +7085,62 @@ function unguardJs(source) {
   }
   let after = applyEdits(source, edits);
   const stillUsed = new RegExp(`(?<![\\w$.])${escapeForRegex(alias)}\\s*\\(`).test(after);
-  if (!stillUsed) after = removeJsGuardImport(after);
-  return { after, removed: edits.length, leftovers };
+  if (!stillUsed) after = removeJsSdkImport(after, "guard");
+  return { after, removed: edits.length + checkpoints.removed, leftovers };
+}
+function uncheckpointJs(source) {
+  const alias = existingImport(source, "checkpoint", "js");
+  if (!alias) return { after: source, removed: 0, leftovers: [] };
+  const lineOf = lineLocator2(source);
+  const leftovers = [];
+  let removed = 0;
+  const key = `(?:(['"\`])[a-z][a-z0-9_]*\\1|[A-Za-z_$][\\w$]*(?:\\s*(?:\\?\\.|\\.)\\s*[A-Za-z_$][\\w$]*)+)`;
+  let after = source.replace(
+    new RegExp(
+      `^[ \\t]*(?:await[ \\t]+)?${escapeForRegex(alias)}\\(\\s*${key}[^\\n]*\\)[ \\t]*;?[ \\t]*\\r?\\n`,
+      "gm"
+    ),
+    () => {
+      removed += 1;
+      return "";
+    }
+  );
+  for (const match of after.matchAll(
+    new RegExp(`(?<![\\w$.])${escapeForRegex(alias)}\\s*\\(`, "g")
+  )) {
+    leftovers.push({
+      line: lineOf(match.index ?? 0),
+      text: after.slice(match.index ?? 0, (match.index ?? 0) + 80).split("\n")[0] ?? ""
+    });
+  }
+  if (leftovers.length === 0) after = removeJsSdkImport(after, "checkpoint");
+  return { after, removed, leftovers };
 }
 function unguardPython(source) {
   const imported = /^from[ \t]+veefore[ \t]+import[ \t]+([^\n]+)$/m.exec(source);
   if (!imported) return { after: source, removed: 0, leftovers: [] };
-  const spec = (imported[1] ?? "").replace(/[()]/g, "").split(",").map((part) => /^guard(?:\s+as\s+(\w+))?$/.exec(part.trim())).find((found) => found !== null);
-  if (!spec) return { after: source, removed: 0, leftovers: [] };
+  const names = (imported[1] ?? "").replace(/[()]/g, "").split(",");
+  const spec = names.map((part) => /^guard(?:\s+as\s+(\w+))?$/.exec(part.trim())).find((found) => found !== null);
+  const gate = names.map((part) => /^checkpoint(?:\s+as\s+(\w+))?$/.exec(part.trim())).find((found) => found !== null);
+  if (!spec && !gate) return { after: source, removed: 0, leftovers: [] };
+  if (!spec) {
+    const alias2 = gate?.[1] ?? "checkpoint";
+    let removed2 = 0;
+    let after2 = source.replace(
+      new RegExp(
+        `^[ \\t]*${escapeForRegex(alias2)}\\(\\s*(['"])[a-z][a-z0-9_]*\\1[^\\n]*\\)[ \\t]*\\r?\\n`,
+        "gm"
+      ),
+      () => {
+        removed2 += 1;
+        return "";
+      }
+    );
+    if (!new RegExp(`(?<![\\w.])${escapeForRegex(alias2)}\\s*\\(`).test(after2)) {
+      after2 = removePythonImport(after2, alias2);
+    }
+    return { after: after2, removed: removed2, leftovers: [] };
+  }
   const alias = spec[1] ?? "guard";
   const lineOf = lineLocator2(source);
   let removed = 0;
@@ -6122,18 +7179,20 @@ function unguardPython(source) {
   after = applyEdits(after, edits);
   removed += edits.length;
   const stillUsed = new RegExp(`(?<![\\w.])@?${escapeForRegex(alias)}\\s*\\(`).test(after);
-  if (!stillUsed) {
-    after = after.replace(
-      /^from[ \t]+veefore[ \t]+import[ \t]+([^\n]+)\r?\n?/m,
-      (line, names) => {
-        const rest = names.replace(/[()]/g, "").split(",").map((part) => part.trim()).filter((part) => part && !/^guard(?:\s+as\s+\w+)?$/.test(part));
-        return rest.length === 0 ? "" : `from veefore import ${rest.join(", ")}
-`;
-      }
-    );
-  }
+  if (!stillUsed) after = removePythonImport(after, "guard");
   return { after, removed, leftovers };
 }
+function removePythonImport(source, name) {
+  const target = new RegExp(`^${escapeForRegex(name)}(?:\\s+as\\s+\\w+)?$`);
+  return source.replace(
+    /^from[ \t]+veefore[ \t]+import[ \t]+([^\n]+)\r?\n?/m,
+    (_line, names) => {
+      const rest = names.replace(/[()]/g, "").split(",").map((part) => part.trim()).filter((part) => part && !target.test(part));
+      return rest.length === 0 ? "" : `from veefore import ${rest.join(", ")}
+`;
+    }
+  );
+}
 function arrowExpressionBody(fn) {
   let cursor = 0;
   if (fn.startsWith("(")) {
@@ -6168,29 +7227,28 @@ function jsGuardImport(source) {
   }
   return null;
 }
-function removeJsGuardImport(source) {
-  const drop = (full, names, rebuild, isGuard) => {
-    const rest = names.split(",").map((part) => part.trim()).filter((part) => part && !isGuard.test(part));
+function removeJsSdkImport(source, name) {
+  const escaped = escapeForRegex(name);
+  const drop = (names, rebuild, target) => {
+    const rest = names.split(",").map((part) => part.trim()).filter((part) => part && !target.test(part));
     return rest.length === 0 ? "" : rebuild(rest);
   };
   let after = source.replace(
     /^[ \t]*import\s*\{([^}]*)\}\s*from\s*(['"])@veefore\/sdk\2\s*;?[ \t]*\r?\n?/m,
-    (full, names, quote2) => drop(
-      full,
+    (_full, names, quote2) => drop(
       names,
       (rest) => `import { ${rest.join(", ")} } from ${quote2}@veefore/sdk${quote2};
 `,
-      /^guard(\s+as\s+[\w$]+)?$/
+      new RegExp(`^${escaped}(\\s+as\\s+[\\w$]+)?$`)
     )
   );
   after = after.replace(
     /^[ \t]*const\s*\{([^}]*)\}\s*=\s*require\(\s*(['"])@veefore\/sdk\2\s*\)\s*;?[ \t]*\r?\n?/m,
-    (full, names, quote2) => drop(
-      full,
+    (_full, names, quote2) => drop(
       names,
       (rest) => `const { ${rest.join(", ")} } = require(${quote2}@veefore/sdk${quote2});
 `,
-      /^guard(\s*:\s*[\w$]+)?$/
+      new RegExp(`^${escaped}(\\s*:\\s*[\\w$]+)?$`)
     )
   );
   return after;
@@ -6201,22 +7259,35 @@ function escapeForRegex(value) {
 function isGuarded(value, alias) {
   return new RegExp(`^\\s*(${alias}|guard|veeforeGuard)\\(`).test(value);
 }
-var JS_GUARD_IMPORT = /import\s*\{[^}]*\bguard\b(?:\s+as\s+([A-Za-z_$][\w$]*))?[^}]*\}\s*from\s*['"]@veefore\/sdk['"]/;
-var CJS_GUARD_IMPORT = /\{[^}]*\bguard\b(?:\s*:\s*([A-Za-z_$][\w$]*))?[^}]*\}\s*=\s*require\(\s*['"]@veefore\/sdk['"]\s*\)/;
-var PY_GUARD_IMPORT = /^from\s+veefore\s+import\s+[^\n]*\bguard\b(?:\s+as\s+(\w+))?/m;
-function existingGuardImport(source, language) {
+function existingImport(source, name, language) {
+  const escaped = escapeForRegex(name);
   if (language === "py") {
-    const match2 = PY_GUARD_IMPORT.exec(source);
-    return match2 ? match2[1] ?? "guard" : null;
-  }
-  const match = JS_GUARD_IMPORT.exec(source) ?? CJS_GUARD_IMPORT.exec(source);
-  return match ? match[1] ?? "guard" : null;
+    const match2 = new RegExp(
+      `^from\\s+veefore\\s+import\\s+[^\\n]*\\b${escaped}\\b(?:\\s+as\\s+(\\w+))?`,
+      "m"
+    ).exec(source);
+    return match2 ? match2[1] ?? name : null;
+  }
+  const esm = new RegExp(
+    `import\\s*\\{[^}]*\\b${escaped}\\b(?:\\s+as\\s+([A-Za-z_$][\\w$]*))?[^}]*\\}\\s*from\\s*['"]@veefore/sdk['"]`
+  ).exec(source);
+  const cjs = new RegExp(
+    `\\{[^}]*\\b${escaped}\\b(?:\\s*:\\s*([A-Za-z_$][\\w$]*))?[^}]*\\}\\s*=\\s*require\\(\\s*['"]@veefore/sdk['"]\\s*\\)`
+  ).exec(source);
+  const match = esm ?? cjs;
+  return match ? match[1] ?? name : null;
 }
-function chooseAlias(source, language) {
-  const existing = existingGuardImport(source, language);
+function existingGuardImport(source, language) {
+  return existingImport(source, "guard", language);
+}
+function chooseAliasFor(source, name, language) {
+  const existing = existingImport(source, name, language);
   if (existing) return existing;
-  if (!/\bguard\b/.test(source)) return "guard";
-  return language === "py" ? "veefore_guard" : "veeforeGuard";
+  if (!new RegExp(`\\b${escapeForRegex(name)}\\b`).test(source)) return name;
+  return language === "py" ? `veefore_${name}` : `veefore${name[0]?.toUpperCase() ?? ""}${name.slice(1)}`;
+}
+function chooseAlias(source, language) {
+  return chooseAliasFor(source, "guard", language);
 }
 function applyEdits(source, edits) {
   let out2 = source;
@@ -6225,14 +7296,22 @@ function applyEdits(source, edits) {
   }
   return out2;
 }
-function schemaOnly(source, python, wanted) {
+var SCHEMA_ONLY_REASON = "this is only the schema; guard the code that runs the tool the model picked (often one dispatch function for every tool)";
+function schemaOnly(source, python, wanted, placed = /* @__PURE__ */ new Set()) {
   const lineOf = lineLocator2(source);
-  return findToolSchemas(source, python).filter((hit) => wanted.has(toToolKey(hit.name))).map((hit) => ({
-    key: toToolKey(hit.name),
-    line: lineOf(hit.index),
-    status: "manual",
-    reason: "this is only the schema; guard the code that runs the tool the model picked (often one dispatch function for every tool)"
-  }));
+  const hits = [
+    ...findToolSchemas(source, python).map((hit) => ({ name: hit.name, index: hit.index })),
+    ...python ? [] : findFunctionToolSchemas(source).map((hit) => ({ name: hit.name, index: hit.index }))
+  ].sort((a, b) => a.index - b.index);
+  const changes = [];
+  const seen = new Set(placed);
+  for (const hit of hits) {
+    const key = toToolKey(hit.name);
+    if (!wanted.has(key) || seen.has(key)) continue;
+    seen.add(key);
+    changes.push({ key, line: lineOf(hit.index), status: "manual", reason: SCHEMA_ONLY_REASON });
+  }
+  return changes;
 }
 function dedupeChanges(changes) {
   const seen = /* @__PURE__ */ new Set();
@@ -6352,10 +7431,55 @@ function myers(a, b) {
 
 // src/integrate.ts
 async function integrate(root, toolKeys, options) {
-  const plan = planRewrite(root, listSourceFiles(root), toolKeys);
+  const index = indexFiles(root);
+  const anchors = [...toolKeyAnchors(toolKeys), ...TOOL_ANCHORS, ...GUARD_ANCHORS];
+  const candidates = shortlist(root, index, anchors);
+  const sourceFiles = candidates.files;
+  const truncated = index.truncated || candidates.truncated;
   const interactive = options.interactive ?? (process.stdin.isTTY === true && process.stdout.isTTY === true && !options.yes);
-  const dispatchGuardFiles = findDispatchGuards(readSources(root));
+  if (truncated && !options.quiet) {
+    out(
+      `${symbol.warn} The search ran out of time before it finished, so a tool may be reported as not found, or the place it runs may be missed.`
+    );
+  }
+  const sources = readSources(root, sourceFiles);
+  const dispatchGuardFiles = findDispatchGuards(sources);
   const dispatchGuarded = dispatchGuardFiles.length > 0;
+  const alreadyGuarded = guardedToolKeys(sources, toolKeys);
+  const reconcile = (result) => {
+    for (const file of result.files) {
+      for (const change of file.changes) {
+        if (change.status === "manual" && alreadyGuarded.has(change.key)) {
+          change.status = "already";
+          delete change.reason;
+        }
+      }
+    }
+    return result;
+  };
+  let plan = reconcile(planRewrite(root, sourceFiles, toolKeys));
+  const changeable = [
+    ...new Set(
+      plan.files.flatMap(
+        (file) => file.changes.filter((change) => change.status !== "already").map((change) => change.key)
+      )
+    )
+  ];
+  const selected = await chooseTools(changeable, plan, {
+    requested: options.tools,
+    interactive,
+    quiet: options.quiet === true
+  });
+  const skipped = changeable.filter((key) => !selected.includes(key));
+  if (skipped.length > 0) {
+    plan = reconcile(
+      planRewrite(
+        root,
+        sourceFiles,
+        toolKeys.filter((key) => !skipped.includes(key))
+      )
+    );
+  }
   let manual = plan.files.flatMap(
     (file) => file.changes.filter((change) => change.status === "manual").map((change) => ({
       file: file.file,
@@ -6379,7 +7503,7 @@ async function integrate(root, toolKeys, options) {
     }
     dispatch = [];
   } else if (dispatch.length > 0) {
-    dispatchPlan = planDispatch(listSourceFiles(root), (file) => currentText(root, plan, file), [
+    dispatchPlan = planDispatch(sourceFiles, (file) => currentText(root, plan, file), [
       ...new Set(dispatch.map((item) => item.key))
     ]);
     if (dispatchPlan?.after) {
@@ -6387,7 +7511,22 @@ async function integrate(root, toolKeys, options) {
       dispatch = [];
     }
   }
-  const dispatchKeys = [...new Set(dispatch.map((item) => item.key))];
+  if (dispatch.length > 0 && checkpointUsable(root, options.quiet === true)) {
+    const placed = applyCheckpoints(
+      plan,
+      planCheckpoints(sourceFiles, (file) => currentText(root, plan, file), [
+        ...new Set(dispatch.map((item) => item.key))
+      ])
+    );
+    dispatch = dispatch.filter((item) => !placed.has(item.key));
+  }
+  const runsElsewhere = (key) => {
+    const site = dispatchPlan?.sites?.get(key);
+    return site !== void 0 && site.file !== dispatchPlan?.file;
+  };
+  const dispatchKeys = [
+    ...new Set(dispatch.filter((item) => !runsElsewhere(item.key)).map((item) => item.key))
+  ];
   const dispatchItems = dispatchPlan ? dispatchKeys.map((key) => ({
     file: dispatchPlan?.file,
     key,
@@ -6395,7 +7534,7 @@ async function integrate(root, toolKeys, options) {
     reason: `guard the code that runs the tool: ${dispatchPlan?.reason ?? ""}`,
     language: languageOf(dispatchPlan?.file)
   })) : [];
-  const unplaced = dispatchPlan ? [] : dispatch;
+  const unplaced = dispatchPlan ? dispatch.filter((item) => runsElsewhere(item.key)) : dispatch;
   const pending = [...manual, ...dispatchItems];
   if (pending.length > 0 && !options.dryRun) {
     const hostedAvailable = await hostedEnabled(options.api ?? null);
@@ -6450,8 +7589,9 @@ async function integrate(root, toolKeys, options) {
           const entry = plan.files.find((file) => file.file === proposal.file);
           if (!entry) continue;
           entry.after = proposal.proposal;
+          const guarded = findGuardedKeys([{ file: proposal.file, text: proposal.proposal }]);
           for (const change of entry.changes) {
-            if (change.status === "manual" && proposal.keys.includes(change.key)) {
+            if (change.status === "manual" && guarded.has(change.key)) {
               change.status = "wrapped";
               change.via = "ai";
               delete change.reason;
@@ -6465,29 +7605,46 @@ async function integrate(root, toolKeys, options) {
     dispatch = remaining.filter(isDispatchItem);
     if (method !== "skip" && !options.quiet) {
       if (manual.length > 0) printManualInstructions(manual);
-      if (dispatch.length > 0) printDispatchInstructions(dispatch, dispatchPlan);
+      printDispatchInstructions([...dispatch, ...unplaced], dispatchPlan);
     }
   } else if (pending.length > 0 && !options.quiet) {
-    if (dispatchItems.length > 0) printDispatchInstructions(dispatchItems, dispatchPlan);
+    printDispatchInstructions([...dispatchItems, ...unplaced], dispatchPlan);
     dispatch = dispatchItems;
+  } else if (unplaced.length > 0 && !options.quiet && options.assist !== "skip") {
+    printDispatchInstructions(unplaced, dispatchPlan);
   }
-  if (unplaced.length > 0 && !options.quiet && options.assist !== "skip") {
-    printDispatchInstructions(unplaced, null);
-  }
-  manual = [...manual, ...dispatch, ...unplaced];
+  manual = stillManual([...manual, ...dispatch, ...unplaced], plan);
   const toWrite = plan.files.filter((file) => file.before !== file.after);
   const languages = new Set(toWrite.map((file) => file.file.endsWith(".py") ? "py" : "js"));
   if (!options.quiet) printPlan(plan);
   if (toWrite.length === 0) {
-    if (!options.quiet && !options.dryRun) {
+    const quiet = options.quiet === true || options.dryRun === true;
+    if (!quiet) {
       const guardedFiles = plan.files.filter((file) => file.changes.some((change) => change.status !== "manual")).map((file) => file.file);
       reportSdkReadiness(root, [.../* @__PURE__ */ new Set([...guardedFiles, ...dispatchGuardFiles])]);
     }
-    return { status: "nothing-to-do", plan, checks: [], backupId: null, manual };
+    const unguarded2 = reportProtection(root, sourceFiles, toolKeys, quiet);
+    return {
+      status: "nothing-to-do",
+      plan,
+      checks: [],
+      backupId: null,
+      manual,
+      unguarded: unguarded2,
+      skipped
+    };
   }
   if (options.dryRun) {
     out(style.grey("Dry run: nothing was written."));
-    return { status: "dry-run", plan, checks: [], backupId: null, manual };
+    return {
+      status: "dry-run",
+      plan,
+      checks: [],
+      backupId: null,
+      manual,
+      unguarded: reportProtection(root, sourceFiles, toolKeys, true),
+      skipped
+    };
   }
   if (!options.quiet) {
     reportSdkReadiness(
@@ -6501,7 +7658,15 @@ async function integrate(root, toolKeys, options) {
   );
   if (!proceed) {
     out(style.grey("No files were changed. Run `veefore integrate` when you are ready."));
-    return { status: "declined", plan, checks: [], backupId: null, manual };
+    return {
+      status: "declined",
+      plan,
+      checks: [],
+      backupId: null,
+      manual,
+      unguarded: reportProtection(root, sourceFiles, toolKeys, true),
+      skipped
+    };
   }
   const jsReady = languages.has("js") && sdkInstalled(root, "js");
   const baseline = jsReady ? typecheck(
@@ -6509,13 +7674,22 @@ async function integrate(root, toolKeys, options) {
     toWrite.map((file) => file.file)
   ) : null;
   for (const file of toWrite) {
-    if (readFileSync8(path9.join(root, file.file), "utf8") !== file.before) {
+    if (readFileSync9(path10.join(root, file.file), "utf8") !== file.before) {
       out(`${symbol.fail} ${file.file} changed while setup was running. Nothing was written.`);
-      return { status: "declined", plan, checks: [], backupId: null, manual };
+      return {
+        status: "declined",
+        plan,
+        checks: [],
+        backupId: null,
+        manual,
+        unguarded: reportProtection(root, sourceFiles, toolKeys, true),
+        skipped
+      };
     }
   }
   const backup = createBackup(root, toWrite);
-  for (const file of toWrite) writeFilePreservingMode(path9.join(root, file.file), file.after);
+  for (const file of toWrite) writeFilePreservingMode(path10.join(root, file.file), file.after);
+  forgetIndex(root);
   out(
     `${symbol.pass} Updated ${toWrite.length} file${toWrite.length === 1 ? "" : "s"} ${style.grey(`(backup ${backup.id})`)}`
   );
@@ -6571,7 +7745,15 @@ async function integrate(root, toolKeys, options) {
       `${symbol.warn} A check failed after the change, so every file was put back as it was ${style.grey(`(${restored.restored.length} restored)`)}.`
     );
     out(style.grey("  Please report this: the rewrite should never break a project."));
-    return { status: "rolled-back", plan, checks, backupId: null, manual };
+    return {
+      status: "rolled-back",
+      plan,
+      checks,
+      backupId: null,
+      manual,
+      unguarded: reportProtection(root, sourceFiles, toolKeys, true),
+      skipped
+    };
   }
   for (const language of languages) {
     if (!sdkInstalled(root, language)) {
@@ -6580,13 +7762,39 @@ async function integrate(root, toolKeys, options) {
       );
     }
   }
+  if (skipped.length > 0 && !options.quiet) {
+    out(
+      `${symbol.info} Left out of this run, as you chose: ${style.bold(skipped.join(", "))} ${style.grey("(no file was changed for these)")}`
+    );
+  }
+  const unguarded = reportProtection(root, sourceFiles, toolKeys, options.quiet === true);
   out(style.grey("  Undo at any time with `veefore undo`."));
-  return { status: "applied", plan, checks, backupId: backup.id, manual };
+  return { status: "applied", plan, checks, backupId: backup.id, manual, unguarded, skipped };
+}
+function reportProtection(root, files, toolKeys, quiet) {
+  const guarded = guardedToolKeys(readSources(root, files), toolKeys);
+  const unguarded = toolKeys.filter((key) => !guarded.has(key));
+  if (quiet) return unguarded;
+  if (unguarded.length === 0) {
+    out(
+      `${symbol.pass} Every registered tool goes through Veefore ${style.grey(`(${toolKeys.length})`)}`
+    );
+    return unguarded;
+  }
+  out(
+    `${symbol.warn} ${toolKeys.length - unguarded.length} of ${toolKeys.length} registered tools go through Veefore. Still unprotected: ${style.bold(unguarded.join(", "))}`
+  );
+  out(
+    style.grey(
+      "  The instructions above say what each one needs. Then `veefore integrate --check` to confirm."
+    )
+  );
+  return unguarded;
 }
 function reportSdkReadiness(root, files) {
   const problems = [];
   if (files.length === 0) return problems;
-  const dirs = [...new Set(files.map((file) => path9.dirname(file)))];
+  const dirs = [...new Set(files.map((file) => path10.dirname(file)))];
   const python = files.some((file) => file.endsWith(".py"));
   const sdks = installedSdks(root, { dirs, python });
   for (const sdk of sdks) {
@@ -6663,7 +7871,7 @@ async function removeGuards(root, options) {
   const tsFiles = changed.filter((file) => /\.(m|c)?tsx?$/.test(file));
   const baseline = tsFiles.length > 0 ? typecheck(root, tsFiles) : null;
   const backup = createBackup(root, toWrite);
-  for (const entry of toWrite) writeFilePreservingMode(path9.join(root, entry.file), entry.after);
+  for (const entry of toWrite) writeFilePreservingMode(path10.join(root, entry.file), entry.after);
   const checks = [];
   const py = changed.filter((file) => file.endsWith(".py"));
   if (py.length > 0) checks.push(pythonSyntax(root, py));
@@ -6687,7 +7895,7 @@ function currentText(root, plan, file) {
   const entry = plan.files.find((candidate) => candidate.file === file);
   if (entry) return entry.after;
   try {
-    return readFileSync8(path9.join(root, file), "utf8");
+    return readFileSync9(path10.join(root, file), "utf8");
   } catch {
     return null;
   }
@@ -6709,17 +7917,113 @@ function applyDispatch(root, plan, file, after, line, items, via) {
     entry.changes.push({ key, line, status: "wrapped", ...via ? { via } : {} });
   }
 }
-function readSources(root) {
-  return listSourceFiles(root).flatMap((file) => {
+function stillManual(items, plan) {
+  const open = new Set(
+    plan.files.flatMap(
+      (file) => file.changes.filter((change) => change.status === "manual").map((change) => change.key)
+    )
+  );
+  const seen = /* @__PURE__ */ new Set();
+  return items.filter((item) => {
+    if (!open.has(item.key)) return false;
+    const id = isDispatchItem(item) ? item.key : `${item.key}\0${item.file}`;
+    if (seen.has(id)) return false;
+    seen.add(id);
+    return true;
+  });
+}
+async function chooseTools(changeable, plan, options) {
+  if (options.requested) {
+    const asked = new Set(options.requested);
+    const unknown = options.requested.filter((key) => !changeable.includes(key));
+    if (unknown.length > 0 && !options.quiet) {
+      out(
+        `${symbol.warn} Nothing to change for: ${unknown.join(", ")} ${style.grey("(already protected, or not found in the code)")}`
+      );
+    }
+    return changeable.filter((key) => asked.has(key));
+  }
+  if (!options.interactive || changeable.length < 2) return changeable;
+  const where = /* @__PURE__ */ new Map();
+  for (const file of plan.files) {
+    for (const change of file.changes) {
+      if (change.status === "already" || where.has(change.key)) continue;
+      where.set(change.key, { line: change.line, file: file.file, status: change.status });
+    }
+  }
+  try {
+    return await selectMany(
+      "Which tools should Veefore decide for?",
+      changeable.map((key) => {
+        const at = where.get(key);
+        return {
+          label: key,
+          value: key,
+          hint: at ? `${at.status === "wrapped" ? "guard here" : "needs a change"} \xB7 ${at.file}:${at.line}` : ""
+        };
+      }),
+      { help: "All of them unless you say otherwise. Only what is ticked gets changed." }
+    );
+  } catch (error) {
+    if (error instanceof MenuCancelled) return [];
+    throw error;
+  }
+}
+function checkpointUsable(root, quiet) {
+  const sdks = installedSdks(root).filter((sdk) => sdk.language === "js");
+  const stale = sdks.filter((sdk) => !sdk.hasCheckpoint);
+  if (sdks.length === 0 || stale.length === 0) return true;
+  if (!quiet) {
+    out(
+      `${symbol.warn} Tools your code runs in a branch rather than a function are guarded with ${style.bold("checkpoint()")}, added in @veefore/sdk ${MIN_CHECKPOINT_SDK}. ${stale[0]?.version ?? "The installed version"} does not have it, so they are left for you.`
+    );
+    out(
+      `  Upgrade and re-run: ${style.bold(`${installCommand(root, "js")}@^${MIN_CHECKPOINT_SDK}`)}`
+    );
+  }
+  return false;
+}
+function applyCheckpoints(plan, plans) {
+  const placed = /* @__PURE__ */ new Set();
+  for (const checkpoint of plans) {
+    let entry = plan.files.find((candidate) => candidate.file === checkpoint.file);
+    if (!entry) {
+      entry = {
+        file: checkpoint.file,
+        before: checkpoint.before,
+        after: checkpoint.after,
+        changes: []
+      };
+      plan.files.push(entry);
+    }
+    entry.after = checkpoint.after;
+    for (const place of checkpoint.placed) {
+      placed.add(place.key);
+      entry.changes.push({
+        key: place.key,
+        line: place.line,
+        status: "wrapped",
+        via: "checkpoint"
+      });
+    }
+  }
+  for (const file of plan.files) {
+    file.changes = file.changes.filter(
+      (change) => !(change.status === "manual" && placed.has(change.key) && isDispatchItem({ reason: change.reason ?? "" }))
+    );
+  }
+  return placed;
+}
+function readSources(root, files = listSourceFiles(root)) {
+  return files.flatMap((file) => {
     try {
-      return [{ file, text: readFileSync8(path9.join(root, file), "utf8") }];
+      return [{ file, text: readFileSync9(path10.join(root, file), "utf8") }];
     } catch {
       return [];
     }
   });
 }
-function checkIntegration(root, toolKeys) {
-  const sources = readSources(root);
+function guardedToolKeys(sources, toolKeys) {
   const guarded = findGuardedKeys(sources);
   const dispatchFiles = findDispatchGuards(sources);
   if (dispatchFiles.length > 0) {
@@ -6734,6 +8038,16 @@ function checkIntegration(root, toolKeys) {
       }
     }
   }
+  return new Map([...guarded].filter(([key]) => toolKeys.includes(key)));
+}
+function checkIntegration(root, toolKeys) {
+  const index = indexFiles(root);
+  const candidates = shortlist(root, index, [
+    ...toolKeyAnchors(toolKeys),
+    ...TOOL_ANCHORS,
+    ...GUARD_ANCHORS
+  ]);
+  const guarded = guardedToolKeys(readSources(root, candidates.files), toolKeys);
   heading("Protection check");
   for (const key of toolKeys) {
     const file = guarded.get(key);
@@ -6796,22 +8110,31 @@ function printPlan(plan) {
   const wrapped = all.filter((entry) => entry.change.status === "wrapped");
   const already = all.filter((entry) => entry.change.status === "already");
   const manual = all.filter((entry) => entry.change.status === "manual");
+  const tools = (entries) => new Set(entries.map((e) => e.change.key)).size;
+  const keys = (entries) => [...new Set(entries.map((e) => e.change.key))];
   if (wrapped.length > 0) {
+    const count = tools(wrapped);
+    const only = new Set(wrapped.map((entry) => entry.change.via ?? "guard"));
+    const how = only.size === 1 && only.has("checkpoint") ? `gated with ${style.bold("checkpoint()")} where your code runs them` : `wrapped with ${style.bold("guard()")}`;
     out(
-      `${symbol.pass} ${wrapped.length} tool${wrapped.length === 1 ? "" : "s"} will be wrapped with ${style.bold("guard()")}, so Veefore decides each call:`
+      `${symbol.pass} ${count} tool${count === 1 ? "" : "s"} will be ${how}, so Veefore decides each call:`
     );
+    const note = {
+      ai: style.amber("proposed by AI \u2014 review the diff below"),
+      checkpoint: style.grey("guarded where your code runs it")
+    };
     for (const { file, change } of wrapped) {
       out(
-        `    ${style.bold(change.key.padEnd(24))} ${style.grey(`${file}:${change.line}`)}` + (change.via === "ai" ? ` ${style.amber("proposed by AI \u2014 review the diff below")}` : "")
+        `    ${style.bold(change.key.padEnd(24))} ${style.grey(`${file}:${change.line}`)}` + (change.via ? ` ${note[change.via] ?? ""}` : "")
       );
     }
   }
   if (already.length > 0) {
-    out(`${symbol.pass} Already protected: ${already.map((entry) => entry.change.key).join(", ")}`);
+    out(`${symbol.pass} Already protected: ${keys(already).join(", ")}`);
   }
   if (manual.length > 0) {
     out(
-      `${symbol.warn} Not changed automatically: ${manual.map((entry) => entry.change.key).join(", ")} ${style.grey("(see instructions above)")}`
+      `${symbol.warn} Not changed automatically: ${keys(manual).join(", ")} ${style.grey("(see instructions above)")}`
     );
   }
   if (plan.notFound.length > 0) {
@@ -6833,8 +8156,8 @@ function printPlan(plan) {
 }
 
 // src/commands/remove.ts
-import { rmSync as rmSync3 } from "node:fs";
-import path10 from "node:path";
+import { rmSync as rmSync4 } from "node:fs";
+import path11 from "node:path";
 
 // src/discover.ts
 var LOCAL_CANDIDATE_PORTS = [4e3, 4400, 4100, 4200, 4300, 4500, 8e3, 8080, 3e3];
@@ -6948,7 +8271,7 @@ async function removeCommand(args, flags, known) {
   if (!file || !config) {
     throw new CliError("This project is not connected to Veefore.", "There is nothing to remove.");
   }
-  const root = path10.dirname(file);
+  const root = path11.dirname(file);
   const state = known ?? await agentState(config);
   heading("Remove Veefore from this project");
   details([
@@ -6999,7 +8322,7 @@ async function removeCommand(args, flags, known) {
     out(style.grey("The project stays connected."));
     return 0;
   }
-  rmSync3(file);
+  rmSync4(file);
   const envRemoved = removeLocalEnvBlock(root);
   out(
     `${symbol.pass} Disconnected: removed veefore.config.json${envRemoved ? " and the Veefore block in .env.local" : ""}.`
@@ -7026,10 +8349,20 @@ async function integrateCommand(args, flags) {
   let assist;
   let dryRun = false;
   let check = false;
+  let tools;
   for (const arg of args) {
     if (arg === "--dry-run") dryRun = true;
     else if (arg === "--check") check = true;
-    else if (arg.startsWith("--assist=")) {
+    else if (arg === "--tools=all") tools = void 0;
+    else if (arg.startsWith("--tools=")) {
+      tools = arg.slice("--tools=".length).split(",").map((key) => key.trim()).filter((key) => key !== "");
+      if (tools.length === 0) {
+        throw new CliError(
+          "`--tools` takes a comma-separated list of tool keys, or `all`.",
+          "For example: --tools=refund_order,adjust_stock"
+        );
+      }
+    } else if (arg.startsWith("--assist=")) {
       const value = ASSIST_VALUES[arg.slice("--assist=".length)];
       if (!value) {
         throw new CliError(
@@ -7072,7 +8405,8 @@ async function integrateCommand(args, flags) {
     dryRun,
     quiet: flags.json,
     assist,
-    api
+    api,
+    ...tools ? { tools } : {}
   });
   if (flags.json) {
     out(
@@ -7083,6 +8417,8 @@ async function integrateCommand(args, flags) {
           files: outcome.plan.files.map((file) => ({ file: file.file, changes: file.changes })),
           not_found: outcome.plan.notFound,
           manual: outcome.manual,
+          unguarded: outcome.unguarded,
+          skipped: outcome.skipped,
           checks: outcome.checks
         },
         null,
@@ -7482,10 +8818,10 @@ async function resolveAuthorizedTools(context, filter) {
 
 // src/panel.ts
 import { homedir as homedir2 } from "node:os";
-import path11 from "node:path";
+import path12 from "node:path";
 
 // src/version.ts
-var CLI_VERSION = "1.4.1";
+var CLI_VERSION = "1.6.0";
 
 // src/panel.ts
 function welcomeSource(flags = {}) {
@@ -7509,7 +8845,7 @@ function welcomeSource(flags = {}) {
 }
 function tilde(dir) {
   const home = homedir2();
-  return dir === home || dir.startsWith(`${home}${path11.sep}`) ? `~${dir.slice(home.length)}` : dir;
+  return dir === home || dir.startsWith(`${home}${path12.sep}`) ? `~${dir.slice(home.length)}` : dir;
 }
 function hostOf(url) {
   try {
@@ -7576,7 +8912,7 @@ function planTool(tool) {
 }
 function printScan(scan) {
   out(
-    `${symbol.pass} Scanned ${scan.filesScanned} file${scan.filesScanned === 1 ? "" : "s"}` + (scan.truncated ? style.amber(" (limit reached; findings may be incomplete)") : "") + style.grey(" \u2014 locally, nothing was uploaded")
+    `${symbol.pass} Searched ${scan.filesScanned.toLocaleString("en-US")} file${scan.filesScanned === 1 ? "" : "s"}, read ${scan.filesParsed.toLocaleString("en-US")}` + (scan.truncated ? style.amber(" (ran out of time; findings may be incomplete)") : "") + style.grey(" \u2014 locally, nothing was uploaded")
   );
   if (scan.tools.length === 0) {
     out(`${symbol.warn} No tools found, so there is nothing for Veefore to decide on yet.`);
@@ -7609,6 +8945,40 @@ function printScan(scan) {
       `${symbol.warn} Your code reads ${service.length} credential${service.length === 1 ? "" : "s"}: ${service.map((s) => s.name).join(", ")} ${style.grey("(names only; values were not read)")}`
     );
   }
+  printGaps(scan);
+}
+function printGaps(scan) {
+  let discovery;
+  try {
+    discovery = discoverAgents(scan.root, scan);
+  } catch {
+    return;
+  }
+  if (discovery.agents.length > 1) {
+    out();
+    out(`${symbol.info} ${discovery.agents.length} agents found in this project:`);
+    for (const agent of discovery.agents) {
+      out(
+        `    ${style.bold(agent.name ?? agent.directory)} ${style.grey(`${agent.directory} \u2014 ${agent.tools.length} tool${agent.tools.length === 1 ? "" : "s"}`)}`
+      );
+    }
+    out(style.grey("    Set each one up from its own directory, so its tools stay its own."));
+  }
+  if (discovery.unreadable.length === 0) return;
+  const shown = discovery.unreadable.slice(0, 5);
+  out();
+  out(
+    `${symbol.warn} ${discovery.unreadable.length} file${discovery.unreadable.length === 1 ? "" : "s"} look${discovery.unreadable.length === 1 ? "s" : ""} like agent code whose tools could not be read:`
+  );
+  for (const gap of shown) out(`    ${style.grey(`${gap.file}:${gap.line}`)}`);
+  if (discovery.unreadable.length > shown.length) {
+    out(style.grey(`    \u2026and ${discovery.unreadable.length - shown.length} more`));
+  }
+  out(
+    style.grey(
+      "    Tools defined in a shape this scan does not know are not protected. Register them\n    in the console by hand, or report the shape so it can be detected."
+    )
+  );
 }
 function printPlan2(plan, environment) {
   out();
@@ -8570,7 +9940,7 @@ async function initCommand(args, flags) {
 }
 function previousApprovalMode(dir = process.cwd()) {
   try {
-    const text = readFileSync9(path12.join(dir, ".env.local"), "utf8");
+    const text = readFileSync10(path13.join(dir, ".env.local"), "utf8");
     const value = /^\s*VEEFORE_APPROVAL_MODE\s*=\s*['"]?(\w+)/m.exec(text)?.[1]?.toLowerCase();
     return value === "wait" || value === "throw" ? value : null;
   } catch {