@moda-ai/cli 1.55.73 → 1.55.74

package/dist/{cli-h5ar0v9v.js → cli-82dggtv9.js}

@@ -109,10 +109,10 @@ import {
 } from "./cli-0v6na3yp.js";
 
 // src/harness-extract/enumerators/agents.ts
-var import_typescript12 = __toESM(require_typescript(), 1);
+var import_typescript14 = __toESM(require_typescript(), 1);
 
 // src/harness-extract/index.ts
-var import_typescript10 = __toESM(require_typescript(), 1);
+var import_typescript13 = __toESM(require_typescript(), 1);
 import { resolve as resolve13 } from "node:path";
 
 // src/harness-extract/ast.ts
@@ -17641,6 +17641,103 @@ function hasDirective(text) {
   const plain = text.replace(/\{\{[^}]*\}\}/g, " ").trim();
   return DIRECTIVE_ANYWHERE.test(plain) || DIRECTIVE_VERB.test(plain);
 }
+var ERROR_TEXT = /^\s*(?:error\b|failed\b|could not\b|couldn't\b|cannot\b|can't\b|unable to\b|invalid\b|unknown\b|missing\b|not found\b)/i;
+function toolResultIsPrompt(owner, pieces) {
+  if (!owner)
+    return false;
+  if (import_typescript8.default.isShorthandPropertyAssignment(owner) || import_typescript8.default.isPropertyAssignment(owner) && !isNamedTableEntry(owner))
+    return false;
+  const own = pieces.map((piece) => piece.trim()).filter(Boolean);
+  if (own.length === 0)
+    return false;
+  const text = withoutLabels(own.join(`
+`));
+  if (own.every((piece) => ERROR_TEXT.test(piece)) && !IMPERATIVE.test(text))
+    return false;
+  if (!hasDirective(text) && !IMPERATIVE.test(text))
+    return false;
+  const fn = import_typescript8.default.isFunctionLike(owner) ? owner : import_typescript8.default.isVariableDeclaration(owner) && owner.initializer && import_typescript8.default.isFunctionLike(unwrapNode(owner.initializer)) ? unwrapNode(owner.initializer) : undefined;
+  return !fn || isTextBuilder(fn);
+}
+function isNamedTableEntry(property) {
+  const object = property.parent;
+  if (object.properties.some((entry) => entry.name && import_typescript8.default.isIdentifier(entry.name) && entry.name.text === "type"))
+    return false;
+  let node = object;
+  while (import_typescript8.default.isObjectLiteralExpression(node) || import_typescript8.default.isPropertyAssignment(node) || import_typescript8.default.isParenthesizedExpression(node) || import_typescript8.default.isAsExpression(node) || import_typescript8.default.isSatisfiesExpression(node) || import_typescript8.default.isTypeAssertionExpression(node)) {
+    node = node.parent;
+  }
+  return import_typescript8.default.isVariableDeclaration(node) || import_typescript8.default.isPropertyDeclaration(node) || import_typescript8.default.isExportAssignment(node);
+}
+function withoutLabels(text) {
+  return text.replace(/\{\{[^}]*\}\}/g, " ").replace(/(^|[.!?\n]\s*)[A-Za-z][\w -]{0,24}:(?=\s)/g, "$1");
+}
+var IMPERATIVE_VERBS = "keep|write|reply|respond|return|answer|use|include|output|list|describe|summari[sz]e|explain|decide|pick|choose|rate|score|label|extract|generate|draft|revise|rewrite|translate|tell|ask|call|check|verify|follow|format|limit|stop|continue|focus|consider|act|identify|compare|judge|review|repair|fix|plan|propose|suggest|recommend|find|search|read|treat|cite|flag|mark|rank|group|merge|drop|skip|wait|confirm|send|offer|share|re-share|lean|vary|retry|resend|retell|replace|unschedule|reschedule|reconnect|connect|attach|pass|move|open|try|run|re-run|rerun|load|save|update|delete|remove|add|create|edit|post|publish|schedule|mention|note|let|give|show|present|announce|surface|ping|text|message|forward|route|hand|escalate|report|log";
+var IMPERATIVE = new RegExp(`(?:^|[.!?:;\\n]\\s*|\\bif\\b[^.!?\\n]{0,160},\\s*)(?:then\\s+)?(?:${IMPERATIVE_VERBS})\\b`, "i");
+function unwrapNode(node) {
+  let current = node;
+  while (import_typescript8.default.isParenthesizedExpression(current) || import_typescript8.default.isAsExpression(current) || import_typescript8.default.isSatisfiesExpression(current))
+    current = current.expression;
+  return current;
+}
+function isTextBuilder(fn) {
+  const modifiers = import_typescript8.default.canHaveModifiers(fn) ? import_typescript8.default.getModifiers(fn) ?? [] : [];
+  if (modifiers.some((modifier) => modifier.kind === import_typescript8.default.SyntaxKind.AsyncKeyword))
+    return false;
+  const declared = fn.type?.getText().replace(/\s+/g, "");
+  if (declared && !/^(?:Promise<)?(?:(?:readonly)?string(?:\[\])?|null|undefined)(?:\|(?:(?:readonly)?string(?:\[\])?|null|undefined))*>?$/.test(declared))
+    return false;
+  let builder = true;
+  let returns = 0;
+  let failures = 0;
+  const visit = (node) => {
+    if (!builder)
+      return;
+    if (node !== fn && import_typescript8.default.isFunctionLike(node))
+      return;
+    if (import_typescript8.default.isAwaitExpression(node))
+      builder = false;
+    else if (import_typescript8.default.isReturnStatement(node) && node.expression) {
+      if (returnsRecord(node.expression))
+        builder = false;
+      returns += 1;
+      if (ERROR_TEXT.test(leadingText(node.expression)))
+        failures += 1;
+      import_typescript8.default.forEachChild(node, visit);
+    } else
+      import_typescript8.default.forEachChild(node, visit);
+  };
+  const body = fn.body;
+  if (body && !import_typescript8.default.isBlock(body))
+    return !returnsRecord(body);
+  if (body)
+    import_typescript8.default.forEachChild(body, visit);
+  return builder && !(returns > 1 && failures > 0 && takesContext(fn));
+}
+function takesContext(fn) {
+  return fn.parameters.some((parameter) => {
+    const name = import_typescript8.default.isIdentifier(parameter.name) ? parameter.name.text : "";
+    return /^(?:ctx|context|env|sql|db|tx)$/.test(name) || /(?:Context|Env)\b/.test(parameter.type?.getText() ?? "");
+  });
+}
+function leadingText(expr) {
+  const value = unwrapNode(expr);
+  if (import_typescript8.default.isStringLiteral(value) || import_typescript8.default.isNoSubstitutionTemplateLiteral(value))
+    return value.text;
+  if (import_typescript8.default.isTemplateExpression(value))
+    return value.head.text;
+  if (import_typescript8.default.isBinaryExpression(value) && value.operatorToken.kind === import_typescript8.default.SyntaxKind.PlusToken)
+    return leadingText(value.left);
+  return "";
+}
+function returnsRecord(expr) {
+  const value = unwrapNode(expr);
+  if (import_typescript8.default.isObjectLiteralExpression(value))
+    return true;
+  if (import_typescript8.default.isConditionalExpression(value))
+    return returnsRecord(value.whenTrue) || returnsRecord(value.whenFalse);
+  return value.kind === import_typescript8.default.SyntaxKind.TrueKeyword || value.kind === import_typescript8.default.SyntaxKind.FalseKeyword || import_typescript8.default.isNumericLiteral(value);
+}
 function isInstructionDescription(text) {
   if (text.length >= 2000)
     return true;
@@ -17792,7 +17889,7 @@ class PromptResolver {
       const line = `${ref.path}:${ref.line}`;
       firstOnLine.set(line, Math.min(firstOnLine.get(line) ?? Infinity, ref.start));
     }
-    const refs = [...this.refs.values()].map(({ pieces, start, ...ref }) => {
+    const refs = [...this.refs.values()].filter((ref) => this.keepAll || ref.role !== "tool-result" || toolResultIsPrompt(ref.ownerNode, [...ref.pieces.values()])).map(({ pieces, start, ownerNode: _owner, ...ref }) => {
       const later = start > firstOnLine.get(`${ref.path}:${ref.line}`);
       const column = later ? this.columnOf(ref.path, start) : undefined;
       return {
@@ -18369,7 +18466,8 @@ class PromptResolver {
         hops: walk.hops,
         via: [...walk.flags],
         pieces: new Map,
-        start: anchor.getStart(sf)
+        start: anchor.getStart(sf),
+        ...owner ? { ownerNode: owner.node } : {}
       };
       this.refs.set(key, ref);
     }
@@ -18390,6 +18488,15 @@ class PromptResolver {
       return;
     return this.relative(resolvePath(dirname7(statement.getSourceFile().fileName), spec.replace(/\?raw$/, "")));
   }
+  preferModelRole(ref, walk) {
+    const toolPath = walk.role === "tool-result" || walk.role === "tool-description";
+    if (ref.role === "tool-result" && !toolPath) {
+      ref.role = walk.role;
+      ref.hops = walk.hops;
+      ref.via = [...walk.flags];
+    }
+    return ref.role === "tool-result" || walk.role !== "tool-result";
+  }
   fileRef(path, walk) {
     if (TEST_SOURCE.test(path))
       return;
@@ -18399,9 +18506,11 @@ class PromptResolver {
       ref = { id, path, line: 1, endLine: 1, start: 0, kind: "file", role: walk.role, text: "", callSiteIds: [], hops: walk.hops, via: [...walk.flags], pieces: new Map };
       this.refs.set(id, ref);
     }
+    const counts = this.preferModelRole(ref, walk);
     if (!ref.callSiteIds.includes(walk.site.id))
       ref.callSiteIds.push(walk.site.id);
-    ref.via = ref.via.filter((f) => walk.flags.includes(f));
+    if (counts)
+      ref.via = ref.via.filter((f) => walk.flags.includes(f));
   }
   markUnresolved(node, reason, walk) {
     const sf = node.getSourceFile();
@@ -19037,7 +19146,7 @@ async function runHarnessCommand(context) {
         throw new CliInputError("Focused remote prompt analysis is not supported yet.", "Use local --analyst=claude|codex|cursor|local-scan, or drop --concern for a full remote report.");
       }
       if (context.flags["github-actions"] === "true") {
-        const { runGithubActionsAnalyze } = await import("./harness-github-actions-p4011crc.js");
+        const { runGithubActionsAnalyze } = await import("./harness-github-actions-m26tapfj.js");
         const result = await runGithubActionsAnalyze(rootDir, {
           writeReport: (report2) => {
             const normalized = normalizeHarnessReport(report2);
@@ -19183,8 +19292,8 @@ async function runHarnessCommand(context) {
         }
         const { artifacts, unknowns } = deterministicGraphItems(rootDir, promote === "all" ? undefined : promote);
         tagComponentStatus({ runtimeAgents: [], artifacts }, rootDir);
-        const { extractHarnessWithContext: extractHarnessWithContext2 } = await import("./index-4z7h9mam.js");
-        const { enumerateHarnessComponents, mergeEnumeratedComponents } = await import("./index-femt9s00.js");
+        const { extractHarnessWithContext: extractHarnessWithContext2 } = await import("./index-cpz85prt.js");
+        const { enumerateHarnessComponents, mergeEnumeratedComponents } = await import("./index-0wm7157z.js");
         let components = { runtimeAgents: [], artifacts: [], warnings: [] };
         if (promote === "all" || promote === "topology" || promote === "tools") {
           const { result, ctx } = extractHarnessWithContext2(rootDir);
@@ -19218,8 +19327,8 @@ async function runHarnessCommand(context) {
     }
     case "extract": {
       writeHumanProgress(context, "Harness extract: tracing model call sites (no LLM, no network)...");
-      const { extractHarnessWithContext: extractHarnessWithContext2, serializeExtractResult } = await import("./index-4z7h9mam.js");
-      const { enumerateHarnessComponents, mergeEnumeratedComponents } = await import("./index-femt9s00.js");
+      const { extractHarnessWithContext: extractHarnessWithContext2, serializeExtractResult } = await import("./index-cpz85prt.js");
+      const { enumerateHarnessComponents, mergeEnumeratedComponents } = await import("./index-0wm7157z.js");
       const { result, ctx } = extractHarnessWithContext2(rootDir, { fresh: true });
       const artifacts = deterministicArtifacts(rootDir);
       tagComponentStatus({ runtimeAgents: [], artifacts }, rootDir);
@@ -26642,165 +26751,1130 @@ function collectModelLiterals(rootDir) {
   return { literals: [...found].sort(), truncated: capped || skipped };
 }
 
-// src/harness-extract/types.ts
-var EXTRACT_SCHEMA_VERSION = 1;
-// src/harness-extract/tools.ts
-var PASS_THROUGH2 = new Set(["ref", "call", "param", "oneOf", "lookup"]);
-var DEFINITION_KEYS = new Set(["description", "input_schema", "inputSchema", "parameters", "schema", "execute", "type", "strict"]);
-function member(tree, key) {
-  const members = tree.children ?? [];
-  for (let index = members.length - 1;index >= 0; index -= 1)
-    if (members[index].key === key)
-      return members[index];
-  return;
-}
-function singleLiteral2(tree) {
-  if (!tree)
-    return;
-  if (tree.kind === "literal")
-    return tree.text;
-  if (PASS_THROUGH2.has(tree.kind)) {
-    const flow = valueChildren(tree);
-    if (flow.length === 1)
-      return singleLiteral2(flow[0]);
-  }
-  return;
-}
-function objectsOf(tree) {
-  if (tree.kind === "object")
-    return [tree];
-  if (PASS_THROUGH2.has(tree.kind))
-    return valueChildren(tree).flatMap(objectsOf);
-  return [];
-}
-function definitionName(tree) {
-  const fn = member(tree, "function");
-  const fnObject = fn ? objectsOf(fn)[0] : undefined;
-  const fnName = fnObject ? singleLiteral2(member(fnObject, "name")) : undefined;
-  if (fnName && fnObject)
-    return { name: fnName, path: fnObject.path, line: fnObject.line, via: "function.name" };
-  const nameNode = member(tree, "name");
-  const name = singleLiteral2(nameNode);
-  const keys = (tree.children ?? []).map((child) => child.key ?? "");
-  if (name && nameNode && keys.some((key) => DEFINITION_KEYS.has(key)))
-    return { name, path: nameNode.path, line: nameNode.line, via: "name" };
-  return;
-}
-function toolNamesOf(tree) {
-  const out = { names: [], unresolved: [] };
-  const visit = (node, inArray, names) => {
-    if (node.kind === "array" || node.kind === "assembled" && node.text === "array") {
-      for (const child of node.children ?? [])
-        visit(child, true, names);
-      return;
-    }
-    if (node.kind === "object") {
-      const definition = definitionName(node);
-      if (definition) {
-        names.push(definition);
-        return;
-      }
-      if (inArray) {
-        out.unresolved.push({ ...node, note: "tool object without a literal name" });
-        return;
+// src/harness-extract/emit-tools.ts
+var import_typescript12 = __toESM(require_typescript(), 1);
+import { existsSync as existsSync9 } from "node:fs";
+import { join as join14, posix as posix3 } from "node:path";
+
+// src/harness-extract/enumerators/common.ts
+var import_typescript10 = __toESM(require_typescript(), 1);
+import { readdirSync as readdirSync8, readFileSync as readFileSync15 } from "node:fs";
+import { dirname as dirname10, join as join13, posix as posix2, relative as relative10 } from "node:path";
+var cache = new WeakMap;
+var SKIP = new Set(["node_modules", "dist", "build", "out", "vendor", "coverage", "__pycache__"]);
+var TEST_PATH4 = /(?:^|\/)(?:test|tests|__tests__|test-fixtures|fixtures?|__fixtures__|__mocks__|e2e)\/|\.(?:test|spec)\.[cm]?[jt]sx?$/i;
+var EVAL_PATH2 = /(?:^|\/)evals?\/|\.evals?\.[cm]?[jt]sx?$/i;
+function enumerationRepository(ctx) {
+  const existing = cache.get(ctx);
+  if (existing)
+    return existing;
+  const files = [];
+  const walk = (dir) => {
+    for (const entry of readdirSync8(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+      const abs = join13(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!entry.name.startsWith(".") && !SKIP.has(entry.name))
+          walk(abs);
+      } else if (entry.isFile() && /\.(?:[cm]?[jt]sx?|py|jsonc?|toml)$/.test(entry.name) && !/\.d\.[cm]?ts$/.test(entry.name)) {
+        const path = relative10(ctx.rootDir, abs).split("\\").join("/");
+        try {
+          const text = readFileSync15(abs, "utf8");
+          if (text.length > 1024 * 1024)
+            continue;
+          const source = ctx.programFor(path)?.getSourceFile(abs) ?? import_typescript10.default.createSourceFile(abs, text, import_typescript10.default.ScriptTarget.Latest, true, path.endsWith("tsx") ? import_typescript10.default.ScriptKind.TSX : import_typescript10.default.ScriptKind.TS);
+          files.push({ path, text, source });
+        } catch {}
       }
-      const record = new Map;
-      const set = (hit) => {
-        record.delete(hit.name);
-        record.set(hit.name, hit);
-      };
-      for (const child of node.children ?? []) {
-        if (child.key === "...") {
-          const spread = [];
-          visit(child, false, spread);
-          spread.forEach(set);
-        } else if (child.key) {
-          set({ name: child.key, path: child.path, line: child.line, via: "key" });
-        }
+    }
+  };
+  walk(ctx.rootDir);
+  const workers = [];
+  const paths = new Set(files.map((file) => file.path));
+  const closure = (main) => {
+    const found = new Set, pending = [main];
+    for (let index = 0;index < pending.length; index++) {
+      const path = pending[index];
+      if (found.has(path))
+        continue;
+      found.add(path);
+      const file = files.find((entry) => entry.path === path);
+      if (!file)
+        continue;
+      for (const ref of import_typescript10.default.preProcessFile(file.text, true, true).importedFiles) {
+        if (!ref.fileName.startsWith("."))
+          continue;
+        const base = posix2.normalize(posix2.join(posix2.dirname(path), ref.fileName)).replace(/\.[cm]?js$/, "");
+        const target = [base, ...[".ts", ".tsx", ".js", ".mjs", "/index.ts", "/index.js"].map((suffix) => base + suffix)].find((candidate) => paths.has(candidate));
+        if (target)
+          pending.push(target);
       }
-      names.push(...record.values());
-      return;
     }
-    if (PASS_THROUGH2.has(node.kind) && valueChildren(node).length > 0) {
-      for (const child of valueChildren(node))
-        visit(child, inArray, names);
-      return;
+    return found;
+  };
+  for (const file of files)
+    if (/(?:^|\/)wrangler(?:\.[\w.-]+)?\.(?:jsonc?|toml)$/.test(file.path)) {
+      try {
+        const config2 = file.path.endsWith(".toml") ? parse(file.text) : JSON.parse(stripJsonc(file.text));
+        const variants = [["default", config2], ...Object.entries(config2.env ?? {}).map(([name, section]) => [name, { ...config2, ...section, queues: section.queues, workflows: section.workflows }])];
+        for (const [environment, section] of variants) {
+          if (typeof section.main !== "string" || isTestWorkerConfig({ path: file.path, name: section.name, mains: [section.main] }))
+            continue;
+          const main = posix2.normalize(posix2.join(dirname10(file.path), section.main));
+          workers.push({ id: `${file.path}#${environment}`, main, cron: Boolean(section.triggers?.crons?.length), queueBindings: new Set((section.queues?.producers ?? []).flatMap((producer) => typeof producer.binding === "string" ? [producer.binding] : [])), workflowClasses: (section.workflows ?? []).flatMap((binding) => typeof binding.class_name === "string" && !binding.script_name ? [binding.class_name] : []), files: closure(main) });
+        }
+      } catch {}
     }
-    out.unresolved.push(node);
+  const queueBindingsFor = (path) => {
+    const owners = workers.filter((worker) => worker.files.has(path));
+    return new Set(owners[0] ? [...owners[0].queueBindings].filter((binding) => owners.every((worker) => worker.queueBindings.has(binding))) : []);
   };
-  visit(tree, false, out.names);
-  return out;
-}
-
-// src/harness-extract/index.ts
-var PROMPT_ROLES = new Set(["system", "user", "messages", "prompt", "instructions", "questions"]);
-var MAX_HELPER_CALLERS = 200;
-var MAX_DERIVED = 5000;
-var MAX_CALLER_CHAIN = 3;
-var cache = new Map;
-function clearExtractCache() {
-  cache.clear();
+  const reach = buildImportGraphReachability(ctx.rootDir);
+  const repo = { files, workers, queueBindingsFor, cronEntrypoints: new Set(workers.filter((worker) => worker.cron).map((worker) => worker.main)), deployedFiles: reach.inProd, status: (path) => reach.inProd.has(path) || reach.reachable.has(path) ? "reachable" : "defined_only" };
+  cache.set(ctx, repo);
+  return repo;
 }
-function extractHarness(rootDir, options = {}) {
-  return extractHarnessWithContext(rootDir, options).result;
+function lineOf5(node) {
+  return node.getSourceFile().getLineAndCharacterOfPosition(node.getStart()).line + 1;
 }
-function extractHarnessWithContext(rootDir, options = {}) {
-  const root = resolve13(rootDir);
-  const { fresh, ...rest } = options;
-  const key = `${root}\x00${JSON.stringify(rest)}`;
-  const fingerprint = sourceFingerprint(root, rest);
-  const cached = fresh ? undefined : cache.get(key);
-  if (cached && cached.fingerprint === fingerprint)
-    return cached.output;
-  const output = runExtract(root, options);
-  cache.set(key, { output, fingerprint });
-  return output;
+function nameOf(node) {
+  if (!node)
+    return;
+  if (import_typescript10.default.isComputedPropertyName(node) && import_typescript10.default.isStringLiteralLike(node.expression))
+    return node.expression.text;
+  return import_typescript10.default.isIdentifier(node) || import_typescript10.default.isStringLiteralLike(node) || import_typescript10.default.isNumericLiteral(node) ? node.text : undefined;
 }
-function argRef(rootDir, node, key) {
-  const source = node.getSourceFile();
-  const ref = { path: relPath(rootDir, source.fileName), start: node.getStart(source), end: node.getEnd(), line: lineOf(node) };
-  if (key !== undefined)
-    ref.key = key;
-  Object.defineProperty(ref, "node", { value: node, enumerable: false });
-  return ref;
+function visit(node, fn) {
+  fn(node);
+  import_typescript10.default.forEachChild(node, (child) => visit(child, fn));
 }
-function namedEnclosingFunction(node) {
-  for (let fn = enclosingFunction(node);fn; fn = enclosingFunction(fn)) {
-    const name = functionName(fn);
-    if (name)
-      return { fn, name };
-  }
-  return;
+function componentId(kind, path, name) {
+  return `${kind}:${path}:${name}`;
 }
-function qualifiedName(fn, name) {
-  const cls = enclosingClass(fn);
-  const owner = cls && (fn.parent === cls || fn.parent && fn.parent.parent === cls) ? className(cls) : undefined;
-  return owner ? `${owner}.${name}` : name;
+function artifact(type, name, file, node, reason, status) {
+  return { id: componentId(type, file.path, name), type, name, scope: "shared", sourcePath: file.path, usedByAgentIds: [], confidence: 1, evidence: [{ path: file.path, line: lineOf5(node), reason }], status };
 }
-function functionScope(rootDir, fn, name) {
-  const parts = [qualifiedName(fn, name)];
-  const object = objectLiteralOf2(fn);
-  if (object) {
-    const holder = object.parent && import_typescript10.default.isVariableDeclaration(object.parent) && import_typescript10.default.isIdentifier(object.parent.name) ? object.parent.name.text : `L${lineOf(object)}`;
-    parts.unshift(holder);
-  }
-  for (let outer = namedEnclosingFunction(object ?? fn);outer; outer = namedEnclosingFunction(outer.fn))
-    parts.unshift(qualifiedName(outer.fn, outer.name));
-  return `${relPath(rootDir, fn.getSourceFile().fileName)}#${parts.join(".")}`;
+function agent(name, file, node, reason, status) {
+  return { id: componentId("agent", file.path, name), name, kind: "runtime_agent", root: ".", entrypointIds: [], channelAdapterIds: [], artifactIds: [], identityNamespaceIds: [], deploymentIds: [], frameworkIds: [], modelProviderIds: [], confidence: 1, evidence: [{ path: file.path, line: lineOf5(node), reason }], status };
 }
-function objectLiteralOf2(fn) {
-  const member2 = import_typescript10.default.isMethodDeclaration(fn) || import_typescript10.default.isGetAccessorDeclaration(fn) || import_typescript10.default.isSetAccessorDeclaration(fn) ? fn : import_typescript10.default.isPropertyAssignment(fn.parent) ? fn.parent : undefined;
-  return member2 && import_typescript10.default.isObjectLiteralExpression(member2.parent) ? member2.parent : undefined;
+function emptyResult() {
+  return { runtimeAgents: [], artifacts: [], warnings: [] };
 }
-function scopeOf(rootDir, node) {
-  const named = namedEnclosingFunction(node);
-  if (named)
-    return functionScope(rootDir, named.fn, named.name);
-  const path = relPath(rootDir, node.getSourceFile().fileName);
-  let outermost;
-  for (let fn = enclosingFunction(node);fn; fn = enclosingFunction(fn))
-    outermost = fn;
-  return outermost ? `${path}#L${lineOf(outermost)}` : path;
+function stableResult(result) {
+  const unique2 = (values) => [...new Map(values.map((x) => [x.id, x])).values()].sort((a, b) => a.id.localeCompare(b.id));
+  return { runtimeAgents: unique2(result.runtimeAgents), artifacts: unique2(result.artifacts), warnings: [...new Set(result.warnings)].sort() };
+}
+
+// src/harness-extract/tool-owners.ts
+var import_typescript11 = __toESM(require_typescript(), 1);
+var AGENT_BASES3 = new Set(["Think", "Agent", "AIChatAgent"]);
+var ROLE_FIELD = /^(?:role|roleId|roleName|kind|type|id|slug|agentRole|subagentRole)$/i;
+var MAX_HOPS = 10;
+var MIN_ALLOWLIST = 3;
+var TOOL_LIST_PARAM = /^(?:allow(?:list|ed)?|allowedTools|toolNames|tools|requested)$/i;
+var ALLOWLIST_SHARE = 0.6;
+function sourceFilesOf(ctx) {
+  const out = [];
+  for (const program of ctx.programs) {
+    for (const source of program.getSourceFiles()) {
+      if (source.isDeclarationFile || /[\\/]node_modules[\\/]/.test(source.fileName))
+        continue;
+      const rel2 = relPath(ctx.rootDir, source.fileName);
+      if (rel2.startsWith(".."))
+        continue;
+      if (ctx.programFor(source.fileName) !== program)
+        continue;
+      out.push({ program, source, rel: rel2 });
+    }
+  }
+  return out;
+}
+function isOneOffScript(rel2, reach) {
+  if (!/^scripts\//.test(rel2))
+    return false;
+  return !reach?.inProd.has(rel2);
+}
+
+class ToolOwners {
+  ctx;
+  classes = [];
+  byDeclaration = new Map;
+  references = new Map;
+  edges = new Map;
+  allowlists;
+  constructor(ctx) {
+    this.ctx = ctx;
+    const memo = createFrameworkMemo();
+    for (const { program, source, rel: rel2 } of sourceFilesOf(ctx)) {
+      if (isTestPath(rel2))
+        continue;
+      const checker = program.getTypeChecker();
+      const visit2 = (node) => {
+        if ((import_typescript11.default.isClassDeclaration(node) || import_typescript11.default.isClassExpression(node)) && node.name) {
+          let info;
+          try {
+            info = frameworkBaseOf(node, checker, memo);
+          } catch {
+            info = undefined;
+          }
+          if (info?.base && AGENT_BASES3.has(info.base)) {
+            const agent2 = {
+              name: node.name.text,
+              path: rel2,
+              line: lineOf(node.name),
+              abstract: Boolean(import_typescript11.default.getCombinedModifierFlags(node) & import_typescript11.default.ModifierFlags.Abstract),
+              base: info.base,
+              baseModule: info.module,
+              parent: superclassOf(node, checker),
+              declaration: node,
+              fields: classFields(node),
+              methods: new Set(node.members.filter((member) => import_typescript11.default.isMethodDeclaration(member) || import_typescript11.default.isGetAccessorDeclaration(member)).map((member) => propertyNameText(member.name) ?? ""))
+            };
+            this.classes.push(agent2);
+            this.byDeclaration.set(node, agent2);
+          }
+        }
+        import_typescript11.default.forEachChild(node, visit2);
+      };
+      visit2(source);
+    }
+  }
+  concrete() {
+    return this.classes.filter((agent2) => !agent2.abstract);
+  }
+  fieldOf(name, field) {
+    let current = this.classes.find((agent2) => agent2.name === name);
+    for (let hops = 0;current && hops < 10; hops += 1) {
+      if (field in current.fields)
+        return current.fields[field];
+      current = current.parent ? this.byDeclaration.get(current.parent) : undefined;
+    }
+    return;
+  }
+  inheritors(owner, method) {
+    const out = [];
+    for (const agent2 of this.classes) {
+      if (agent2.abstract)
+        continue;
+      let current = agent2;
+      let ok = false;
+      for (let hops = 0;current && hops < 10; hops += 1) {
+        if (current === owner) {
+          ok = true;
+          break;
+        }
+        if (method && current.methods.has(method))
+          break;
+        current = current.parent ? this.byDeclaration.get(current.parent) : undefined;
+      }
+      if (ok)
+        out.push(agent2.name);
+    }
+    return out;
+  }
+  ownersOf(node, program) {
+    const sets = { direct: new Set, rpc: new Set, open: new Set };
+    const start = this.positionOf(node, program);
+    if (!start)
+      return { direct: [], rpc: [], open: [] };
+    const seen = new Set;
+    let frontier = [{ position: start, via: "direct" }];
+    for (let hops = 0;frontier.length > 0 && hops <= MAX_HOPS; hops += 1) {
+      const next = [];
+      for (const { position, via } of frontier) {
+        for (const agent2 of position.agents)
+          sets[via].add(agent2);
+        const key = `${position.id}|${via}`;
+        if (seen.has(key))
+          continue;
+        seen.add(key);
+        for (const edge of this.edgesOf(position, program))
+          next.push({ position: edge.position, via: combineVia(via, edge.via) });
+      }
+      frontier = next;
+    }
+    const direct = [...sets.direct].sort();
+    return {
+      direct,
+      rpc: [...sets.rpc].filter((name) => !sets.direct.has(name)).sort(),
+      open: [...sets.open].filter((name) => !sets.direct.has(name)).sort()
+    };
+  }
+  positionOf(node, program) {
+    let method;
+    for (let current = node;current; current = current.parent) {
+      if ((import_typescript11.default.isMethodDeclaration(current) || import_typescript11.default.isGetAccessorDeclaration(current) || import_typescript11.default.isPropertyDeclaration(current)) && import_typescript11.default.isClassLike(current.parent) && import_typescript11.default.isIdentifier(current.name)) {
+        method = current.name;
+      }
+      if (import_typescript11.default.isClassLike(current)) {
+        const agent2 = this.byDeclaration.get(current);
+        if (!agent2)
+          return current.name ? this.holderPosition(current.name, program) : undefined;
+        const guards = fieldGuards(node, current);
+        const agents = this.inheritors(agent2, method?.text).filter((name) => guards.every((guard) => guard.holds(this.fieldOf(name, guard.field))));
+        const anchor = method ?? current;
+        return { id: nodeId(anchor), anchor, agents, agent: agent2, method };
+      }
+    }
+    const holder = holderName(node);
+    return holder ? this.holderPosition(holder, program) : undefined;
+  }
+  holderPosition(name, program) {
+    const target = valueDeclaration(resolvedSymbol(name, program.getTypeChecker())) ?? name.parent;
+    return { id: nodeId(target), anchor: target, agents: [], holder: name };
+  }
+  edgesOf(position, program) {
+    const cached = this.edges.get(position.id);
+    if (cached)
+      return cached;
+    const out = [];
+    this.edges.set(position.id, out);
+    const checker = program.getTypeChecker();
+    if (position.holder) {
+      for (const reference of this.referencesOf(program, position.holder.text)) {
+        if (reference === position.holder || isDeclarationName(reference))
+          continue;
+        if (valueDeclaration(resolvedSymbol(reference, checker)) !== position.anchor)
+          continue;
+        const next = this.positionOf(reference, program);
+        if (next)
+          out.push({ position: next, via: "direct" });
+      }
+    } else if (position.agent && position.method) {
+      const owner = position.agent;
+      const name = position.method.text;
+      const unique2 = this.classes.filter((agent2) => agent2.methods.has(name)).length === 1 && owner.methods.has(name);
+      const declaration = position.method.parent;
+      const takesToolList = import_typescript11.default.isMethodDeclaration(declaration) && declaration.parameters.some((param) => import_typescript11.default.isIdentifier(param.name) && TOOL_LIST_PARAM.test(param.name.text));
+      for (const reference of this.referencesOf(program, name)) {
+        const access = reference.parent;
+        if (!access || !import_typescript11.default.isPropertyAccessExpression(access) || access.name !== reference)
+          continue;
+        if (access.expression.kind === import_typescript11.default.SyntaxKind.ThisKeyword) {
+          if (!isWithin3(reference, owner.declaration))
+            continue;
+          const next2 = this.positionOf(reference, program);
+          if (next2)
+            out.push({ position: { ...next2, agents: [] }, via: "direct" });
+          continue;
+        }
+        if (!unique2 || !import_typescript11.default.isCallExpression(access.parent) || access.parent.expression !== access)
+          continue;
+        const resolved = valueDeclaration(resolvedSymbol(reference, checker));
+        if (resolved && resolved.parent !== owner.declaration)
+          continue;
+        const next = this.positionOf(reference, program);
+        if (next)
+          out.push({ position: next, via: takesToolList ? "open" : "rpc" });
+      }
+    }
+    return out;
+  }
+  referencesOf(program, name) {
+    let index = this.references.get(program);
+    if (!index) {
+      index = new Map;
+      for (const source of program.getSourceFiles()) {
+        if (source.isDeclarationFile || /[\\/]node_modules[\\/]/.test(source.fileName))
+          continue;
+        if (isTestPath(relPath(this.ctx.rootDir, source.fileName)))
+          continue;
+        const visit2 = (node) => {
+          if (import_typescript11.default.isIdentifier(node)) {
+            const list = index.get(node.text);
+            if (list)
+              list.push(node);
+            else
+              index.set(node.text, [node]);
+          }
+          import_typescript11.default.forEachChild(node, visit2);
+        };
+        visit2(source);
+      }
+      this.references.set(program, index);
+    }
+    return index.get(name) ?? [];
+  }
+  indexAllowlists(knownTools) {
+    this.allowlists = [];
+    for (const { program, source, rel: rel2 } of sourceFilesOf(this.ctx)) {
+      if (isTestPath(rel2))
+        continue;
+      const checker = program.getTypeChecker();
+      const visit2 = (node) => {
+        if (import_typescript11.default.isArrayLiteralExpression(node) && (!node.parent || !import_typescript11.default.isSpreadElement(node.parent))) {
+          const entries = stringEntries(node, checker);
+          const named = entries.filter((entry) => knownTools.has(entry) || entry.endsWith("*") && entry.length > 2);
+          if (entries.length >= MIN_ALLOWLIST && named.length / entries.length >= ALLOWLIST_SHARE) {
+            const agents = this.allowlistOwners(node, program);
+            if (agents.length > 0)
+              this.allowlists.push({ entries, agents, path: rel2 });
+          }
+        }
+        import_typescript11.default.forEachChild(node, visit2);
+      };
+      visit2(source);
+    }
+  }
+  allowlisted() {
+    return new Set((this.allowlists ?? []).flatMap((list) => list.agents));
+  }
+  agentsFor(tool, owners, allowlistApplies = () => true) {
+    const restricted = this.allowlisted();
+    const out = new Set([...owners.direct, ...owners.open, ...owners.rpc.filter((agent2) => !restricted.has(agent2)), ...this.allowlistAgents(tool, allowlistApplies)]);
+    return [...out].sort();
+  }
+  allowlistAgents(tool, applies = () => true) {
+    const out = new Set;
+    for (const list of this.allowlists ?? []) {
+      if (!applies(list.path))
+        continue;
+      if (list.entries.some((entry) => entry === tool || entry.endsWith("*") && tool.startsWith(entry.slice(0, -1)))) {
+        for (const agent2 of list.agents)
+          out.add(agent2);
+      }
+    }
+    return [...out].sort();
+  }
+  allowlistOwners(list, program) {
+    const keys = new Set;
+    const direct = new Set;
+    const checker = program.getTypeChecker();
+    const visited = new Set;
+    const walk = (node, hops) => {
+      if (hops > 4 || visited.has(node))
+        return;
+      visited.add(node);
+      for (let current = node.parent;current; current = current.parent) {
+        if (import_typescript11.default.isClassLike(current)) {
+          const agent2 = this.byDeclaration.get(current);
+          if (agent2)
+            for (const name of this.inheritors(agent2, undefined))
+              direct.add(name);
+          return;
+        }
+        if (import_typescript11.default.isFunctionLike(current))
+          return;
+        if (import_typescript11.default.isPropertyAssignment(current) || import_typescript11.default.isShorthandPropertyAssignment(current)) {
+          const key = propertyNameText(current.name);
+          if (key)
+            keys.add(key);
+        }
+        if (import_typescript11.default.isObjectLiteralExpression(current)) {
+          for (const property of current.properties) {
+            if (!import_typescript11.default.isPropertyAssignment(property) || !ROLE_FIELD.test(propertyNameText(property.name) ?? ""))
+              continue;
+            const value = unwrap(property.initializer);
+            if (import_typescript11.default.isStringLiteral(value))
+              keys.add(value.text);
+          }
+        }
+        if (import_typescript11.default.isVariableDeclaration(current) && import_typescript11.default.isIdentifier(current.name)) {
+          const target = current;
+          for (const reference of this.referencesOf(program, current.name.text)) {
+            if (reference === current.name || isDeclarationName(reference))
+              continue;
+            if (valueDeclaration(resolvedSymbol(reference, checker)) !== target)
+              continue;
+            walk(reference, hops + 1);
+          }
+          return;
+        }
+      }
+    };
+    walk(list, 0);
+    for (const agent2 of this.concrete()) {
+      if (Object.entries(agent2.fields).some(([field, value]) => ROLE_FIELD.test(field) && keys.has(value)))
+        direct.add(agent2.name);
+    }
+    return [...direct].sort();
+  }
+}
+function combineVia(current, edge) {
+  if (current === "open" || edge === "open")
+    return "open";
+  if (current === "rpc" || edge === "rpc")
+    return "rpc";
+  return "direct";
+}
+function nodeId(node) {
+  return `${node.getSourceFile().fileName}:${node.getStart()}`;
+}
+function fieldGuards(node, cls) {
+  const out = [];
+  let child = node;
+  for (let current = node.parent;current && current !== cls; child = current, current = current.parent) {
+    let condition;
+    let whenTrue;
+    if (import_typescript11.default.isConditionalExpression(current) && child !== current.condition) {
+      condition = current.condition;
+      whenTrue = child === current.whenTrue;
+    } else if (import_typescript11.default.isIfStatement(current) && child !== current.expression) {
+      condition = current.expression;
+      whenTrue = child === current.thenStatement;
+    }
+    if (!condition || whenTrue === undefined)
+      continue;
+    const test = unwrap(condition);
+    if (!import_typescript11.default.isBinaryExpression(test))
+      continue;
+    const op = test.operatorToken.kind;
+    const equal = op === import_typescript11.default.SyntaxKind.EqualsEqualsEqualsToken || op === import_typescript11.default.SyntaxKind.EqualsEqualsToken;
+    const notEqual = op === import_typescript11.default.SyntaxKind.ExclamationEqualsEqualsToken || op === import_typescript11.default.SyntaxKind.ExclamationEqualsToken;
+    if (!equal && !notEqual)
+      continue;
+    const sides = [unwrap(test.left), unwrap(test.right)];
+    const access = sides.find((side) => import_typescript11.default.isPropertyAccessExpression(side) && side.expression.kind === import_typescript11.default.SyntaxKind.ThisKeyword);
+    const literal = sides.find((side) => import_typescript11.default.isStringLiteral(side));
+    if (!access || !literal)
+      continue;
+    const wantEqual = equal === whenTrue;
+    const value = literal.text;
+    out.push({ field: access.name.text, holds: (actual) => actual === undefined || actual === value === wantEqual });
+  }
+  return out;
+}
+function isWithin3(node, container) {
+  for (let current = node;current; current = current.parent)
+    if (current === container)
+      return true;
+  return false;
+}
+function superclassOf(node, checker) {
+  const heritage = node.heritageClauses?.find((clause) => clause.token === import_typescript11.default.SyntaxKind.ExtendsKeyword)?.types[0];
+  if (!heritage)
+    return;
+  const expression = unwrap(heritage.expression);
+  const declaration = valueDeclaration(resolvedSymbol(import_typescript11.default.isPropertyAccessExpression(expression) ? expression.name : expression, checker));
+  return declaration && (import_typescript11.default.isClassDeclaration(declaration) || import_typescript11.default.isClassExpression(declaration)) ? declaration : undefined;
+}
+function classFields(node) {
+  const fields = {};
+  for (const member of node.members) {
+    if (!import_typescript11.default.isPropertyDeclaration(member) || !member.initializer)
+      continue;
+    const name = propertyNameText(member.name);
+    if (!name)
+      continue;
+    const value = unwrap(member.initializer);
+    if (import_typescript11.default.isStringLiteral(value) || import_typescript11.default.isNoSubstitutionTemplateLiteral(value))
+      fields[name] = value.text;
+    else if (value.kind === import_typescript11.default.SyntaxKind.TrueKeyword)
+      fields[name] = "true";
+    else if (value.kind === import_typescript11.default.SyntaxKind.FalseKeyword)
+      fields[name] = "false";
+  }
+  return fields;
+}
+function holderName(node) {
+  let found;
+  for (let current = node.parent;current; current = current.parent) {
+    if (import_typescript11.default.isFunctionDeclaration(current) && current.name)
+      return current.name;
+    if (import_typescript11.default.isVariableDeclaration(current) && import_typescript11.default.isIdentifier(current.name)) {
+      found = current.name;
+      const statement = current.parent?.parent;
+      if (statement && import_typescript11.default.isVariableStatement(statement) && import_typescript11.default.isSourceFile(statement.parent))
+        return found;
+      const init = current.initializer ? unwrap(current.initializer) : undefined;
+      if (init && (import_typescript11.default.isArrowFunction(init) || import_typescript11.default.isFunctionExpression(init)))
+        return found;
+    }
+  }
+  return found;
+}
+function isDeclarationName(identifier) {
+  const parent = identifier.parent;
+  if (!parent)
+    return false;
+  if (import_typescript11.default.isImportSpecifier(parent) || import_typescript11.default.isImportClause(parent) || import_typescript11.default.isNamespaceImport(parent) || import_typescript11.default.isExportSpecifier(parent))
+    return true;
+  return (import_typescript11.default.isVariableDeclaration(parent) || import_typescript11.default.isFunctionDeclaration(parent) || import_typescript11.default.isClassDeclaration(parent) || import_typescript11.default.isParameter(parent) || import_typescript11.default.isPropertyDeclaration(parent) || import_typescript11.default.isMethodDeclaration(parent)) && parent.name === identifier;
+}
+function stringEntries(expression, checker, depth = 0) {
+  if (depth > 4)
+    return [];
+  const value = unwrap(expression);
+  if (import_typescript11.default.isIdentifier(value)) {
+    const declaration = valueDeclaration(resolvedSymbol(value, checker));
+    return declaration && import_typescript11.default.isVariableDeclaration(declaration) && declaration.initializer ? stringEntries(declaration.initializer, checker, depth + 1) : [];
+  }
+  if (!import_typescript11.default.isArrayLiteralExpression(value))
+    return [];
+  const out = [];
+  for (const element of value.elements) {
+    if (import_typescript11.default.isSpreadElement(element)) {
+      out.push(...stringEntries(element.expression, checker, depth + 1));
+      continue;
+    }
+    const text = constantString(element, checker, depth);
+    if (text !== undefined)
+      out.push(text);
+  }
+  return out;
+}
+function constantString(expression, checker, depth) {
+  const value = unwrap(expression);
+  if (import_typescript11.default.isStringLiteral(value) || import_typescript11.default.isNoSubstitutionTemplateLiteral(value))
+    return value.text;
+  if (depth > 4)
+    return;
+  if (import_typescript11.default.isIdentifier(value)) {
+    const declaration = valueDeclaration(resolvedSymbol(value, checker));
+    return declaration && import_typescript11.default.isVariableDeclaration(declaration) && declaration.initializer ? constantString(declaration.initializer, checker, depth + 1) : undefined;
+  }
+  if (import_typescript11.default.isTemplateExpression(value)) {
+    let text = value.head.text;
+    for (const span of value.templateSpans) {
+      const part = constantString(span.expression, checker, depth + 1);
+      if (part === undefined)
+        return;
+      text += part + span.literal.text;
+    }
+    return text;
+  }
+  return;
+}
+
+// src/harness-extract/tools.ts
+var PASS_THROUGH2 = new Set(["ref", "call", "param", "oneOf", "lookup"]);
+var DEFINITION_KEYS = new Set(["description", "input_schema", "inputSchema", "parameters", "schema", "execute", "type", "strict"]);
+function member(tree, key) {
+  const members = tree.children ?? [];
+  for (let index = members.length - 1;index >= 0; index -= 1)
+    if (members[index].key === key)
+      return members[index];
+  return;
+}
+function singleLiteral2(tree) {
+  if (!tree)
+    return;
+  if (tree.kind === "literal")
+    return tree.text;
+  if (PASS_THROUGH2.has(tree.kind)) {
+    const flow = valueChildren(tree);
+    if (flow.length === 1)
+      return singleLiteral2(flow[0]);
+  }
+  return;
+}
+function objectsOf(tree) {
+  if (tree.kind === "object")
+    return [tree];
+  if (PASS_THROUGH2.has(tree.kind))
+    return valueChildren(tree).flatMap(objectsOf);
+  return [];
+}
+function definitionName(tree) {
+  const fn = member(tree, "function");
+  const fnObject = fn ? objectsOf(fn)[0] : undefined;
+  const fnName = fnObject ? singleLiteral2(member(fnObject, "name")) : undefined;
+  if (fnName && fnObject)
+    return { name: fnName, path: fnObject.path, line: fnObject.line, via: "function.name" };
+  const nameNode = member(tree, "name");
+  const name = singleLiteral2(nameNode);
+  const keys = (tree.children ?? []).map((child) => child.key ?? "");
+  if (name && nameNode && keys.some((key) => DEFINITION_KEYS.has(key)))
+    return { name, path: nameNode.path, line: nameNode.line, via: "name" };
+  return;
+}
+function toolNamesOf(tree) {
+  const out = { names: [], unresolved: [] };
+  const visit2 = (node, inArray, names) => {
+    if (node.kind === "array" || node.kind === "assembled" && node.text === "array") {
+      for (const child of node.children ?? [])
+        visit2(child, true, names);
+      return;
+    }
+    if (node.kind === "object") {
+      const definition = definitionName(node);
+      if (definition) {
+        names.push(definition);
+        return;
+      }
+      if (inArray) {
+        out.unresolved.push({ ...node, note: "tool object without a literal name" });
+        return;
+      }
+      const record = new Map;
+      const set = (hit) => {
+        record.delete(hit.name);
+        record.set(hit.name, hit);
+      };
+      for (const child of node.children ?? []) {
+        if (child.key === "...") {
+          const spread = [];
+          visit2(child, false, spread);
+          spread.forEach(set);
+        } else if (child.key) {
+          set({ name: child.key, path: child.path, line: child.line, via: "key" });
+        }
+      }
+      names.push(...record.values());
+      return;
+    }
+    if (PASS_THROUGH2.has(node.kind) && valueChildren(node).length > 0) {
+      for (const child of valueChildren(node))
+        visit2(child, inArray, names);
+      return;
+    }
+    out.unresolved.push(node);
+  };
+  visit2(tree, false, out.names);
+  return out;
+}
+
+// src/harness-extract/emit-tools.ts
+var SCHEMA_KEYS = ["input_schema", "inputSchema", "parameters", "output_schema"];
+var TOOL_BODY_KEYS = ["execute", "handler"];
+var TOOL_FACTORY = /^(?:tool|dynamicTool|agentTool|createTool|defineTool)$/;
+var TOOL_MODULE = /^(?:ai|agents(?:\/.*)?|@cloudflare\/[\w-]+(?:\/.*)?|@mastra\/[\w-]+|@ai-sdk\/[\w-]+|@openai\/agents(?:-core)?|@langchain\/[\w-]+)$/;
+var MODEL_FACING_NAME = /^[A-Za-z_][\w.:-]{0,127}$/;
+var MAX_NAMES_PER_SITE = 64;
+var MAX_TOOLS = 1e4;
+var MAX_EVIDENCE_PER_TOOL = 64;
+var MAX_DEFINITIONS_PER_TOOL = 64;
+var MAX_DEFINITION_BYTES = 8 * 1024 * 1024;
+var MAX_BODY_BYTES = 64000;
+function emitTools(result, ctx, options = {}) {
+  const owners = options.owners ?? new ToolOwners(ctx);
+  const agentForScope = createAgentScopeResolver(result, ctx);
+  let reach;
+  try {
+    reach = buildImportGraphReachability(ctx.rootDir);
+  } catch {
+    reach = undefined;
+  }
+  const skipPath = (rel2) => isTestPath(rel2) || isOneOffScript(rel2, reach);
+  const tracers = new Map;
+  const tracerFor = (program) => {
+    let tracer = tracers.get(program);
+    if (!tracer) {
+      const checker = program.getTypeChecker();
+      tracer = new ValueTracer(ctx.rootDir, checker, new CallIndex(program, checker), { maxDepth: 8, maxNodes: 400, maxCallers: 8 });
+      tracers.set(program, tracer);
+    }
+    return tracer;
+  };
+  const packageOf = workspacePackages(ctx.rootDir);
+  const found = new Map;
+  const ownersByTool = new Map;
+  let definitionBytes = 0;
+  const limit = () => {
+    const warning = "tools: bounded tool catalog budget reached; some evidence or bodies omitted";
+    if (!result.warnings.includes(warning))
+      result.warnings.push(warning);
+  };
+  const add = (name, via, evidence, toolOwners, definition, displayName, enclosing) => {
+    if (!MODEL_FACING_NAME.test(name))
+      return;
+    const pkg = packageOf(evidence.path);
+    const key = name;
+    let tool = found.get(key);
+    if (!tool) {
+      if (found.size >= MAX_TOOLS) {
+        limit();
+        return;
+      }
+      tool = { name, status: enumerationRepository(ctx).status(evidence.path) === "defined_only" ? "defined_only" : "reachable", ...pkg ? { package: pkg } : {}, via, evidence: [], agents: [], calledFrom: [], definitions: [] };
+      found.set(key, tool);
+      ownersByTool.set(key, { direct: [], rpc: [], open: [] });
+    }
+    if (enumerationRepository(ctx).status(evidence.path) !== "defined_only")
+      tool.status = "reachable";
+    if (tool.evidence.length < MAX_EVIDENCE_PER_TOOL && !tool.evidence.some((other) => other.path === evidence.path && other.line === evidence.line)) {
+      tool.evidence.push(evidence);
+      tool.calledFrom.push({ path: evidence.path, line: evidence.line, ...enclosing ? { enclosing } : {} });
+    }
+    if (definition) {
+      const source = definition.getSourceFile();
+      const path = relPath(ctx.rootDir, source.fileName), start = definition.getStart(source);
+      if (tool.definitions.length < MAX_DEFINITIONS_PER_TOOL && !tool.definitions.some((other) => other.path === path && other.start === start)) {
+        const text = Buffer.from(definition.getText(source));
+        if (text.length > MAX_BODY_BYTES) {
+          const warning = `tools: ${name} definition at ${path}:${lineOf(definition)} exceeds ${MAX_BODY_BYTES} bytes; its body is truncated`;
+          if (!result.warnings.includes(warning))
+            result.warnings.push(warning);
+        }
+        const body = text.subarray(0, Math.max(0, Math.min(MAX_BODY_BYTES, MAX_DEFINITION_BYTES - definitionBytes))).toString("utf8");
+        definitionBytes += Buffer.byteLength(body);
+        if (definitionBytes >= MAX_DEFINITION_BYTES)
+          limit();
+        tool.definitions.push({ path, start, end: definition.getEnd(), line: lineOf(definition), scope: scopeOf(ctx.rootDir, definition), body });
+      }
+    }
+    const merged = ownersByTool.get(key);
+    for (const agent2 of toolOwners.direct)
+      if (!merged.direct.includes(agent2))
+        merged.direct.push(agent2);
+    for (const agent2 of toolOwners.rpc)
+      if (!merged.rpc.includes(agent2))
+        merged.rpc.push(agent2);
+    for (const agent2 of toolOwners.open)
+      if (!merged.open.includes(agent2))
+        merged.open.push(agent2);
+    tool.displayName ??= displayName;
+  };
+  for (const { program, source, rel: rel2 } of sourceFilesOf(ctx)) {
+    if (skipPath(rel2))
+      continue;
+    const checker = program.getTypeChecker();
+    const tracer = tracerFor(program);
+    const names = (expression) => literalStrings(expression, tracer).slice(0, MAX_NAMES_PER_SITE);
+    const at = (node, reason) => ({ path: rel2, line: lineOf(node), reason });
+    const visitObject = (object) => {
+      const keys = object.properties.map((property) => propertyNameText(property.name) ?? "");
+      const nameExpr = propertyValue(object, "name");
+      if (nameExpr && SCHEMA_KEYS.some((key) => keys.includes(key)) && !isSchemaProperty(object)) {
+        const list = names(nameExpr);
+        if (list.length > 0) {
+          const span = registryEntryOf(object);
+          const agents = owners.ownersOf(span, program);
+          for (const name of list)
+            add(name, "definition", at(nameExpr, "tool definition (name beside its input schema)"), agents, span, displayNameOf(object, tracer), enclosingName(object));
+        }
+      }
+      const toolNameExpr = propertyValue(object, "toolName");
+      if (toolNameExpr && keys.includes("description")) {
+        const list = names(toolNameExpr);
+        if (list.length > 0) {
+          const agents = owners.ownersOf(object, program);
+          for (const name of list)
+            add(name, "role-table", at(toolNameExpr, "role table row naming the tool the model sees"), agents, object, displayNameOf(object, tracer), enclosingName(object));
+        }
+      }
+      for (const property of object.properties) {
+        if (!import_typescript12.default.isPropertyAssignment(property) || !isToolValue(property.initializer, checker))
+          continue;
+        const list = import_typescript12.default.isComputedPropertyName(property.name) ? names(property.name.expression) : [propertyNameText(property.name)].filter((key) => Boolean(key));
+        if (list.length === 0)
+          continue;
+        const agents = owners.ownersOf(property, program);
+        const options2 = toolOptions(property.initializer);
+        const definition = definitionNode(property.initializer, checker);
+        for (const name of list)
+          add(name, "record", at(property, "tools record key"), agents, definition, options2 ? displayNameOf(options2, tracer) : undefined, enclosingName(property));
+      }
+    };
+    const visit2 = (node) => {
+      try {
+        if (import_typescript12.default.isObjectLiteralExpression(node)) {
+          visitObject(node);
+        } else if (import_typescript12.default.isBinaryExpression(node) && node.operatorToken.kind === import_typescript12.default.SyntaxKind.EqualsToken && import_typescript12.default.isElementAccessExpression(node.left) && isToolValue(node.right, checker)) {
+          const list = names(node.left.argumentExpression);
+          if (list.length > 0) {
+            const agents = owners.ownersOf(node, program);
+            const options2 = toolOptions(node.right);
+            const definition = definitionNode(node.right, checker);
+            for (const name of list)
+              add(name, "record", at(node, "tool stored under this key"), agents, definition, options2 ? displayNameOf(options2, tracer) : undefined, enclosingName(node));
+          }
+        }
+      } catch {}
+      import_typescript12.default.forEachChild(node, visit2);
+    };
+    visit2(source);
+  }
+  for (const role of result.roles) {
+    if (role.role !== "tools" || role.sink.isTest || skipPath(role.sink.path))
+      continue;
+    const program = ctx.programFor(role.sink.path);
+    const siteOwners = program ? ownersAtSite(owners, program, role.sink.path, role.sink.line) : { direct: [], rpc: [], open: [] };
+    for (const hit of toolNamesOf(role.tree).names) {
+      if (skipPath(hit.path))
+        continue;
+      add(hit.name, "tools-arg", { path: hit.path, line: hit.line, reason: `named in the tools argument of ${role.sink.callee} at ${role.sink.path}:${role.sink.line}` }, siteOwners, undefined, undefined, role.sink.enclosing);
+    }
+  }
+  owners.indexAllowlists(new Set([...found.values()].map((tool) => tool.name)));
+  const callOwners = new Map;
+  for (const role of result.roles) {
+    if (role.role !== "tools" || role.sink.isTest || skipPath(role.sink.path))
+      continue;
+    const ids = agentForScope(role.sink.scope);
+    for (const hit of toolNamesOf(role.tree).names) {
+      let owners2 = callOwners.get(hit.name);
+      if (!owners2)
+        callOwners.set(hit.name, owners2 = new Set);
+      for (const id of ids)
+        owners2.add(id);
+    }
+  }
+  for (const [key, tool] of found) {
+    const ids = new Set;
+    for (const name of owners.agentsFor(tool.name, ownersByTool.get(key))) {
+      const classes = owners.classes.filter((entry) => entry.name === name);
+      if (classes.length === 1)
+        for (const id of agentForScope(`${classes[0].path}#${name}`))
+          ids.add(id);
+    }
+    for (const id of callOwners.get(tool.name) ?? [])
+      ids.add(id);
+    tool.agents = [...ids].sort();
+  }
+  return [...found.values()].sort((a, b) => a.name.localeCompare(b.name) || (a.package ?? "").localeCompare(b.package ?? ""));
+}
+function registryEntryOf(object) {
+  const parent = object.parent;
+  if (parent && import_typescript12.default.isPropertyAssignment(parent) && propertyNameText(parent.name) === "definition" && import_typescript12.default.isObjectLiteralExpression(parent.parent)) {
+    return parent.parent;
+  }
+  return object;
+}
+function definitionNode(expression, checker, depth = 0) {
+  const value = unwrap(expression);
+  if (import_typescript12.default.isCallExpression(value) || import_typescript12.default.isObjectLiteralExpression(value))
+    return value;
+  if (import_typescript12.default.isIdentifier(value) && depth < 2) {
+    const declaration = valueDeclaration(resolvedSymbol(value, checker));
+    if (declaration && import_typescript12.default.isVariableDeclaration(declaration) && declaration.initializer)
+      return definitionNode(declaration.initializer, checker, depth + 1);
+  }
+  return;
+}
+function ownersAtSite(owners, program, path, line) {
+  const source = program.getSourceFiles().find((file) => file.fileName.endsWith(`/${path}`) || file.fileName === path);
+  if (!source)
+    return { direct: [], rpc: [], open: [] };
+  const position = source.getPositionOfLineAndCharacter(Math.max(0, line - 1), 0);
+  let node = source;
+  const descend = (current) => {
+    for (const child of current.getChildren(source)) {
+      if (child.getStart(source) <= position && position < child.getEnd()) {
+        node = child;
+        descend(child);
+        return;
+      }
+    }
+  };
+  descend(source);
+  return owners.ownersOf(node, program);
+}
+function literalStrings(expression, tracer) {
+  const value = unwrap(expression);
+  if (import_typescript12.default.isStringLiteral(value) || import_typescript12.default.isNoSubstitutionTemplateLiteral(value))
+    return [value.text];
+  let tree;
+  try {
+    tree = tracer.trace(value);
+  } catch {
+    return [];
+  }
+  return [...new Set(renderings(tree, MAX_NAMES_PER_SITE).filter((text) => text.length > 0 && !text.includes("${...}")))];
+}
+function displayNameOf(object, tracer) {
+  for (const key of ["displayName", "title"]) {
+    const value = propertyValue(object, key);
+    if (!value)
+      continue;
+    const [text] = literalStrings(value, tracer);
+    if (text)
+      return text;
+  }
+  return;
+}
+function toolOptions(expression) {
+  const value = unwrap(expression);
+  if (import_typescript12.default.isObjectLiteralExpression(value))
+    return value;
+  if (import_typescript12.default.isCallExpression(value)) {
+    for (const argument of value.arguments) {
+      const inner = unwrap(argument);
+      if (import_typescript12.default.isObjectLiteralExpression(inner))
+        return inner;
+    }
+  }
+  return;
+}
+function enclosingName(node) {
+  const parts = [];
+  for (let current = node.parent;current; current = current.parent) {
+    if ((import_typescript12.default.isFunctionDeclaration(current) || import_typescript12.default.isMethodDeclaration(current)) && current.name && parts.length === 0) {
+      parts.unshift(propertyNameText(current.name) ?? "");
+    } else if (import_typescript12.default.isVariableDeclaration(current) && import_typescript12.default.isIdentifier(current.name) && parts.length === 0) {
+      parts.unshift(current.name.text);
+    } else if (import_typescript12.default.isClassLike(current) && current.name) {
+      parts.unshift(current.name.text);
+      break;
+    }
+  }
+  const joined = parts.filter(Boolean).join(".");
+  return joined || undefined;
+}
+function isSchemaProperty(object) {
+  const parent = object.parent;
+  if (!parent || !import_typescript12.default.isPropertyAssignment(parent))
+    return false;
+  const holder = parent.parent;
+  return import_typescript12.default.isObjectLiteralExpression(holder) && import_typescript12.default.isPropertyAssignment(holder.parent) && propertyNameText(holder.parent.name) === "properties";
+}
+function isToolValue(expression, checker, depth = 0) {
+  const value = unwrap(expression);
+  if (import_typescript12.default.isCallExpression(value)) {
+    const callee = unwrap(value.expression);
+    const name = import_typescript12.default.isIdentifier(callee) ? callee : import_typescript12.default.isPropertyAccessExpression(callee) ? callee.name : undefined;
+    if (!name)
+      return false;
+    if (TOOL_FACTORY.test(name.text))
+      return true;
+    if (import_typescript12.default.isIdentifier(callee)) {
+      const origin = importOrigin(callee, checker);
+      if (origin && TOOL_MODULE.test(origin.module) && /tool/i.test(origin.imported))
+        return true;
+    }
+    return false;
+  }
+  if (import_typescript12.default.isObjectLiteralExpression(value)) {
+    const keys = value.properties.map((property) => propertyNameText(property.name) ?? "");
+    return SCHEMA_KEYS.some((key) => keys.includes(key)) && TOOL_BODY_KEYS.some((key) => keys.includes(key)) && keys.includes("description") && !keys.includes("name");
+  }
+  if (import_typescript12.default.isIdentifier(value) && depth < 2) {
+    const declaration = valueDeclaration(resolvedSymbol(value, checker));
+    if (declaration && import_typescript12.default.isVariableDeclaration(declaration) && declaration.initializer && declaration.parent.flags & import_typescript12.default.NodeFlags.Const) {
+      return isToolValue(declaration.initializer, checker, depth + 1);
+    }
+  }
+  return false;
+}
+var emitted = new WeakMap;
+function emitToolsCached(result, ctx) {
+  let tools = emitted.get(result);
+  if (!tools) {
+    tools = emitTools(result, ctx);
+    emitted.set(result, tools);
+  }
+  return tools;
+}
+function toolArtifactId(name, pkg) {
+  const slug2 = (text) => text.replace(/[^A-Za-z0-9_.:-]+/g, "_");
+  return `tool.extract.${slug2(name)}`;
+}
+function workspacePackages(rootDir) {
+  const cache2 = new Map;
+  const lookup = (dir) => {
+    if (dir === "" || dir === ".")
+      return "";
+    const cached = cache2.get(dir);
+    if (cached !== undefined)
+      return cached;
+    const found = existsSync9(join14(rootDir, dir, "package.json")) ? dir : lookup(posix3.dirname(dir) === "." ? "" : posix3.dirname(dir));
+    cache2.set(dir, found);
+    return found;
+  };
+  return (rel2) => lookup(posix3.dirname(rel2) === "." ? "" : posix3.dirname(rel2));
+}
+function toolDefinitionRefs(tools) {
+  const out = [];
+  for (const tool of tools) {
+    const definition = tool.definitions[0];
+    if (!definition)
+      continue;
+    out.push({
+      toolId: toolArtifactId(tool.name, tool.package),
+      name: tool.name,
+      definition: { path: definition.path, start: definition.start, end: definition.end, line: definition.line },
+      ...tool.agents.length > 0 ? { agentIds: [...tool.agents] } : {},
+      scope: definition.scope
+    });
+  }
+  return out;
+}
+function toolArtifacts(tools, runtimeAgents = []) {
+  const knownIds = new Set(runtimeAgents.map((agent2) => agent2.id));
+  return tools.map((tool) => {
+    const usedByAgentIds = [...new Set(tool.agents.filter((id) => knownIds.has(id)))];
+    const artifact2 = {
+      id: toolArtifactId(tool.name, tool.package),
+      type: "tool",
+      name: tool.name,
+      status: tool.status,
+      scope: usedByAgentIds.length === 1 ? "agent" : "shared",
+      ...tool.definitions[0] ? { sourcePath: tool.definitions[0].path } : {},
+      ...tool.definitions[0] ? { body: tool.definitions[0].body } : {},
+      ...tool.definitions.length > 1 ? { definitionVariants: tool.definitions.map((definition) => ({ sourcePath: definition.path, body: definition.body, evidence: [{ path: definition.path, line: definition.line }] })) } : {},
+      usedByAgentIds,
+      confidence: 0.9,
+      confidenceReason: `Deterministic: model-facing tool name read from ${tool.via === "tools-arg" ? "a traced tools argument" : "its definition"} (call-site extractor).`,
+      evidence: tool.evidence.map((entry) => ({ path: entry.path, line: entry.line, reason: entry.reason })),
+      calledFrom: tool.calledFrom,
+      agentClasses: [...tool.agents],
+      ...tool.displayName ? { displayName: tool.displayName } : {}
+    };
+    return artifact2;
+  });
+}
+
+// src/harness-extract/types.ts
+var EXTRACT_SCHEMA_VERSION = 1;
+
+// src/harness-extract/index.ts
+var PROMPT_ROLES = new Set(["system", "user", "messages", "prompt", "instructions", "questions"]);
+var MAX_HELPER_CALLERS = 200;
+var MAX_DERIVED = 5000;
+var MAX_CALLER_CHAIN = 3;
+var cache2 = new Map;
+function clearExtractCache() {
+  cache2.clear();
+}
+function extractHarness(rootDir, options = {}) {
+  return extractHarnessWithContext(rootDir, options).result;
+}
+function extractHarnessWithContext(rootDir, options = {}) {
+  const root = resolve13(rootDir);
+  const { fresh, ...rest } = options;
+  const key = `${root}\x00${JSON.stringify(rest)}`;
+  const fingerprint = sourceFingerprint(root, rest);
+  const cached = fresh ? undefined : cache2.get(key);
+  if (cached && cached.fingerprint === fingerprint)
+    return cached.output;
+  const output = runExtract(root, options);
+  cache2.set(key, { output, fingerprint });
+  return output;
+}
+function argRef(rootDir, node, key) {
+  const source = node.getSourceFile();
+  const ref = { path: relPath(rootDir, source.fileName), start: node.getStart(source), end: node.getEnd(), line: lineOf(node) };
+  if (key !== undefined)
+    ref.key = key;
+  Object.defineProperty(ref, "node", { value: node, enumerable: false });
+  return ref;
+}
+function namedEnclosingFunction(node) {
+  for (let fn = enclosingFunction(node);fn; fn = enclosingFunction(fn)) {
+    const name = functionName(fn);
+    if (name)
+      return { fn, name };
+  }
+  return;
+}
+function qualifiedName(fn, name) {
+  const cls = enclosingClass(fn);
+  const owner = cls && (fn.parent === cls || fn.parent && fn.parent.parent === cls) ? className(cls) : undefined;
+  return owner ? `${owner}.${name}` : name;
+}
+function functionScope(rootDir, fn, name) {
+  const parts = [qualifiedName(fn, name)];
+  const object = objectLiteralOf2(fn);
+  if (object) {
+    const holder = object.parent && import_typescript13.default.isVariableDeclaration(object.parent) && import_typescript13.default.isIdentifier(object.parent.name) ? object.parent.name.text : `L${lineOf(object)}`;
+    parts.unshift(holder);
+  }
+  for (let outer = namedEnclosingFunction(object ?? fn);outer; outer = namedEnclosingFunction(outer.fn))
+    parts.unshift(qualifiedName(outer.fn, outer.name));
+  return `${relPath(rootDir, fn.getSourceFile().fileName)}#${parts.join(".")}`;
+}
+function objectLiteralOf2(fn) {
+  const member2 = import_typescript13.default.isMethodDeclaration(fn) || import_typescript13.default.isGetAccessorDeclaration(fn) || import_typescript13.default.isSetAccessorDeclaration(fn) ? fn : import_typescript13.default.isPropertyAssignment(fn.parent) ? fn.parent : undefined;
+  return member2 && import_typescript13.default.isObjectLiteralExpression(member2.parent) ? member2.parent : undefined;
+}
+function scopeOf(rootDir, node) {
+  const named = namedEnclosingFunction(node);
+  if (named)
+    return functionScope(rootDir, named.fn, named.name);
+  const path = relPath(rootDir, node.getSourceFile().fileName);
+  let outermost;
+  for (let fn = enclosingFunction(node);fn; fn = enclosingFunction(fn))
+    outermost = fn;
+  return outermost ? `${path}#L${lineOf(outermost)}` : path;
 }
 function callerChain(rootDir, anchor, calls, memo) {
   const start = namedEnclosingFunction(anchor);
@@ -26828,15 +27902,15 @@ function findAgentClasses(program, checker, memo) {
   for (const source of program.getSourceFiles()) {
     if (source.isDeclarationFile || /[\\/]node_modules[\\/]/.test(source.fileName))
       continue;
-    const visit = (node) => {
-      if ((import_typescript10.default.isClassDeclaration(node) || import_typescript10.default.isClassExpression(node)) && node.heritageClauses) {
+    const visit2 = (node) => {
+      if ((import_typescript13.default.isClassDeclaration(node) || import_typescript13.default.isClassExpression(node)) && node.heritageClauses) {
         const base = frameworkBaseOf(node, checker, memo).base;
         if (base && AGENT_CLASS_BASES.has(base))
           out.push(node);
       }
-      import_typescript10.default.forEachChild(node, visit);
+      import_typescript13.default.forEachChild(node, visit2);
     };
-    visit(source);
+    visit2(source);
   }
   return out;
 }
@@ -26878,35 +27952,35 @@ function siteFields(sources, rootDir) {
   return out;
 }
 function paramFlow(node, fn, checker, hops = 0) {
-  if (!import_typescript10.default.isExpression(node) || hops > 2)
+  if (!import_typescript13.default.isExpression(node) || hops > 2)
     return;
   const expr = unwrap(node);
-  if (import_typescript10.default.isBinaryExpression(expr) && (expr.operatorToken.kind === import_typescript10.default.SyntaxKind.QuestionQuestionToken || expr.operatorToken.kind === import_typescript10.default.SyntaxKind.BarBarToken)) {
+  if (import_typescript13.default.isBinaryExpression(expr) && (expr.operatorToken.kind === import_typescript13.default.SyntaxKind.QuestionQuestionToken || expr.operatorToken.kind === import_typescript13.default.SyntaxKind.BarBarToken)) {
     return paramFlow(expr.left, fn, checker, hops);
   }
-  if (import_typescript10.default.isPropertyAccessExpression(expr) && import_typescript10.default.isIdentifier(unwrap(expr.expression))) {
+  if (import_typescript13.default.isPropertyAccessExpression(expr) && import_typescript13.default.isIdentifier(unwrap(expr.expression))) {
     const inner = paramFlow(expr.expression, fn, checker, hops);
     return inner && inner.key === undefined ? { param: inner.param, key: expr.name.text } : undefined;
   }
-  if (!import_typescript10.default.isIdentifier(expr))
+  if (!import_typescript13.default.isIdentifier(expr))
     return;
   const declaration = valueDeclaration(resolvedSymbol(expr, checker));
   if (!declaration)
     return;
-  if (import_typescript10.default.isParameter(declaration) && declaration.parent === fn && !declaration.dotDotDotToken)
+  if (import_typescript13.default.isParameter(declaration) && declaration.parent === fn && !declaration.dotDotDotToken)
     return { param: declaration };
-  if (import_typescript10.default.isBindingElement(declaration) && import_typescript10.default.isObjectBindingPattern(declaration.parent) && import_typescript10.default.isParameter(declaration.parent.parent) && declaration.parent.parent.parent === fn && !declaration.dotDotDotToken) {
+  if (import_typescript13.default.isBindingElement(declaration) && import_typescript13.default.isObjectBindingPattern(declaration.parent) && import_typescript13.default.isParameter(declaration.parent.parent) && declaration.parent.parent.parent === fn && !declaration.dotDotDotToken) {
     const key = propertyNameText(declaration.propertyName ?? declaration.name);
     return key ? { param: declaration.parent.parent, key } : undefined;
   }
-  if (import_typescript10.default.isVariableDeclaration(declaration) && declaration.initializer && enclosingFunction(declaration) === fn && declaration.parent.flags & import_typescript10.default.NodeFlags.Const) {
+  if (import_typescript13.default.isVariableDeclaration(declaration) && declaration.initializer && enclosingFunction(declaration) === fn && declaration.parent.flags & import_typescript13.default.NodeFlags.Const) {
     return paramFlow(declaration.initializer, fn, checker, hops + 1);
   }
   return;
 }
 function roleParamFlow(arg, fn, checker) {
   const object = unwrap(arg.node);
-  if (arg.key !== undefined && !arg.key.includes(".") && import_typescript10.default.isObjectLiteralExpression(object)) {
+  if (arg.key !== undefined && !arg.key.includes(".") && import_typescript13.default.isObjectLiteralExpression(object)) {
     const value = propertyValue(object, arg.key);
     const flow = value ? paramFlow(value, fn, checker) : undefined;
     return flow ? { ...flow, viaProperty: true } : undefined;
@@ -26918,9 +27992,9 @@ function descendArg(argument, path) {
   let index = 0;
   for (;index < path.length; index += 1) {
     let value = unwrap(node);
-    if (import_typescript10.default.isCallExpression(value) && value.expression.getText() === "JSON.stringify" && value.arguments[0])
+    if (import_typescript13.default.isCallExpression(value) && value.expression.getText() === "JSON.stringify" && value.arguments[0])
       value = unwrap(value.arguments[0]);
-    const next = import_typescript10.default.isObjectLiteralExpression(value) ? propertyValue(value, path[index]) : undefined;
+    const next = import_typescript13.default.isObjectLiteralExpression(value) ? propertyValue(value, path[index]) : undefined;
     if (!next)
       break;
     node = next;
@@ -26997,8 +28071,8 @@ function runExtract(rootDir, options) {
           };
           sites.push({ site, entry, anchor, sources, level: 0 });
         };
-        const visit = (node) => {
-          if (import_typescript10.default.isCallExpression(node) || import_typescript10.default.isNewExpression(node)) {
+        const visit2 = (node) => {
+          if (import_typescript13.default.isCallExpression(node) || import_typescript13.default.isNewExpression(node)) {
             for (const recognizer of CALL_SINKS) {
               let match;
               const begin = performance.now();
@@ -27013,7 +28087,7 @@ function runExtract(rootDir, options) {
                 break;
               }
             }
-          } else if (import_typescript10.default.isClassDeclaration(node) || import_typescript10.default.isClassExpression(node)) {
+          } else if (import_typescript13.default.isClassDeclaration(node) || import_typescript13.default.isClassExpression(node)) {
             for (const recognizer of classRecognizers) {
               try {
                 for (const match of recognizer.match(node, ctx2))
@@ -27023,9 +28097,9 @@ function runExtract(rootDir, options) {
               }
             }
           }
-          import_typescript10.default.forEachChild(node, visit);
+          import_typescript13.default.forEachChild(node, visit2);
         };
-        visit(source);
+        visit2(source);
       }
     } catch (error) {
       warnings.push(`sinks ${entry.configPath ?? "(fallback)"}: ${error.message}`);
@@ -27075,7 +28149,7 @@ function runExtract(rootDir, options) {
           const sources = [];
           for (const { source: role, flow } of flowing) {
             const argument = call.arguments[named.fn.parameters.indexOf(flow.param)];
-            if (!argument || import_typescript10.default.isSpreadElement(argument))
+            if (!argument || import_typescript13.default.isSpreadElement(argument))
               continue;
             const arg = descendArg(argument, [flow.key, flow.viaProperty ? undefined : role.arg.key].filter((part) => Boolean(part)));
             sources.push({ ...role, bindings: extendBindings(role.bindings, callerBindings), arg });
@@ -27204,11 +28278,21 @@ function runExtract(rootDir, options) {
     timings.models = Date.now() - begin;
     result.durationMs = Date.now() - started;
   }
+  if (options.tools ?? true) {
+    const begin = Date.now();
+    try {
+      result.toolDefinitions = toolDefinitionRefs(emitToolsCached(result, ctx));
+    } catch (error) {
+      warnings.push(`tools: ${error.message}`);
+    }
+    timings.tools = Date.now() - begin;
+    result.durationMs = Date.now() - started;
+  }
   return { result, ctx };
 }
 function nodeSpanning(source, start, end) {
   let best;
-  const visit = (node) => {
+  const visit2 = (node) => {
     const nodeStart = node.getStart(source);
     if (nodeStart > start || node.getEnd() < end)
       return;
@@ -27217,9 +28301,9 @@ function nodeSpanning(source, start, end) {
       return;
     }
     best = node;
-    import_typescript10.default.forEachChild(node, visit);
+    import_typescript13.default.forEachChild(node, visit2);
   };
-  visit(source);
+  visit2(source);
   return best;
 }
 function serializeExtractResult(result) {
@@ -27263,114 +28347,6 @@ function assignAgentIds(result, agentForScope) {
   }
 }
 
-// src/harness-extract/enumerators/common.ts
-var import_typescript11 = __toESM(require_typescript(), 1);
-import { readdirSync as readdirSync8, readFileSync as readFileSync15 } from "node:fs";
-import { dirname as dirname10, join as join13, posix as posix2, relative as relative10 } from "node:path";
-var cache2 = new WeakMap;
-var SKIP = new Set(["node_modules", "dist", "build", "out", "vendor", "coverage", "__pycache__"]);
-var TEST_PATH4 = /(?:^|\/)(?:test|tests|__tests__|test-fixtures|fixtures?|__fixtures__|__mocks__|e2e)\/|\.(?:test|spec)\.[cm]?[jt]sx?$/i;
-var EVAL_PATH2 = /(?:^|\/)evals?\/|\.evals?\.[cm]?[jt]sx?$/i;
-function enumerationRepository(ctx) {
-  const existing = cache2.get(ctx);
-  if (existing)
-    return existing;
-  const files = [];
-  const walk = (dir) => {
-    for (const entry of readdirSync8(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
-      const abs = join13(dir, entry.name);
-      if (entry.isDirectory()) {
-        if (!entry.name.startsWith(".") && !SKIP.has(entry.name))
-          walk(abs);
-      } else if (entry.isFile() && /\.(?:[cm]?[jt]sx?|py|jsonc?|toml)$/.test(entry.name) && !/\.d\.[cm]?ts$/.test(entry.name)) {
-        const path = relative10(ctx.rootDir, abs).split("\\").join("/");
-        try {
-          const text = readFileSync15(abs, "utf8");
-          if (text.length > 1024 * 1024)
-            continue;
-          const source = ctx.programFor(path)?.getSourceFile(abs) ?? import_typescript11.default.createSourceFile(abs, text, import_typescript11.default.ScriptTarget.Latest, true, path.endsWith("tsx") ? import_typescript11.default.ScriptKind.TSX : import_typescript11.default.ScriptKind.TS);
-          files.push({ path, text, source });
-        } catch {}
-      }
-    }
-  };
-  walk(ctx.rootDir);
-  const workers = [];
-  const paths = new Set(files.map((file) => file.path));
-  const closure = (main) => {
-    const found = new Set, pending = [main];
-    for (let index = 0;index < pending.length; index++) {
-      const path = pending[index];
-      if (found.has(path))
-        continue;
-      found.add(path);
-      const file = files.find((entry) => entry.path === path);
-      if (!file)
-        continue;
-      for (const ref of import_typescript11.default.preProcessFile(file.text, true, true).importedFiles) {
-        if (!ref.fileName.startsWith("."))
-          continue;
-        const base = posix2.normalize(posix2.join(posix2.dirname(path), ref.fileName)).replace(/\.[cm]?js$/, "");
-        const target = [base, ...[".ts", ".tsx", ".js", ".mjs", "/index.ts", "/index.js"].map((suffix) => base + suffix)].find((candidate) => paths.has(candidate));
-        if (target)
-          pending.push(target);
-      }
-    }
-    return found;
-  };
-  for (const file of files)
-    if (/(?:^|\/)wrangler(?:\.[\w.-]+)?\.(?:jsonc?|toml)$/.test(file.path)) {
-      try {
-        const config2 = file.path.endsWith(".toml") ? parse(file.text) : JSON.parse(stripJsonc(file.text));
-        const variants = [["default", config2], ...Object.entries(config2.env ?? {}).map(([name, section]) => [name, { ...config2, ...section, queues: section.queues, workflows: section.workflows }])];
-        for (const [environment, section] of variants) {
-          if (typeof section.main !== "string" || isTestWorkerConfig({ path: file.path, name: section.name, mains: [section.main] }))
-            continue;
-          const main = posix2.normalize(posix2.join(dirname10(file.path), section.main));
-          workers.push({ id: `${file.path}#${environment}`, main, cron: Boolean(section.triggers?.crons?.length), queueBindings: new Set((section.queues?.producers ?? []).flatMap((producer) => typeof producer.binding === "string" ? [producer.binding] : [])), workflowClasses: (section.workflows ?? []).flatMap((binding) => typeof binding.class_name === "string" && !binding.script_name ? [binding.class_name] : []), files: closure(main) });
-        }
-      } catch {}
-    }
-  const queueBindingsFor = (path) => {
-    const owners = workers.filter((worker) => worker.files.has(path));
-    return new Set(owners[0] ? [...owners[0].queueBindings].filter((binding) => owners.every((worker) => worker.queueBindings.has(binding))) : []);
-  };
-  const reach = buildImportGraphReachability(ctx.rootDir);
-  const repo = { files, workers, queueBindingsFor, cronEntrypoints: new Set(workers.filter((worker) => worker.cron).map((worker) => worker.main)), deployedFiles: reach.inProd, status: (path) => reach.inProd.has(path) || reach.reachable.has(path) ? "reachable" : "defined_only" };
-  cache2.set(ctx, repo);
-  return repo;
-}
-function lineOf5(node) {
-  return node.getSourceFile().getLineAndCharacterOfPosition(node.getStart()).line + 1;
-}
-function nameOf(node) {
-  if (!node)
-    return;
-  if (import_typescript11.default.isComputedPropertyName(node) && import_typescript11.default.isStringLiteralLike(node.expression))
-    return node.expression.text;
-  return import_typescript11.default.isIdentifier(node) || import_typescript11.default.isStringLiteralLike(node) || import_typescript11.default.isNumericLiteral(node) ? node.text : undefined;
-}
-function visit(node, fn) {
-  fn(node);
-  import_typescript11.default.forEachChild(node, (child) => visit(child, fn));
-}
-function componentId(kind, path, name) {
-  return `${kind}:${path}:${name}`;
-}
-function artifact(type, name, file, node, reason, status) {
-  return { id: componentId(type, file.path, name), type, name, scope: "shared", sourcePath: file.path, usedByAgentIds: [], confidence: 1, evidence: [{ path: file.path, line: lineOf5(node), reason }], status };
-}
-function agent(name, file, node, reason, status) {
-  return { id: componentId("agent", file.path, name), name, kind: "runtime_agent", root: ".", entrypointIds: [], channelAdapterIds: [], artifactIds: [], identityNamespaceIds: [], deploymentIds: [], frameworkIds: [], modelProviderIds: [], confidence: 1, evidence: [{ path: file.path, line: lineOf5(node), reason }], status };
-}
-function emptyResult() {
-  return { runtimeAgents: [], artifacts: [], warnings: [] };
-}
-function stableResult(result) {
-  const unique2 = (values) => [...new Map(values.map((x) => [x.id, x])).values()].sort((a, b) => a.id.localeCompare(b.id));
-  return { runtimeAgents: unique2(result.runtimeAgents), artifacts: unique2(result.artifacts), warnings: [...new Set(result.warnings)].sort() };
-}
-
 // src/harness-extract/enumerators/agents.ts
 function agentForScope(scope, enumeration) {
   return enumeration.agentForScope(scope);
@@ -27379,15 +28355,15 @@ function createAgentScopeResolver(result, ctx) {
   return enumerateAgents(result, ctx).agentForScope;
 }
 var enumerations = new WeakMap;
-var AGENT_BASES3 = new Set(["Think", "Agent", "AIChatAgent", "McpAgent"]);
+var AGENT_BASES4 = new Set(["Think", "Agent", "AIChatAgent", "McpAgent"]);
 var HTTP_METHODS2 = new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"]);
 function routeOf(fn, file) {
   const name = functionName(fn);
   if (name && HTTP_METHODS2.has(name) && /(?:^|\/)(?:route|\+server)\.[cm]?[jt]sx?$/.test(file.path))
     return `${name} ${file.path}`;
   const parent = fn.parent;
-  if (parent && import_typescript12.default.isCallExpression(parent) && import_typescript12.default.isPropertyAccessExpression(parent.expression) && /^(get|post|put|patch|delete|all|on)$/.test(parent.expression.name.text)) {
-    const path = parent.arguments.find(import_typescript12.default.isStringLiteralLike);
+  if (parent && import_typescript14.default.isCallExpression(parent) && import_typescript14.default.isPropertyAccessExpression(parent.expression) && /^(get|post|put|patch|delete|all|on)$/.test(parent.expression.name.text)) {
+    const path = parent.arguments.find(import_typescript14.default.isStringLiteralLike);
     if (path)
       return `${parent.expression.name.text.toUpperCase()} ${path.text} (${file.path})`;
   }
@@ -27409,19 +28385,19 @@ function enumerateAgents(result, ctx) {
       continue;
     const checker = ctx.checkerFor(file.path);
     visit(file.source, (node) => {
-      if ((import_typescript12.default.isClassDeclaration(node) || import_typescript12.default.isClassExpression(node)) && node.name) {
+      if ((import_typescript14.default.isClassDeclaration(node) || import_typescript14.default.isClassExpression(node)) && node.name) {
         const name2 = node.name.text;
         const info = checker ? frameworkBaseOf(node, checker, memo) : undefined;
         const directBase = node.heritageClauses?.flatMap((h) => h.types).map((x) => x.expression.getText()) ?? [];
         const protocolEvents = new Set;
         visit(node, (member2) => {
-          if (import_typescript12.default.isStringLiteralLike(member2))
+          if (import_typescript14.default.isStringLiteralLike(member2))
             protocolEvents.add(member2.text);
         });
         const realtime = protocolEvents.has("session.update") && protocolEvents.has("response.create") && [...protocolEvents].some((event) => event.includes("function_call"));
-        const exported = import_typescript12.default.getCombinedModifierFlags(node) & import_typescript12.default.ModifierFlags.Export;
-        const abstract = import_typescript12.default.getCombinedModifierFlags(node) & import_typescript12.default.ModifierFlags.Abstract;
-        if (!abstract && (exported || bound.has(name2)) && (info?.base && AGENT_BASES3.has(info.base) || directBase.some((x) => AGENT_BASES3.has(x)) || exported && realtime)) {
+        const exported = import_typescript14.default.getCombinedModifierFlags(node) & import_typescript14.default.ModifierFlags.Export;
+        const abstract = import_typescript14.default.getCombinedModifierFlags(node) & import_typescript14.default.ModifierFlags.Abstract;
+        if (!abstract && (exported || bound.has(name2)) && (info?.base && AGENT_BASES4.has(info.base) || directBase.some((x) => AGENT_BASES4.has(x)) || exported && realtime)) {
           classes.push({ file, node, name: name2, chain: info?.chain ?? [name2, ...directBase] });
         }
       }
@@ -27458,10 +28434,10 @@ function enumerateAgents(result, ctx) {
       };
       if (name) {
         const parts = [qualified(node, name)];
-        const member2 = import_typescript12.default.isMethodDeclaration(node) || import_typescript12.default.isGetAccessorDeclaration(node) || import_typescript12.default.isSetAccessorDeclaration(node) ? node : import_typescript12.default.isPropertyAssignment(node.parent) ? node.parent : undefined;
-        const object = member2 && import_typescript12.default.isObjectLiteralExpression(member2.parent) ? member2.parent : undefined;
+        const member2 = import_typescript14.default.isMethodDeclaration(node) || import_typescript14.default.isGetAccessorDeclaration(node) || import_typescript14.default.isSetAccessorDeclaration(node) ? node : import_typescript14.default.isPropertyAssignment(node.parent) ? node.parent : undefined;
+        const object = member2 && import_typescript14.default.isObjectLiteralExpression(member2.parent) ? member2.parent : undefined;
         if (object)
-          parts.unshift(import_typescript12.default.isVariableDeclaration(object.parent) && import_typescript12.default.isIdentifier(object.parent.name) ? object.parent.name.text : `L${lineOf5(object)}`);
+          parts.unshift(import_typescript14.default.isVariableDeclaration(object.parent) && import_typescript14.default.isIdentifier(object.parent.name) ? object.parent.name.text : `L${lineOf5(object)}`);
         for (let outer = (object ?? node).parent;outer; outer = outer.parent) {
           if (isFunctionLike(outer)) {
             const outerName = functionName(outer);
@@ -27483,7 +28459,7 @@ function enumerateAgents(result, ctx) {
     const checker = ctx.checkerFor(node.getSourceFile().fileName.slice(ctx.rootDir.length + 1));
     const bases = node.heritageClauses?.flatMap((clause) => clause.types).flatMap((base) => {
       const declaration = checker && valueDeclaration(resolvedSymbol(base.expression, checker));
-      return declaration && import_typescript12.default.isClassLike(declaration) ? classChain(declaration, seen) : [];
+      return declaration && import_typescript14.default.isClassLike(declaration) ? classChain(declaration, seen) : [];
     }) ?? [];
     return [node, ...bases];
   };
@@ -27499,32 +28475,32 @@ function enumerateAgents(result, ctx) {
     return;
   };
   const bindingTruth = (condition, worker) => {
-    if (condition.kind === import_typescript12.default.SyntaxKind.TrueKeyword)
+    if (condition.kind === import_typescript14.default.SyntaxKind.TrueKeyword)
       return true;
-    if (condition.kind === import_typescript12.default.SyntaxKind.FalseKeyword)
+    if (condition.kind === import_typescript14.default.SyntaxKind.FalseKeyword)
       return false;
-    if (import_typescript12.default.isPrefixUnaryExpression(condition) && condition.operator === import_typescript12.default.SyntaxKind.ExclamationToken) {
+    if (import_typescript14.default.isPrefixUnaryExpression(condition) && condition.operator === import_typescript14.default.SyntaxKind.ExclamationToken) {
       const value = bindingTruth(condition.operand, worker);
       return value === undefined ? undefined : !value;
     }
-    if (import_typescript12.default.isPropertyAccessExpression(condition) && /^(?:this\.)?env$/.test(condition.expression.getText()) && (worker ? repo.workers.find((entry) => entry.id === worker)?.queueBindings : repo.queueBindingsFor(condition.getSourceFile().fileName.slice(ctx.rootDir.length + 1)))?.has(condition.name.text))
+    if (import_typescript14.default.isPropertyAccessExpression(condition) && /^(?:this\.)?env$/.test(condition.expression.getText()) && (worker ? repo.workers.find((entry) => entry.id === worker)?.queueBindings : repo.queueBindingsFor(condition.getSourceFile().fileName.slice(ctx.rootDir.length + 1)))?.has(condition.name.text))
       return true;
     return;
   };
-  const returns = (node) => Boolean(node && (import_typescript12.default.isReturnStatement(node) || import_typescript12.default.isBlock(node) && node.statements.length && import_typescript12.default.isReturnStatement(node.statements[node.statements.length - 1])));
+  const returns = (node) => Boolean(node && (import_typescript14.default.isReturnStatement(node) || import_typescript14.default.isBlock(node) && node.statements.length && import_typescript14.default.isReturnStatement(node.statements[node.statements.length - 1])));
   const deployed = (node, worker) => {
     for (let current = node;current.parent; current = current.parent) {
       const parent = current.parent;
-      if (import_typescript12.default.isIfStatement(parent)) {
+      if (import_typescript14.default.isIfStatement(parent)) {
         const truth = bindingTruth(parent.expression, worker);
         if (truth !== undefined && (current === parent.thenStatement ? !truth : current === parent.elseStatement ? truth : false))
           return false;
       }
-      if (import_typescript12.default.isBlock(parent))
+      if (import_typescript14.default.isBlock(parent))
         for (const prior of parent.statements) {
           if (prior.getStart() >= current.getStart())
             break;
-          if (import_typescript12.default.isIfStatement(prior)) {
+          if (import_typescript14.default.isIfStatement(prior)) {
             const truth = bindingTruth(prior.expression, worker);
             if (truth !== undefined && returns(truth ? prior.thenStatement : prior.elseStatement))
               return false;
@@ -27550,7 +28526,7 @@ function enumerateAgents(result, ctx) {
     const descend = (node) => {
       if (node.getStart() <= offset && node.getEnd() >= offset) {
         anchor = node;
-        import_typescript12.default.forEachChild(node, descend);
+        import_typescript14.default.forEachChild(node, descend);
       }
     };
     descend(file.source);
@@ -27559,21 +28535,21 @@ function enumerateAgents(result, ctx) {
       continue;
     markModel(scope, anchor);
     const tools = site.toolsArg ? ctx.nodeAt(site.toolsArg) : undefined;
-    scope.hasTools ||= Boolean(tools && !(import_typescript12.default.isObjectLiteralExpression(tools) && tools.properties.length === 0) && !(import_typescript12.default.isArrayLiteralExpression(tools) && tools.elements.length === 0));
+    scope.hasTools ||= Boolean(tools && !(import_typescript14.default.isObjectLiteralExpression(tools) && tools.properties.length === 0) && !(import_typescript14.default.isArrayLiteralExpression(tools) && tools.elements.length === 0));
     scope.aliases.push(site.scope);
   }
   const targetsOf = (node, file) => {
     const checker = ctx.checkerFor(file.path);
     if (!checker)
       return [];
-    const at = import_typescript12.default.isPropertyAccessExpression(node) ? node.name : node;
+    const at = import_typescript14.default.isPropertyAccessExpression(node) ? node.name : node;
     const declaration = valueDeclaration(resolvedSymbol(at, checker));
     if (!declaration)
       return [];
     const direct = byNode.get(declaration) ?? scopes.get(keyOf(declaration));
     if (direct)
       return [direct];
-    if (import_typescript12.default.isVariableDeclaration(declaration) && declaration.initializer) {
+    if (import_typescript14.default.isVariableDeclaration(declaration) && declaration.initializer) {
       const fn = byNode.get(declaration.initializer) ?? scopes.get(keyOf(declaration.initializer));
       if (fn)
         return [fn];
@@ -27585,19 +28561,19 @@ function enumerateAgents(result, ctx) {
       if (node !== scope.node && isFunctionLike(node)) {
         return;
       }
-      if (import_typescript12.default.isWhileStatement(node) || import_typescript12.default.isDoStatement(node) || import_typescript12.default.isForStatement(node) || import_typescript12.default.isForOfStatement(node))
+      if (import_typescript14.default.isWhileStatement(node) || import_typescript14.default.isDoStatement(node) || import_typescript14.default.isForStatement(node) || import_typescript14.default.isForOfStatement(node))
         scope.hasLoop = true;
-      if ((import_typescript12.default.isIdentifier(node) || import_typescript12.default.isStringLiteralLike(node)) && /^(?:tool_calls|toolCalls|tool_use|tool_result|tool_results|toolResults)$/.test(node.text)) {
+      if ((import_typescript14.default.isIdentifier(node) || import_typescript14.default.isStringLiteralLike(node)) && /^(?:tool_calls|toolCalls|tool_use|tool_result|tool_results|toolResults)$/.test(node.text)) {
         scope.hasTools = true;
         scope.toolFeedback = true;
       }
-      if (import_typescript12.default.isObjectLiteralExpression(node)) {
-        const fields = new Map(node.properties.filter(import_typescript12.default.isPropertyAssignment).map((p2) => [nameOf(p2.name), p2.initializer]));
+      if (import_typescript14.default.isObjectLiteralExpression(node)) {
+        const fields = new Map(node.properties.filter(import_typescript14.default.isPropertyAssignment).map((p2) => [nameOf(p2.name), p2.initializer]));
         const type = fields.get("type");
-        if (type && import_typescript12.default.isStringLiteralLike(type) && type.text === "tool" && fields.has("name"))
+        if (type && import_typescript14.default.isStringLiteralLike(type) && type.text === "tool" && fields.has("name"))
           scope.forcedOutput = true;
       }
-      if (import_typescript12.default.isCallExpression(node) || import_typescript12.default.isNewExpression(node)) {
+      if (import_typescript14.default.isCallExpression(node) || import_typescript14.default.isNewExpression(node)) {
         const callee = node.expression.getText();
         if (/(?:chat\.)?completions\.create$|messages\.(?:create|stream)$|responses\.(?:create|stream)$/.test(callee))
           markModel(scope, node);
@@ -27605,7 +28581,7 @@ function enumerateAgents(result, ctx) {
           markModel(scope, node);
         const connect = (at) => {
           for (const target of byNode.has(at) ? [byNode.get(at)] : targetsOf(at, scope.file)) {
-            if (import_typescript12.default.isPropertyAccessExpression(at) && at.expression.kind === import_typescript12.default.SyntaxKind.ThisKeyword) {
+            if (import_typescript14.default.isPropertyAccessExpression(at) && at.expression.kind === import_typescript14.default.SyntaxKind.ThisKeyword) {
               virtualEdges.set(`${scope.key}|${target.key}`, at.name.text);
               scope.virtualCalls.set(target.key, at.name.text);
             }
@@ -27624,30 +28600,30 @@ function enumerateAgents(result, ctx) {
             connect(at);
             return;
           }
-          if (import_typescript12.default.isIdentifier(at) || import_typescript12.default.isPropertyAccessExpression(at))
+          if (import_typescript14.default.isIdentifier(at) || import_typescript14.default.isPropertyAccessExpression(at))
             connect(at);
-          import_typescript12.default.forEachChild(at, connectArgument);
+          import_typescript14.default.forEachChild(at, connectArgument);
         };
         for (const argument of node.arguments ?? [])
           connectArgument(argument);
         for (const argument of node.arguments ?? [])
-          if (import_typescript12.default.isObjectLiteralExpression(argument)) {
+          if (import_typescript14.default.isObjectLiteralExpression(argument)) {
             const fields = new Set(argument.properties.map((p2) => nameOf(p2.name)));
             if (fields.has("model") && fields.has("messages") && fields.has("tools")) {
               markModel(scope, node);
               scope.hasTools = true;
             }
           }
-        if (/(?:^|\.)(?:stepCountIs|isStepCount)$/.test(node.expression.getText()) && node.arguments?.[0] && import_typescript12.default.isNumericLiteral(node.arguments?.[0]) && Number(node.arguments?.[0].text) > 1) {
+        if (/(?:^|\.)(?:stepCountIs|isStepCount)$/.test(node.expression.getText()) && node.arguments?.[0] && import_typescript14.default.isNumericLiteral(node.arguments?.[0]) && Number(node.arguments?.[0].text) > 1) {
           scope.hasLoop = true;
           scope.configuredSteps = true;
         }
       }
-      if (import_typescript12.default.isPropertyAssignment(node) && nameOf(node.name) === "maxSteps" && import_typescript12.default.isNumericLiteral(node.initializer) && Number(node.initializer.text) > 1) {
+      if (import_typescript14.default.isPropertyAssignment(node) && nameOf(node.name) === "maxSteps" && import_typescript14.default.isNumericLiteral(node.initializer) && Number(node.initializer.text) > 1) {
         scope.hasLoop = true;
         scope.configuredSteps = true;
       }
-      import_typescript12.default.forEachChild(node, inspect);
+      import_typescript14.default.forEachChild(node, inspect);
     };
     inspect(scope.node);
   }
@@ -27672,19 +28648,19 @@ function enumerateAgents(result, ctx) {
     values.add(id);
   };
   for (const cls of classes) {
-    const emitted = agent(cls.name, cls.file, cls.node, "Concrete agent/framework class or realtime model/tool bridge", repo.status(cls.file.path));
-    agents.set(emitted.id, emitted);
+    const emitted2 = agent(cls.name, cls.file, cls.node, "Concrete agent/framework class or realtime model/tool bridge", repo.status(cls.file.path));
+    agents.set(emitted2.id, emitted2);
   }
   for (const scope of scopes.values()) {
     let nestedInFunction = false;
-    for (let parent = scope.node.parent;parent && !import_typescript12.default.isClassLike(parent); parent = parent.parent)
+    for (let parent = scope.node.parent;parent && !import_typescript14.default.isClassLike(parent); parent = parent.parent)
       if (isFunctionLike(parent)) {
         nestedInFunction = true;
         break;
       }
     if (scope.className && !nestedInFunction) {
       let member2 = scope.node;
-      while (member2.parent && !import_typescript12.default.isClassLike(member2.parent))
+      while (member2.parent && !import_typescript14.default.isClassLike(member2.parent))
         member2 = member2.parent;
       const memberName = "name" in member2 ? nameOf(member2.name) : undefined;
       for (const cls of classes) {
@@ -27709,9 +28685,9 @@ function enumerateAgents(result, ctx) {
       const name = boundary.route ?? functionName(boundary.node);
       if (!name)
         continue;
-      const emitted = agent(name, boundary.file, scope.node, "Function or route owns a multi-step model/tool feedback loop", repo.status(boundary.file.path));
-      agents.set(emitted.id, emitted);
-      assign(boundary.key, emitted.id);
+      const emitted2 = agent(name, boundary.file, scope.node, "Function or route owns a multi-step model/tool feedback loop", repo.status(boundary.file.path));
+      agents.set(emitted2.id, emitted2);
+      assign(boundary.key, emitted2.id);
     }
   }
   let changed = true;
@@ -27778,7 +28754,7 @@ function enumerateAgents(result, ctx) {
 }
 
 // src/harness-extract/enumerators/workflows.ts
-var import_typescript13 = __toESM(require_typescript(), 1);
+var import_typescript15 = __toESM(require_typescript(), 1);
 function enumerateWorkflows(result, ctx) {
   const output = emptyResult();
   const repo = enumerationRepository(ctx);
@@ -27791,10 +28767,10 @@ function enumerateWorkflows(result, ctx) {
       continue;
     for (const name of worker.workflowClasses) {
       let exported = checker.getExportsOfModule(module).find((symbol) => symbol.name === name);
-      if (exported && exported.flags & import_typescript13.default.SymbolFlags.Alias)
+      if (exported && exported.flags & import_typescript15.default.SymbolFlags.Alias)
         exported = checker.getAliasedSymbol(exported);
       const declaration = exported && valueDeclaration(exported);
-      if (declaration && import_typescript13.default.isClassDeclaration(declaration))
+      if (declaration && import_typescript15.default.isClassDeclaration(declaration))
         bindings.add(nodeKey(declaration));
     }
   }
@@ -27803,7 +28779,7 @@ function enumerateWorkflows(result, ctx) {
     if (!/\.[cm]?[jt]sx?$/.test(file.path) || TEST_PATH4.test(file.path) || EVAL_PATH2.test(file.path))
       continue;
     visit(file.source, (node) => {
-      if (!import_typescript13.default.isClassDeclaration(node) || !node.name || import_typescript13.default.getCombinedModifierFlags(node) & import_typescript13.default.ModifierFlags.Abstract)
+      if (!import_typescript15.default.isClassDeclaration(node) || !node.name || import_typescript15.default.getCombinedModifierFlags(node) & import_typescript15.default.ModifierFlags.Abstract)
         return;
       const checker = ctx.checkerFor(file.path);
       const base = checker ? frameworkBaseOf(node, checker, memo)?.base : undefined;
@@ -27828,7 +28804,7 @@ function enumerateWorkflows(result, ctx) {
       if (!cls || !workerClasses.has(nodeKey(cls)))
         return calls;
       const member2 = scope.node.parent === cls ? scope.node : scope.node.parent;
-      if (import_typescript13.default.getCombinedModifierFlags(member2) & import_typescript13.default.ModifierFlags.Static)
+      if (import_typescript15.default.getCombinedModifierFlags(member2) & import_typescript15.default.ModifierFlags.Static)
         return calls;
       return new Set([...calls].map((key) => {
         const method = scope.virtualCalls.get(key);
@@ -27842,24 +28818,24 @@ function enumerateWorkflows(result, ctx) {
       if (!node || visited.has(node))
         return;
       visited.add(node);
-      if (import_typescript13.default.isParenthesizedExpression(node) || import_typescript13.default.isAsExpression(node) || import_typescript13.default.isSatisfiesExpression(node) || import_typescript13.default.isNonNullExpression(node)) {
+      if (import_typescript15.default.isParenthesizedExpression(node) || import_typescript15.default.isAsExpression(node) || import_typescript15.default.isSatisfiesExpression(node) || import_typescript15.default.isNonNullExpression(node)) {
         resolveWorker(node.expression);
         return;
       }
-      if (import_typescript13.default.isCallExpression(node) && /(?:^|\.)withSentry$/.test(node.expression.getText())) {
+      if (import_typescript15.default.isCallExpression(node) && /(?:^|\.)withSentry$/.test(node.expression.getText())) {
         for (const argument of node.arguments)
           resolveWorker(argument);
         return;
       }
-      if (import_typescript13.default.isExportAssignment(node)) {
+      if (import_typescript15.default.isExportAssignment(node)) {
         resolveWorker(node.expression);
         return;
       }
-      if (import_typescript13.default.isVariableDeclaration(node)) {
+      if (import_typescript15.default.isVariableDeclaration(node)) {
         resolveWorker(node.initializer);
         return;
       }
-      if (import_typescript13.default.isIdentifier(node) && checker) {
+      if (import_typescript15.default.isIdentifier(node) && checker) {
         resolveWorker(valueDeclaration(resolvedSymbol(node, checker)));
         return;
       }
@@ -27867,17 +28843,17 @@ function enumerateWorkflows(result, ctx) {
     };
     const module = mainFile && checker?.getSymbolAtLocation(mainFile.source);
     const exported = module && checker?.getExportsOfModule(module).find((symbol2) => symbol2.name === "default");
-    const symbol = exported && checker && (exported.flags & import_typescript13.default.SymbolFlags.Alias ? checker.getAliasedSymbol(exported) : exported);
+    const symbol = exported && checker && (exported.flags & import_typescript15.default.SymbolFlags.Alias ? checker.getAliasedSymbol(exported) : exported);
     resolveWorker(symbol && valueDeclaration(symbol));
     const collectImplementations = (node) => {
-      if (!import_typescript13.default.isClassLike(node) || workerClasses.has(nodeKey(node)))
+      if (!import_typescript15.default.isClassLike(node) || workerClasses.has(nodeKey(node)))
         return;
       workerClasses.add(nodeKey(node));
       for (const member2 of node.members) {
-        if (import_typescript13.default.getCombinedModifierFlags(member2) & import_typescript13.default.ModifierFlags.Static)
+        if (import_typescript15.default.getCombinedModifierFlags(member2) & import_typescript15.default.ModifierFlags.Static)
           continue;
         const name = nameOf(member2.name);
-        const implementation = byKey.get(nodeKey(member2)) ?? (import_typescript13.default.isPropertyDeclaration(member2) && member2.initializer ? byKey.get(nodeKey(member2.initializer)) : undefined);
+        const implementation = byKey.get(nodeKey(member2)) ?? (import_typescript15.default.isPropertyDeclaration(member2) && member2.initializer ? byKey.get(nodeKey(member2.initializer)) : undefined);
         if (name && !implementations.has(name))
           implementations.set(name, implementation?.key ?? "(non-callable override)");
       }
@@ -27904,19 +28880,19 @@ function enumerateWorkflows(result, ctx) {
       if (!node || seen2.has(node))
         return;
       seen2.add(node);
-      if (import_typescript13.default.isIdentifier(node) && checker) {
+      if (import_typescript15.default.isIdentifier(node) && checker) {
         resolveScheduled(valueDeclaration(resolvedSymbol(node, checker)), seen2);
         return;
       }
-      if (import_typescript13.default.isVariableDeclaration(node) || import_typescript13.default.isPropertyAssignment(node) || import_typescript13.default.isPropertyDeclaration(node)) {
+      if (import_typescript15.default.isVariableDeclaration(node) || import_typescript15.default.isPropertyAssignment(node) || import_typescript15.default.isPropertyDeclaration(node)) {
         resolveScheduled(node.initializer, seen2);
         return;
       }
-      if (import_typescript13.default.isShorthandPropertyAssignment(node)) {
+      if (import_typescript15.default.isShorthandPropertyAssignment(node)) {
         resolveScheduled(checker && valueDeclaration(checker.getShorthandAssignmentValueSymbol(node)), seen2);
         return;
       }
-      if (import_typescript13.default.isParenthesizedExpression(node) || import_typescript13.default.isAsExpression(node) || import_typescript13.default.isSatisfiesExpression(node) || import_typescript13.default.isNonNullExpression(node)) {
+      if (import_typescript15.default.isParenthesizedExpression(node) || import_typescript15.default.isAsExpression(node) || import_typescript15.default.isSatisfiesExpression(node) || import_typescript15.default.isNonNullExpression(node)) {
         resolveScheduled(node.expression, seen2);
         return;
       }
@@ -27926,11 +28902,11 @@ function enumerateWorkflows(result, ctx) {
       if (seen2.has(node))
         return;
       seen2.add(node);
-      const members = import_typescript13.default.isObjectLiteralExpression(node) ? node.properties : import_typescript13.default.isClassLike(node) ? node.members : [];
-      const handlers = members.filter((member2) => nameOf(member2.name) === "scheduled" && !(import_typescript13.default.getCombinedModifierFlags(member2) & import_typescript13.default.ModifierFlags.Static));
+      const members = import_typescript15.default.isObjectLiteralExpression(node) ? node.properties : import_typescript15.default.isClassLike(node) ? node.members : [];
+      const handlers = members.filter((member2) => nameOf(member2.name) === "scheduled" && !(import_typescript15.default.getCombinedModifierFlags(member2) & import_typescript15.default.ModifierFlags.Static));
       for (const member2 of handlers)
         resolveScheduled(member2);
-      if (!handlers.length && import_typescript13.default.isClassLike(node) && checker)
+      if (!handlers.length && import_typescript15.default.isClassLike(node) && checker)
         for (const base of node.heritageClauses?.flatMap((clause) => clause.types) ?? []) {
           const declaration = valueDeclaration(resolvedSymbol(base.expression, checker));
           if (declaration)
@@ -27976,7 +28952,7 @@ function enumerateWorkflows(result, ctx) {
 }
 
 // src/harness-extract/enumerators/catalog.ts
-var import_typescript14 = __toESM(require_typescript(), 1);
+var import_typescript16 = __toESM(require_typescript(), 1);
 var THINK_WORKSPACE_TOOLS = ["read", "write", "edit", "list", "find", "grep", "delete"];
 function strings(expression, checker, seen = new Set) {
   if (!expression)
@@ -27985,35 +28961,35 @@ function strings(expression, checker, seen = new Set) {
   if (seen.has(node))
     return [];
   seen.add(node);
-  if (import_typescript14.default.isIdentifier(node)) {
+  if (import_typescript16.default.isIdentifier(node)) {
     const declaration = checker && valueDeclaration(resolvedSymbol(node, checker));
-    if (!declaration || !import_typescript14.default.isVariableDeclaration(declaration))
+    if (!declaration || !import_typescript16.default.isVariableDeclaration(declaration))
       return [];
     return strings(declaration.initializer, checker, seen);
   }
-  if (import_typescript14.default.isArrayLiteralExpression(node))
-    return node.elements.flatMap((entry) => import_typescript14.default.isSpreadElement(entry) ? strings(entry.expression, checker, seen) : strings(entry, checker, seen));
-  if (import_typescript14.default.isStringLiteralLike(node))
+  if (import_typescript16.default.isArrayLiteralExpression(node))
+    return node.elements.flatMap((entry) => import_typescript16.default.isSpreadElement(entry) ? strings(entry.expression, checker, seen) : strings(entry, checker, seen));
+  if (import_typescript16.default.isStringLiteralLike(node))
     return [{ name: node.text, node }];
-  if (import_typescript14.default.isNewExpression(node) && node.expression.getText() === "Set")
+  if (import_typescript16.default.isNewExpression(node) && node.expression.getText() === "Set")
     return strings(node.arguments?.[0], checker, seen);
   return [];
 }
 function property(object, name) {
   const entry = object.properties.find((item) => item.name && nameOf(item.name) === name);
-  return entry && import_typescript14.default.isPropertyAssignment(entry) ? entry.initializer : entry && import_typescript14.default.isShorthandPropertyAssignment(entry) ? entry.name : undefined;
+  return entry && import_typescript16.default.isPropertyAssignment(entry) ? entry.initializer : entry && import_typescript16.default.isShorthandPropertyAssignment(entry) ? entry.name : undefined;
 }
 function inheritedTrue(node, propertyName2, checker, seen = new Set) {
   if (seen.has(node))
     return false;
   seen.add(node);
   const own = node.members.find((member2) => nameOf(member2.name) === propertyName2);
-  if (own && import_typescript14.default.isPropertyDeclaration(own) && own.initializer)
-    return unwrap(own.initializer).kind === import_typescript14.default.SyntaxKind.TrueKeyword;
+  if (own && import_typescript16.default.isPropertyDeclaration(own) && own.initializer)
+    return unwrap(own.initializer).kind === import_typescript16.default.SyntaxKind.TrueKeyword;
   if (checker)
     for (const base of node.heritageClauses?.flatMap((h) => h.types) ?? []) {
       const declaration = valueDeclaration(resolvedSymbol(base.expression, checker));
-      if (declaration && (import_typescript14.default.isClassDeclaration(declaration) || import_typescript14.default.isClassExpression(declaration)))
+      if (declaration && (import_typescript16.default.isClassDeclaration(declaration) || import_typescript16.default.isClassExpression(declaration)))
         return inheritedTrue(declaration, propertyName2, checker, seen);
     }
   return false;
@@ -28028,10 +29004,10 @@ function enumerateToolCatalog(result, ctx) {
     if (!owners.length || !checker)
       continue;
     visit(scope.node, (node) => {
-      if (!import_typescript14.default.isIdentifier(node) || !/ALLOW|MCP_NAME/.test(node.text))
+      if (!import_typescript16.default.isIdentifier(node) || !/ALLOW|MCP_NAME/.test(node.text))
         return;
       const declaration = valueDeclaration(resolvedSymbol(node, checker));
-      if (!declaration || !import_typescript14.default.isVariableDeclaration(declaration) || !import_typescript14.default.isIdentifier(declaration.name))
+      if (!declaration || !import_typescript16.default.isVariableDeclaration(declaration) || !import_typescript16.default.isIdentifier(declaration.name))
         return;
       const key = `${declaration.getSourceFile().fileName}:${declaration.name.text}`;
       let existing = symbolOwners.get(key);
@@ -28052,7 +29028,7 @@ function enumerateToolCatalog(result, ctx) {
     if (!file || !checker)
       continue;
     visit(file.source, (node) => {
-      if ((import_typescript14.default.isClassDeclaration(node) || import_typescript14.default.isClassExpression(node)) && node.name?.text === runtime.name && frameworkBaseOf(node, checker, memo)?.base === "Think")
+      if ((import_typescript16.default.isClassDeclaration(node) || import_typescript16.default.isClassExpression(node)) && node.name?.text === runtime.name && frameworkBaseOf(node, checker, memo)?.base === "Think")
         thinkIds.add(runtime.id);
     });
   }
@@ -28069,11 +29045,11 @@ function enumerateToolCatalog(result, ctx) {
       continue;
     const checker = ctx.checkerFor(file.path), declarations = new Map;
     visit(file.source, (node) => {
-      if (import_typescript14.default.isVariableDeclaration(node) && import_typescript14.default.isIdentifier(node.name) && node.initializer)
+      if (import_typescript16.default.isVariableDeclaration(node) && import_typescript16.default.isIdentifier(node.name) && node.initializer)
         declarations.set(node.name.text, node.initializer);
     });
     visit(file.source, (node) => {
-      if ((import_typescript14.default.isClassDeclaration(node) || import_typescript14.default.isClassExpression(node)) && node.name && agentByName.has(node.name.text)) {
+      if ((import_typescript16.default.isClassDeclaration(node) || import_typescript16.default.isClassExpression(node)) && node.name && agentByName.has(node.name.text)) {
         const info = checker ? frameworkBaseOf(node, checker, memo) : undefined;
         const directThink = node.heritageClauses?.some((h) => h.types.some((t) => t.expression.getText() === "Think"));
         if (info?.base === "Think" || directThink) {
@@ -28085,37 +29061,37 @@ function enumerateToolCatalog(result, ctx) {
             add(name, file, node, "think", "Think workspace tool inherited by this concrete agent", owners2);
         }
       }
-      if (import_typescript14.default.isPropertyAccessExpression(node) && node.name.text === "activate_skill" || import_typescript14.default.isPropertyAssignment(node) && nameOf(node.name) === "activate_skill") {
+      if (import_typescript16.default.isPropertyAccessExpression(node) && node.name.text === "activate_skill" || import_typescript16.default.isPropertyAssignment(node) && nameOf(node.name) === "activate_skill") {
         const owner = ownersAt(node, file.path);
         add("activate_skill", file, node, "think", "Source explicitly exposes Think skill activation", owner);
       }
-      if (import_typescript14.default.isCallExpression(node) && import_typescript14.default.isPropertyAccessExpression(node.expression) && /^(?:registerTool|tool)$/.test(node.expression.name.text) && checker) {
+      if (import_typescript16.default.isCallExpression(node) && import_typescript16.default.isPropertyAccessExpression(node.expression) && /^(?:registerTool|tool)$/.test(node.expression.name.text) && checker) {
         const receiver = valueDeclaration(resolvedSymbol(node.expression.expression, checker));
-        const init = receiver && import_typescript14.default.isVariableDeclaration(receiver) && receiver.initializer ? unwrap(receiver.initializer) : undefined;
-        const origin = init && import_typescript14.default.isNewExpression(init) && import_typescript14.default.isIdentifier(init.expression) ? importOrigin(init.expression, checker) : undefined;
+        const init = receiver && import_typescript16.default.isVariableDeclaration(receiver) && receiver.initializer ? unwrap(receiver.initializer) : undefined;
+        const origin = init && import_typescript16.default.isNewExpression(init) && import_typescript16.default.isIdentifier(init.expression) ? importOrigin(init.expression, checker) : undefined;
         const name = node.arguments[0];
-        if (origin?.module.startsWith("@modelcontextprotocol/sdk/") && origin.imported === "McpServer" && name && import_typescript14.default.isStringLiteralLike(name)) {
+        if (origin?.module.startsWith("@modelcontextprotocol/sdk/") && origin.imported === "McpServer" && name && import_typescript16.default.isStringLiteralLike(name)) {
           add(name.text, file, name, "mcp_server", "MCP SDK server explicitly registers this model-facing tool name", ownersAt(node, file.path));
         }
       }
-      if (import_typescript14.default.isCallExpression(node) && import_typescript14.default.isPropertyAccessExpression(node.expression) && node.expression.expression.getText() === "Output" && node.expression.name.text === "object") {
+      if (import_typescript16.default.isCallExpression(node) && import_typescript16.default.isPropertyAccessExpression(node.expression) && node.expression.expression.getText() === "Output" && node.expression.name.text === "object") {
         const owners2 = ownersAt(node, file.path).filter((id) => thinkIds.has(id));
-        if (owners2.length && checker && import_typescript14.default.isIdentifier(node.expression.expression) && ["ai", "@cloudflare/think"].includes(importOrigin(node.expression.expression, checker)?.module ?? ""))
+        if (owners2.length && checker && import_typescript16.default.isIdentifier(node.expression.expression) && ["ai", "@cloudflare/think"].includes(importOrigin(node.expression.expression, checker)?.module ?? ""))
           add("think_final_answer", file, node, "think", "Think structured output is offered as the framework final-answer tool", owners2);
       }
-      if (import_typescript14.default.isCallExpression(node) && import_typescript14.default.isIdentifier(node.expression) && node.expression.text === "createExecuteRuntime") {
+      if (import_typescript16.default.isCallExpression(node) && import_typescript16.default.isIdentifier(node.expression) && node.expression.text === "createExecuteRuntime") {
         const owners2 = ownersAt(node, file.path).filter((id) => thinkIds.has(id));
         if (owners2.length && checker && importOrigin(node.expression, checker)?.module.startsWith("@cloudflare/think"))
           add("execute", file, node, "think", "Think Code Mode runtime explicitly enabled for this agent", owners2);
       }
-      if (!import_typescript14.default.isObjectLiteralExpression(node))
+      if (!import_typescript16.default.isObjectLiteralExpression(node))
         return;
       const serverNames = strings(property(node, "name"), checker), allow = property(node, "allow");
       if (serverNames.length !== 1 || !allow || !property(node, "url"))
         return;
       const server = serverNames[0].name;
       const owners = ownersAt(node, file.path);
-      if (import_typescript14.default.isStringLiteralLike(unwrap(allow)) && unwrap(allow).text === "all") {
+      if (import_typescript16.default.isStringLiteralLike(unwrap(allow)) && unwrap(allow).text === "all") {
         const entry = add(`${server} dynamic MCP tools`, file, allow, "mcp_dynamic_group", "Server schemas are admitted dynamically as one bounded catalog group", owners);
         entry.serverName = server;
         entry.dynamicGroup = true;
@@ -28166,23 +29142,30 @@ function enumerateToolCatalog(result, ctx) {
 var ENUMERATORS = [
   { id: "agents", enumerate: ({ result }, ctx) => ({ runtimeAgents: enumerateAgents(result, ctx).runtimeAgents }) },
   { id: "workflows", enumerate: ({ result }, ctx) => enumerateWorkflows(result, ctx) },
-  { id: "framework-mcp-catalog", enumerate: ({ result }, ctx) => enumerateToolCatalog(result, ctx) }
+  { id: "framework-mcp-catalog", enumerate: ({ result }, ctx) => enumerateToolCatalog(result, ctx) },
+  { id: "tool-registry", enumerate: ({ result }, ctx) => ({ artifacts: toolArtifacts(emitToolsCached(result, ctx), enumerateAgents(result, ctx).runtimeAgents) }) }
 ];
 function enumerateHarnessComponents(result, ctx) {
   const agents = enumerateAgents(result, ctx), workflows = enumerateWorkflows(result, ctx), catalog = enumerateToolCatalog(result, ctx);
-  return stableResult({ runtimeAgents: agents.runtimeAgents, artifacts: [...workflows.artifacts, ...catalog.artifacts], warnings: [...workflows.warnings, ...catalog.warnings] });
+  return stableResult({ runtimeAgents: agents.runtimeAgents, artifacts: [...workflows.artifacts, ...toolArtifacts(emitToolsCached(result, ctx), agents.runtimeAgents), ...catalog.artifacts], warnings: [...workflows.warnings, ...catalog.warnings] });
 }
 function mergeEnumeratedComponents(artifacts, components) {
   const merged = new Map;
   const definitions = new Map;
-  for (const item of [...artifacts, ...components.artifacts]) {
+  const registry = components.artifacts.filter((item) => item.type === "tool" && item.id.startsWith("tool.extract."));
+  for (const item of [...registry, ...artifacts, ...components.artifacts.filter((item2) => !registry.includes(item2))]) {
     const key = item.type === "tool" ? `tool:${item.name}` : item.id;
-    if (item.type === "tool" && item.body) {
+    if (item.type === "tool") {
+      const own = item.definitionVariants ?? (item.body ? [{ sourcePath: item.sourcePath, body: item.body, evidence: item.evidence }] : []);
       let variants = definitions.get(key);
-      if (!variants)
-        definitions.set(key, variants = []);
-      if (!variants.some((entry) => entry.id === item.id && entry.body === item.body))
-        variants.push({ id: item.id, sourcePath: item.sourcePath, body: item.body, evidence: [...item.evidence], usedByAgentIds: [...item.usedByAgentIds] });
+      for (const variant of own) {
+        if (!variant.body)
+          continue;
+        if (!variants)
+          definitions.set(key, variants = []);
+        if (!variants.some((entry) => entry.id === item.id && entry.sourcePath === variant.sourcePath && entry.body === variant.body))
+          variants.push({ id: item.id, sourcePath: variant.sourcePath, body: variant.body, evidence: [...variant.evidence ?? item.evidence], usedByAgentIds: [...item.usedByAgentIds] });
+      }
     }
     const previous = merged.get(key);
     if (!previous) {
@@ -28213,4 +29196,4 @@ function mergeEnumeratedComponents(artifacts, components) {
   return { runtimeAgents, artifacts: output };
 }
 
-export { startRemoteAnalyze, pollRemoteAnalyzeUntilDone, isRecoverableRemoteRun, checkPromptMapping, safePromptEvidencePath, discoverHarnessPromptSources, valueChildren, selectKey, allValues, renderings, CALL_SINKS, registerCallSink, registerClassSink, isModelId, collectModels, modelArtifacts, modelUnknowns, collectModelLiterals, EXTRACT_SCHEMA_VERSION, agentForScope, createAgentScopeResolver, enumerateAgents, enumerateWorkflows, enumerateToolCatalog, ENUMERATORS, enumerateHarnessComponents, mergeEnumeratedComponents, toolNamesOf, clearExtractCache, extractHarness, extractHarnessWithContext, serializeExtractResult, runEnumerators, assignAgentIds, runHarnessCommand, writeHarnessAnalyzeResult, emitWrittenArtifacts, analyzeHarnessPrompts, isToolGroupPlaceholder, repairExternalAnalystReport, deriveRelationshipsFromGraph, deterministicArtifacts, deterministicGraphItems, mergeDeterministicArtifacts, analystRefutations, describeCodingAgentEvent, analystEventProgress, isRetryableExternalAnalystFailure, sleep, summarizeInvalidAnalystReport, isDeterministicLocalAnalyst, resolveHarnessAnalyzeConcern, resolveExternalHarnessAnalystInvocation, detectAvailableCodingAgents, codingAgentDisplayName, runCodingAgent, readOnlyClaudeExtraArgs, resolveAnalystModel, renderExternalHarnessAnalystPrompt, CONCERN_CANDIDATE_KINDS, SEED_CANDIDATE_KIND_LABELS, renderAnalystCandidateLines, renderAnalystSeedLines, truncateText, scanHarness, summarizeHarness, buildSourceSnapshot, writeHumanProgress, describeSyncIdentity, describeSyncTenantLabel, findFresherHarnessReports, writeHarnessArtifacts, assertHarnessGraphSyncQuality, graphForSync, inventoryFiles, numericEnv, numericEnvAllowZero, computeDeterministicFloor, stableId, titleFromId, promptNameFromPath };
+export { startRemoteAnalyze, pollRemoteAnalyzeUntilDone, isRecoverableRemoteRun, checkPromptMapping, safePromptEvidencePath, discoverHarnessPromptSources, valueChildren, selectKey, allValues, renderings, CALL_SINKS, registerCallSink, registerClassSink, isModelId, collectModels, modelArtifacts, modelUnknowns, collectModelLiterals, agentForScope, createAgentScopeResolver, enumerateAgents, toolNamesOf, EXTRACT_SCHEMA_VERSION, enumerateWorkflows, enumerateToolCatalog, ENUMERATORS, enumerateHarnessComponents, mergeEnumeratedComponents, clearExtractCache, extractHarness, extractHarnessWithContext, scopeOf, serializeExtractResult, runEnumerators, assignAgentIds, runHarnessCommand, writeHarnessAnalyzeResult, emitWrittenArtifacts, analyzeHarnessPrompts, isToolGroupPlaceholder, repairExternalAnalystReport, deriveRelationshipsFromGraph, deterministicArtifacts, deterministicGraphItems, mergeDeterministicArtifacts, analystRefutations, describeCodingAgentEvent, analystEventProgress, isRetryableExternalAnalystFailure, sleep, summarizeInvalidAnalystReport, isDeterministicLocalAnalyst, resolveHarnessAnalyzeConcern, resolveExternalHarnessAnalystInvocation, detectAvailableCodingAgents, codingAgentDisplayName, runCodingAgent, readOnlyClaudeExtraArgs, resolveAnalystModel, renderExternalHarnessAnalystPrompt, CONCERN_CANDIDATE_KINDS, SEED_CANDIDATE_KIND_LABELS, renderAnalystCandidateLines, renderAnalystSeedLines, truncateText, scanHarness, summarizeHarness, buildSourceSnapshot, writeHumanProgress, describeSyncIdentity, describeSyncTenantLabel, findFresherHarnessReports, writeHarnessArtifacts, assertHarnessGraphSyncQuality, graphForSync, inventoryFiles, numericEnv, numericEnvAllowZero, computeDeterministicFloor, stableId, titleFromId, promptNameFromPath };