@moda-ai/cli 1.55.72 → 1.55.74

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

@@ -18,10 +18,12 @@ import {
   artifactHasBody,
   buildImportGraphReachability,
   createHarnessReport,
+  detectBoundRuntimeClasses,
   firstEvidencePath,
   graphForReport,
   hashHarnessReport,
   hashStableJson,
+  isTestWorkerConfig,
   loadHarnessReportForSync,
   mergeBoundRuntimeClasses,
   normalizeHarnessReport,
@@ -29,14 +31,11 @@ import {
   requiresArtifactBody,
   resolveHarnessReportPath,
   stampRemoteSnapshotTruncation,
+  stripJsonc,
   tagComponentStatus,
   validateHarnessReport,
   writeHarnessReportArtifacts
-} from "./cli-9ww72mrd.js";
-import {
-  createCommandContext,
-  stringOption
-} from "./cli-5ms8rw8x.js";
+} from "./cli-y333w08f.js";
 import {
   assertFlags,
   assertPositionals,
@@ -46,6 +45,10 @@ import {
   ApiError,
   callControlAPI
 } from "./cli-87xy1evx.js";
+import {
+  createCommandContext,
+  stringOption
+} from "./cli-5ms8rw8x.js";
 import {
   EXIT_DEGRADED,
   embeddedTenantIdFromApiKey,
@@ -105,8 +108,11 @@ import {
   __toESM
 } from "./cli-0v6na3yp.js";
 
+// src/harness-extract/enumerators/agents.ts
+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
@@ -9140,7 +9146,7 @@ function isUnder2(path, root) {
     return true;
   return path === root || path.startsWith(`${root}/`);
 }
-function stripJsonc(text) {
+function stripJsonc2(text) {
   let out = "";
   let i = 0;
   let inString = false;
@@ -9184,7 +9190,7 @@ function stripJsonc(text) {
 }
 function parseJsonLoose(text) {
   try {
-    return JSON.parse(stripJsonc(text));
+    return JSON.parse(stripJsonc2(text));
   } catch {
     return;
   }
@@ -17635,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;
@@ -17786,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 {
@@ -18363,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);
     }
@@ -18384,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;
@@ -18393,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();
@@ -19031,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-awcd5ns1.js");
+        const { runGithubActionsAnalyze } = await import("./harness-github-actions-m26tapfj.js");
         const result = await runGithubActionsAnalyze(rootDir, {
           writeReport: (report2) => {
             const normalized = normalizeHarnessReport(report2);
@@ -19177,7 +19292,15 @@ async function runHarnessCommand(context) {
         }
         const { artifacts, unknowns } = deterministicGraphItems(rootDir, promote === "all" ? undefined : promote);
         tagComponentStatus({ runtimeAgents: [], artifacts }, rootDir);
-        const promoted = { concern: promote, artifacts, unknowns };
+        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);
+          const found = enumerateHarnessComponents(result, ctx);
+          components = promote === "tools" ? { ...found, artifacts: found.artifacts.filter((entry) => entry.type === "tool") } : promote === "topology" ? { ...found, artifacts: found.artifacts.filter((entry) => entry.type !== "tool") } : found;
+        }
+        const promoted = { concern: promote, unknowns, ...mergeEnumeratedComponents(artifacts, components) };
         const promoteWritten = [];
         if (promoteOut && !context.dryRun) {
           const target = resolve9(context.cwd, promoteOut);
@@ -19204,10 +19327,14 @@ async function runHarnessCommand(context) {
     }
     case "extract": {
       writeHumanProgress(context, "Harness extract: tracing model call sites (no LLM, no network)...");
-      const { extractHarness: extractHarness2, serializeExtractResult } = await import("./index-tpwztst3.js");
-      const result = extractHarness2(rootDir, { fresh: true });
+      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);
+      const graph = mergeEnumeratedComponents(artifacts, enumerateHarnessComponents(result, ctx));
       writeHumanProgress(context, `Harness extract: ${result.callSites.length} call sites, ${result.roles.length} traced roles across ${result.files} files (${result.programs} programs, ${result.durationMs.toLocaleString()} ms).`);
-      context.output.writeData(serializeExtractResult(result), {
+      context.output.writeData({ ...serializeExtractResult(result), graph }, {
         status: result.warnings.length > 0 ? "degraded" : "success",
         ...result.warnings.length > 0 ? { warnings: result.warnings } : {}
       });
@@ -19987,18 +20114,19 @@ function deterministicGraphItems(rootDir, concern) {
   hydratePromptAndToolBodies(graph, rootDir);
   return { artifacts: graph.artifacts, unknowns: graph.unknowns };
 }
-var extractedModelsCache = new Map;
+var extractedModelsCache = new WeakMap;
 function extractedModelItems(rootDir) {
   const empty = { artifacts: [], unknowns: [], rewritten: new Set, enabled: false };
   if (process.env.MODA_HARNESS_EXTRACT === "0")
     return empty;
   const key = resolve9(rootDir);
-  const cached = extractedModelsCache.get(key);
-  if (cached)
-    return cached;
   let items = { ...empty, enabled: true };
   try {
-    const result = extractHarness(key);
+    const { result, ctx } = extractHarnessWithContext(key);
+    createAgentScopeResolver(result, ctx);
+    const cached = extractedModelsCache.get(result);
+    if (cached)
+      return cached;
     for (const warning of result.warnings)
       process.stderr.write(`warning: harness extraction incomplete; ${warning}
 `);
@@ -20008,11 +20136,11 @@ function extractedModelItems(rootDir) {
       rewritten: new Set((result.rewrittenModels ?? []).map((entry) => normalizedModelId(entry.id))),
       enabled: true
     };
+    extractedModelsCache.set(result, items);
   } catch (error) {
     process.stderr.write(`warning: harness extraction failed; model artifacts come from the candidate pre-pass only (${error instanceof Error ? error.message : String(error)})
 `);
   }
-  extractedModelsCache.set(key, items);
   return items;
 }
 var normalizedModelId = (name) => String(name ?? "").trim().toLowerCase();
@@ -20180,7 +20308,7 @@ function withCallSitePrompts(rootDir, promoted) {
     const { result, ctx } = extractHarnessWithContext(rootDir);
     const sites = result.callSites.filter((site) => !site.isTest);
     const toolDefinitions = result.toolDefinitions ?? [];
-    return promptArtifactsFromCallSites(sites, ctx, promoted, { toolDefinitions }).artifacts;
+    return promptArtifactsFromCallSites(sites, ctx, promoted, { toolDefinitions, agentForScope: createAgentScopeResolver(result, ctx) }).artifacts;
   } catch {
     return promoted;
   }
@@ -26390,25 +26518,29 @@ var REASON = {
   config: "model id in model configuration next to a model call"
 };
 function modelArtifacts(result) {
-  return (result.models ?? []).map((model) => ({
-    id: `model_config_${slug(model.id)}_${createHash9("sha256").update(model.id).digest("hex").slice(0, 8)}`,
-    type: "model_config",
-    name: model.id,
-    scope: "shared",
-    usedByAgentIds: [],
-    confidence: CONFIDENCE[model.resolution],
-    confidenceReason: model.resolution === "config" ? "Read from a model-named setting in source; no call site passes it directly." : "Traced from a model call site's model argument to this literal.",
-    evidence: [
-      { path: model.definition.path, line: model.definition.line, reason: REASON[model.resolution] },
-      ...model.calledFrom.slice(0, MAX_CALL_SITE_EVIDENCE).map((site) => ({
-        path: site.path,
-        line: site.line,
-        reason: `model call site${site.enclosing ? ` in ${site.enclosing}` : ""} (${site.callee})`
-      }))
-    ],
-    calledFrom: model.calledFrom.map((site) => ({ path: site.path, line: site.line, ...site.enclosing ? { enclosing: site.enclosing } : {} })),
-    resolution: model.resolution
-  }));
+  const owners = new Map(result.callSites.map((site) => [site.id, site.agentIds ?? []]));
+  return (result.models ?? []).map((model) => {
+    const agentIds = [...new Set(model.calledFrom.flatMap((site) => owners.get(site.callSite) ?? []))].sort();
+    return {
+      id: `model_config_${slug(model.id)}_${createHash9("sha256").update(model.id).digest("hex").slice(0, 8)}`,
+      type: "model_config",
+      name: model.id,
+      scope: agentIds.length === 1 ? "agent" : "shared",
+      usedByAgentIds: agentIds,
+      confidence: CONFIDENCE[model.resolution],
+      confidenceReason: model.resolution === "config" ? "Read from a model-named setting in source; no call site passes it directly." : "Traced from a model call site's model argument to this literal.",
+      evidence: [
+        { path: model.definition.path, line: model.definition.line, reason: REASON[model.resolution] },
+        ...model.calledFrom.slice(0, MAX_CALL_SITE_EVIDENCE).map((site) => ({
+          path: site.path,
+          line: site.line,
+          reason: `model call site${site.enclosing ? ` in ${site.enclosing}` : ""} (${site.callee})`
+        }))
+      ],
+      calledFrom: model.calledFrom.map((site) => ({ path: site.path, line: site.line, ...site.enclosing ? { enclosing: site.enclosing } : {} })),
+      resolution: model.resolution
+    };
+  });
 }
 function describeSource(source) {
   const [kind, ...rest] = source.split(":");
@@ -26619,210 +26751,1173 @@ function collectModelLiterals(rootDir) {
   return { literals: [...found].sort(), truncated: capped || skipped };
 }
 
-// src/harness-extract/types.ts
-var EXTRACT_SCHEMA_VERSION = 1;
-// src/harness-extract/enumerators/index.ts
-var ENUMERATORS = [];
-// 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 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 lineOf5(node) {
+  return node.getSourceFile().getLineAndCharacterOfPosition(node.getStart()).line + 1;
 }
-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 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 namedEnclosingFunction(node) {
-  for (let fn = enclosingFunction(node);fn; fn = enclosingFunction(fn)) {
-    const name = functionName(fn);
-    if (name)
-      return { fn, name };
-  }
-  return;
+function visit(node, fn) {
+  fn(node);
+  import_typescript10.default.forEachChild(node, (child) => visit(child, fn));
 }
-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 componentId(kind, path, name) {
+  return `${kind}:${path}:${name}`;
 }
-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 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 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 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 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 emptyResult() {
+  return { runtimeAgents: [], artifacts: [], warnings: [] };
 }
-function callerChain(rootDir, anchor, calls, memo) {
-  const start = namedEnclosingFunction(anchor);
-  if (!start)
-    return { callers: [], callerScopes: [] };
-  const cached = memo.get(start.fn);
-  if (cached)
-    return cached;
-  const chain = { callers: [], callerScopes: [] };
-  const seen = new Set;
-  let current = start;
-  while (current && !seen.has(current.fn) && chain.callers.length <= MAX_CALLER_CHAIN) {
-    seen.add(current.fn);
-    chain.callers.unshift(qualifiedName(current.fn, current.name));
-    chain.callerScopes.unshift(functionScope(rootDir, current.fn, current.name));
-    const caller = calls.callersOf(current.fn, current.name, 1)[0];
-    current = caller ? namedEnclosingFunction(caller) : undefined;
-  }
-  memo.set(start.fn, chain);
-  return chain;
+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() };
 }
-var AGENT_CLASS_BASES = new Set(["Think", "Agent", "AIChatAgent"]);
-function findAgentClasses(program, checker, memo) {
+
+// 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 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 base = frameworkBaseOf(node, checker, memo).base;
-        if (base && AGENT_CLASS_BASES.has(base))
-          out.push(node);
-      }
-      import_typescript10.default.forEachChild(node, visit);
-    };
-    visit(source);
+  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 describeEnclosing(rootDir, anchor, checker, memo, ownClass) {
-  const fn = ownClass ? undefined : namedEnclosingFunction(anchor);
-  const cls = ownClass ?? enclosingClass(anchor);
-  let enclosingCls;
+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);
+  if (!start)
+    return { callers: [], callerScopes: [] };
+  const cached = memo.get(start.fn);
+  if (cached)
+    return cached;
+  const chain = { callers: [], callerScopes: [] };
+  const seen = new Set;
+  let current = start;
+  while (current && !seen.has(current.fn) && chain.callers.length <= MAX_CALLER_CHAIN) {
+    seen.add(current.fn);
+    chain.callers.unshift(qualifiedName(current.fn, current.name));
+    chain.callerScopes.unshift(functionScope(rootDir, current.fn, current.name));
+    const caller = calls.callersOf(current.fn, current.name, 1)[0];
+    current = caller ? namedEnclosingFunction(caller) : undefined;
+  }
+  memo.set(start.fn, chain);
+  return chain;
+}
+var AGENT_CLASS_BASES = new Set(["Think", "Agent", "AIChatAgent"]);
+function findAgentClasses(program, checker, memo) {
+  const out = [];
+  for (const source of program.getSourceFiles()) {
+    if (source.isDeclarationFile || /[\\/]node_modules[\\/]/.test(source.fileName))
+      continue;
+    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_typescript13.default.forEachChild(node, visit2);
+    };
+    visit2(source);
+  }
+  return out;
+}
+function describeEnclosing(rootDir, anchor, checker, memo, ownClass) {
+  const fn = ownClass ? undefined : namedEnclosingFunction(anchor);
+  const cls = ownClass ?? enclosingClass(anchor);
+  let enclosingCls;
   if (cls) {
     const info = frameworkBaseOf(cls, checker, memo);
     const at = cls.name ?? cls;
@@ -26857,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;
@@ -26897,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;
@@ -26976,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();
@@ -26992,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))
@@ -27002,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}`);
@@ -27054,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 });
@@ -27183,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;
@@ -27196,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) {
@@ -27242,4 +28347,853 @@ function assignAgentIds(result, agentForScope) {
   }
 }
 
-export { startRemoteAnalyze, pollRemoteAnalyzeUntilDone, isRecoverableRemoteRun, checkPromptMapping, safePromptEvidencePath, discoverHarnessPromptSources, valueChildren, selectKey, allValues, renderings, CALL_SINKS, registerCallSink, registerClassSink, isModelId, collectModels, modelArtifacts, modelUnknowns, collectModelLiterals, EXTRACT_SCHEMA_VERSION, ENUMERATORS, 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 };
+// src/harness-extract/enumerators/agents.ts
+function agentForScope(scope, enumeration) {
+  return enumeration.agentForScope(scope);
+}
+function createAgentScopeResolver(result, ctx) {
+  return enumerateAgents(result, ctx).agentForScope;
+}
+var enumerations = new WeakMap;
+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_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})`;
+  }
+  return;
+}
+function enumerateAgents(result, ctx) {
+  const cached = enumerations.get(ctx);
+  if (cached)
+    return cached;
+  const repo = enumerationRepository(ctx);
+  const scopes = new Map;
+  const byNode = new Map;
+  const classes = [];
+  const bound = new Set(detectBoundRuntimeClasses(ctx.rootDir).filter((x) => x.kind === "durable_object").map((x) => x.className));
+  const memo = createFrameworkMemo();
+  const keyOf = (node) => `${node.getSourceFile().fileName}:${node.getStart()}`;
+  for (const file of repo.files) {
+    if (!/\.[cm]?[jt]sx?$/.test(file.path) || TEST_PATH4.test(file.path) || EVAL_PATH2.test(file.path) || /^scripts\//.test(file.path) && !repo.deployedFiles.has(file.path))
+      continue;
+    const checker = ctx.checkerFor(file.path);
+    visit(file.source, (node) => {
+      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_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_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] });
+        }
+      }
+      if (!isFunctionLike(node) || !node.body)
+        return;
+      const name = functionName(node);
+      const cls = enclosingClass(node)?.name?.text;
+      const route = routeOf(node, file);
+      const label = cls && name ? `${cls}.${name}` : name ?? route ?? `${file.path}:${lineOf5(node)}`;
+      const scope = {
+        key: keyOf(node),
+        label,
+        aliases: [label, ...name ? [name] : [], ...route ? [route] : [], `${file.path}::${label}`, `${file.path}#${label}`],
+        file,
+        node,
+        className: cls,
+        route,
+        calls: new Set,
+        virtualCalls: new Map,
+        deployedCalls: new Set,
+        callsByWorker: new Map(repo.workers.map((worker) => [worker.id, new Set])),
+        callers: new Set,
+        hasModel: false,
+        modelWorkers: new Set,
+        hasTools: false,
+        toolFeedback: false,
+        configuredSteps: false,
+        hasLoop: false,
+        forcedOutput: false
+      };
+      const qualified = (fn, fnName) => {
+        const owner = enclosingClass(fn);
+        return owner?.name && (fn.parent === owner || fn.parent?.parent === owner) ? `${owner.name.text}.${fnName}` : fnName;
+      };
+      if (name) {
+        const parts = [qualified(node, name)];
+        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_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);
+            if (outerName)
+              parts.unshift(qualified(outer, outerName));
+          }
+        }
+        scope.aliases.push(`${file.path}#${parts.join(".")}`);
+      }
+      scope.aliases.push(scope.key);
+      scopes.set(scope.key, scope);
+      byNode.set(node, scope);
+    });
+  }
+  const classChain = (node, seen = new Set) => {
+    if (seen.has(keyOf(node)))
+      return [];
+    seen.add(keyOf(node));
+    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_typescript14.default.isClassLike(declaration) ? classChain(declaration, seen) : [];
+    }) ?? [];
+    return [node, ...bases];
+  };
+  for (const cls of classes)
+    cls.nodes = classChain(cls.node);
+  const virtualEdges = new Map;
+  const nearest = (node) => {
+    for (let current = node;current; current = current.parent) {
+      const scope = byNode.get(current);
+      if (scope)
+        return scope;
+    }
+    return;
+  };
+  const bindingTruth = (condition, worker) => {
+    if (condition.kind === import_typescript14.default.SyntaxKind.TrueKeyword)
+      return true;
+    if (condition.kind === import_typescript14.default.SyntaxKind.FalseKeyword)
+      return false;
+    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_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_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_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_typescript14.default.isBlock(parent))
+        for (const prior of parent.statements) {
+          if (prior.getStart() >= current.getStart())
+            break;
+          if (import_typescript14.default.isIfStatement(prior)) {
+            const truth = bindingTruth(prior.expression, worker);
+            if (truth !== undefined && returns(truth ? prior.thenStatement : prior.elseStatement))
+              return false;
+          }
+        }
+    }
+    return true;
+  };
+  const markModel = (scope, node) => {
+    scope.hasModel = true;
+    for (const worker of repo.workers)
+      if (deployed(node, worker.id))
+        scope.modelWorkers.add(worker.id);
+  };
+  for (const site of result.callSites) {
+    if (site.isTest || site.isEval)
+      continue;
+    const file = repo.files.find((x) => x.path === site.path);
+    if (!file)
+      continue;
+    const offset = file.source.getPositionOfLineAndCharacter(Math.max(0, site.line - 1), Math.max(0, site.col - 1));
+    let anchor = file.source;
+    const descend = (node) => {
+      if (node.getStart() <= offset && node.getEnd() >= offset) {
+        anchor = node;
+        import_typescript14.default.forEachChild(node, descend);
+      }
+    };
+    descend(file.source);
+    const scope = nearest(anchor);
+    if (!scope)
+      continue;
+    markModel(scope, anchor);
+    const tools = site.toolsArg ? ctx.nodeAt(site.toolsArg) : undefined;
+    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_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_typescript14.default.isVariableDeclaration(declaration) && declaration.initializer) {
+      const fn = byNode.get(declaration.initializer) ?? scopes.get(keyOf(declaration.initializer));
+      if (fn)
+        return [fn];
+    }
+    return [];
+  };
+  for (const scope of scopes.values()) {
+    const inspect = (node) => {
+      if (node !== scope.node && isFunctionLike(node)) {
+        return;
+      }
+      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_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_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_typescript14.default.isStringLiteralLike(type) && type.text === "tool" && fields.has("name"))
+          scope.forcedOutput = true;
+      }
+      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);
+        if (/\.runTurn$/.test(callee) && scope.node.parameters.some((param) => /tools/i.test(param.name.getText())))
+          markModel(scope, node);
+        const connect = (at) => {
+          for (const target of byNode.has(at) ? [byNode.get(at)] : targetsOf(at, scope.file)) {
+            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);
+            }
+            scope.calls.add(target.key);
+            if (deployed(at))
+              scope.deployedCalls.add(target.key);
+            for (const [worker, calls] of scope.callsByWorker)
+              if (deployed(at, worker))
+                calls.add(target.key);
+            target.callers.add(scope.key);
+          }
+        };
+        connect(node.expression);
+        const connectArgument = (at) => {
+          if (isFunctionLike(at)) {
+            connect(at);
+            return;
+          }
+          if (import_typescript14.default.isIdentifier(at) || import_typescript14.default.isPropertyAccessExpression(at))
+            connect(at);
+          import_typescript14.default.forEachChild(at, connectArgument);
+        };
+        for (const argument of node.arguments ?? [])
+          connectArgument(argument);
+        for (const argument of node.arguments ?? [])
+          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_typescript14.default.isNumericLiteral(node.arguments?.[0]) && Number(node.arguments?.[0].text) > 1) {
+          scope.hasLoop = true;
+          scope.configuredSteps = true;
+        }
+      }
+      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_typescript14.default.forEachChild(node, inspect);
+    };
+    inspect(scope.node);
+  }
+  const modelQueue = [...scopes.values()].filter((scope) => scope.hasModel);
+  for (let index = 0;index < modelQueue.length; index++) {
+    const scope = modelQueue[index];
+    if (scope.reachesModel)
+      continue;
+    scope.reachesModel = true;
+    for (const caller of scope.callers) {
+      const parent = scopes.get(caller);
+      if (parent && !parent.reachesModel)
+        modelQueue.push(parent);
+    }
+  }
+  const agents = new Map;
+  const owners = new Map;
+  const assign = (key, id) => {
+    let values = owners.get(key);
+    if (!values)
+      owners.set(key, values = new Set);
+    values.add(id);
+  };
+  for (const cls of classes) {
+    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_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_typescript14.default.isClassLike(member2.parent))
+        member2 = member2.parent;
+      const memberName = "name" in member2 ? nameOf(member2.name) : undefined;
+      for (const cls of classes) {
+        const ownerClass = enclosingClass(scope.node);
+        const baseIndex = cls.nodes.findIndex((node) => ownerClass && keyOf(node) === keyOf(ownerClass));
+        if (baseIndex < 0)
+          continue;
+        const overridden = memberName && cls.nodes.slice(0, baseIndex).some((node) => node.members.some((candidate) => nameOf(candidate.name) === memberName));
+        if (!overridden)
+          assign(scope.key, componentId("agent", cls.file.path, cls.name));
+      }
+    }
+    if (!scope.className && !scope.forcedOutput && scope.hasLoop && scope.hasTools && (scope.toolFeedback || scope.configuredSteps) && scope.reachesModel) {
+      let boundary = scope;
+      for (let parent = scope.node.parent;parent; parent = parent.parent) {
+        const outer = byNode.get(parent);
+        if (outer?.route) {
+          boundary = outer;
+          break;
+        }
+      }
+      const name = boundary.route ?? functionName(boundary.node);
+      if (!name)
+        continue;
+      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;
+  while (changed) {
+    changed = false;
+    for (const scope of scopes.values())
+      for (const callee of scope.calls)
+        for (const id of owners.get(scope.key) ?? []) {
+          let targetKey = callee;
+          const virtual = virtualEdges.get(`${scope.key}|${callee}`), concrete = classes.find((cls) => componentId("agent", cls.file.path, cls.name) === id);
+          if (virtual && concrete) {
+            const implementation = concrete.nodes.flatMap((node) => node.members.filter((member2) => nameOf(member2.name) === virtual))[0];
+            if (implementation && scopes.has(keyOf(implementation)))
+              targetKey = keyOf(implementation);
+          }
+          const before = owners.get(targetKey)?.size ?? 0;
+          assign(targetKey, id);
+          changed ||= (owners.get(targetKey)?.size ?? 0) !== before;
+        }
+  }
+  const scopeOwners = new Map;
+  const mergeAlias = (label, ids) => {
+    let values = scopeOwners.get(label);
+    if (!values)
+      scopeOwners.set(label, values = new Set);
+    for (const id of ids)
+      values.add(id);
+  };
+  const classAliases = new Map;
+  for (const cls of classes)
+    for (const base of cls.nodes) {
+      if (!base.name)
+        continue;
+      const qualified = `${base.getSourceFile().fileName.slice(ctx.rootDir.length + 1)}#${base.name.text}`;
+      mergeAlias(qualified, [componentId("agent", cls.file.path, cls.name)]);
+      let variants = classAliases.get(base.name.text);
+      if (!variants)
+        classAliases.set(base.name.text, variants = new Set);
+      variants.add(qualified);
+    }
+  for (const [name, variants] of classAliases)
+    if (variants.size === 1)
+      mergeAlias(name, scopeOwners.get([...variants][0]) ?? []);
+  const aliases = new Map;
+  for (const scope of scopes.values())
+    for (const alias of scope.aliases) {
+      const matches = aliases.get(alias) ?? [];
+      matches.push(scope);
+      aliases.set(alias, matches);
+    }
+  for (const [alias, matches] of aliases) {
+    const candidates = matches.map((scope) => [...owners.get(scope.key) ?? []].sort());
+    if (candidates.every((ids) => JSON.stringify(ids) === JSON.stringify(candidates[0])))
+      mergeAlias(alias, candidates[0]);
+  }
+  const output = {
+    runtimeAgents: [...agents.values()].sort((a, b) => a.id.localeCompare(b.id)),
+    agentForScope: (scope) => scope ? [...scopeOwners.get(scope) ?? []].sort() : [],
+    scopes: [...scopes.values()]
+  };
+  enumerations.set(ctx, output);
+  assignAgentIds(result, output.agentForScope);
+  return output;
+}
+
+// src/harness-extract/enumerators/workflows.ts
+var import_typescript15 = __toESM(require_typescript(), 1);
+function enumerateWorkflows(result, ctx) {
+  const output = emptyResult();
+  const repo = enumerationRepository(ctx);
+  const nodeKey = (node) => `${node.getSourceFile().fileName}:${node.getStart()}`;
+  const bindings = new Set;
+  for (const worker of repo.workers) {
+    const file = repo.files.find((entry) => entry.path === worker.main), checker = file && ctx.checkerFor(file.path);
+    const module = file && checker?.getSymbolAtLocation(file.source);
+    if (!module || !checker)
+      continue;
+    for (const name of worker.workflowClasses) {
+      let exported = checker.getExportsOfModule(module).find((symbol) => symbol.name === name);
+      if (exported && exported.flags & import_typescript15.default.SymbolFlags.Alias)
+        exported = checker.getAliasedSymbol(exported);
+      const declaration = exported && valueDeclaration(exported);
+      if (declaration && import_typescript15.default.isClassDeclaration(declaration))
+        bindings.add(nodeKey(declaration));
+    }
+  }
+  const memo = createFrameworkMemo();
+  for (const file of repo.files) {
+    if (!/\.[cm]?[jt]sx?$/.test(file.path) || TEST_PATH4.test(file.path) || EVAL_PATH2.test(file.path))
+      continue;
+    visit(file.source, (node) => {
+      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;
+      const directBase = node.heritageClauses?.flatMap((h) => h.types).map((x) => x.expression.getText()) ?? [];
+      if (!bindings.has(nodeKey(node)) && base !== "WorkflowEntrypoint" && base !== "AgentWorkflow" && !directBase.some((x) => /^(?:WorkflowEntrypoint|AgentWorkflow)$/.test(x)))
+        return;
+      const entry = artifact("entrypoint", node.name.text, file, node, "Concrete Workflow class or Wrangler workflow binding", repo.status(file.path));
+      entry.id = componentId("workflow", file.path, node.name.text);
+      if (bindings.has(nodeKey(node))) {
+        Object.assign(entry, { componentKind: "workflow", trigger: "workflow_binding" });
+      }
+      output.artifacts.push(entry);
+    });
+  }
+  for (const worker of repo.workers.filter((entry) => entry.cron)) {
+    const scopes = enumerateAgents(result, ctx).scopes;
+    const byKey = new Map(scopes.map((scope) => [scope.key, scope]));
+    const implementations = new Map, workerClasses = new Set;
+    const deployedCalls = (scope) => {
+      const calls = scope.callsByWorker.get(worker.id) ?? scope.deployedCalls;
+      const cls = enclosingClass(scope.node);
+      if (!cls || !workerClasses.has(nodeKey(cls)))
+        return calls;
+      const member2 = scope.node.parent === cls ? scope.node : scope.node.parent;
+      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);
+        return method && implementations.has(method) ? implementations.get(method) : key;
+      }));
+    };
+    const modelScopes = new Set(scopes.filter((scope) => scope.modelWorkers.has(worker.id)).map((scope) => scope.key));
+    const mainFile = repo.files.find((file) => file.path === worker.main), checker = mainFile && ctx.checkerFor(mainFile.path);
+    const exportedNodes = new Set, visited = new Set;
+    const resolveWorker = (node) => {
+      if (!node || visited.has(node))
+        return;
+      visited.add(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_typescript15.default.isCallExpression(node) && /(?:^|\.)withSentry$/.test(node.expression.getText())) {
+        for (const argument of node.arguments)
+          resolveWorker(argument);
+        return;
+      }
+      if (import_typescript15.default.isExportAssignment(node)) {
+        resolveWorker(node.expression);
+        return;
+      }
+      if (import_typescript15.default.isVariableDeclaration(node)) {
+        resolveWorker(node.initializer);
+        return;
+      }
+      if (import_typescript15.default.isIdentifier(node) && checker) {
+        resolveWorker(valueDeclaration(resolvedSymbol(node, checker)));
+        return;
+      }
+      exportedNodes.add(node);
+    };
+    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_typescript15.default.SymbolFlags.Alias ? checker.getAliasedSymbol(exported) : exported);
+    resolveWorker(symbol && valueDeclaration(symbol));
+    const collectImplementations = (node) => {
+      if (!import_typescript15.default.isClassLike(node) || workerClasses.has(nodeKey(node)))
+        return;
+      workerClasses.add(nodeKey(node));
+      for (const member2 of node.members) {
+        if (import_typescript15.default.getCombinedModifierFlags(member2) & import_typescript15.default.ModifierFlags.Static)
+          continue;
+        const name = nameOf(member2.name);
+        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)");
+      }
+      if (checker)
+        for (const base of node.heritageClauses?.flatMap((clause) => clause.types) ?? []) {
+          const declaration = valueDeclaration(resolvedSymbol(base.expression, checker));
+          if (declaration)
+            collectImplementations(declaration);
+        }
+    };
+    for (const node of exportedNodes)
+      collectImplementations(node);
+    let changed = true;
+    while (changed) {
+      changed = false;
+      for (const scope of scopes)
+        if (!modelScopes.has(scope.key) && [...deployedCalls(scope)].some((key) => modelScopes.has(key))) {
+          modelScopes.add(scope.key);
+          changed = true;
+        }
+    }
+    const scheduledNodes = new Set;
+    const resolveScheduled = (node, seen2 = new Set) => {
+      if (!node || seen2.has(node))
+        return;
+      seen2.add(node);
+      if (import_typescript15.default.isIdentifier(node) && checker) {
+        resolveScheduled(valueDeclaration(resolvedSymbol(node, checker)), seen2);
+        return;
+      }
+      if (import_typescript15.default.isVariableDeclaration(node) || import_typescript15.default.isPropertyAssignment(node) || import_typescript15.default.isPropertyDeclaration(node)) {
+        resolveScheduled(node.initializer, seen2);
+        return;
+      }
+      if (import_typescript15.default.isShorthandPropertyAssignment(node)) {
+        resolveScheduled(checker && valueDeclaration(checker.getShorthandAssignmentValueSymbol(node)), seen2);
+        return;
+      }
+      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;
+      }
+      scheduledNodes.add(node);
+    };
+    const collectScheduled = (node, seen2 = new Set) => {
+      if (seen2.has(node))
+        return;
+      seen2.add(node);
+      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_typescript15.default.isClassLike(node) && checker)
+        for (const base of node.heritageClauses?.flatMap((clause) => clause.types) ?? []) {
+          const declaration = valueDeclaration(resolvedSymbol(base.expression, checker));
+          if (declaration)
+            collectScheduled(declaration, seen2);
+        }
+    };
+    for (const node of exportedNodes)
+      collectScheduled(node);
+    const roots = scopes.filter((scope) => [...scheduledNodes].some((node) => node.getSourceFile().fileName === scope.node.getSourceFile().fileName && node.getStart() === scope.node.getStart()));
+    const seen = new Set;
+    const queue = roots.flatMap((scope) => scope.modelWorkers.has(worker.id) ? [scope.key] : [...deployedCalls(scope)]);
+    for (let i = 0;i < queue.length; i++) {
+      const key = queue[i];
+      if (seen.has(key))
+        continue;
+      seen.add(key);
+      const scope = byKey.get(key);
+      if (!scope)
+        continue;
+      if (!modelScopes.has(scope.key)) {
+        if (/(?:Cron|Pipeline)$/.test(scope.label)) {
+          const entry = artifact("entrypoint", scope.label, scope.file, scope.node, "Scheduled entrypoint has no deployed model step on its own pipeline", repo.status(scope.file.path));
+          const proof = [...scope.calls].map((callee) => byKey.get(callee)).filter((callee) => callee?.reachesModel).map((callee) => `${callee.file.path}#${callee.label}`);
+          Object.assign(entry, { exclusionReason: scope.reachesModel ? "Model reachable only through a queue consumer or statically excluded fallback" : "No model reachable from scheduled pipeline", proofPath: [`${scope.file.path}#${scope.label}`, ...proof] });
+          output.artifacts.push(entry);
+        } else
+          queue.push(...deployedCalls(scope));
+        continue;
+      }
+      if (/(?:Cron|Pipeline)$/.test(scope.label) || scope.modelWorkers.has(worker.id)) {
+        const entry = artifact("entrypoint", scope.label, scope.file, scope.node, "Cron dispatch reaches this model-backed pipeline", repo.status(scope.file.path));
+        entry.id = componentId("workflow", scope.file.path, scope.label);
+        entry.componentKind = "workflow";
+        entry.trigger = "cron";
+        output.artifacts.push(entry);
+        if (roots.includes(scope))
+          queue.push(...deployedCalls(scope));
+      } else
+        queue.push(...deployedCalls(scope));
+    }
+  }
+  return stableResult(output);
+}
+
+// src/harness-extract/enumerators/catalog.ts
+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)
+    return [];
+  const node = unwrap(expression);
+  if (seen.has(node))
+    return [];
+  seen.add(node);
+  if (import_typescript16.default.isIdentifier(node)) {
+    const declaration = checker && valueDeclaration(resolvedSymbol(node, checker));
+    if (!declaration || !import_typescript16.default.isVariableDeclaration(declaration))
+      return [];
+    return strings(declaration.initializer, checker, seen);
+  }
+  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_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_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_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_typescript16.default.isClassDeclaration(declaration) || import_typescript16.default.isClassExpression(declaration)))
+        return inheritedTrue(declaration, propertyName2, checker, seen);
+    }
+  return false;
+}
+function enumerateToolCatalog(result, ctx) {
+  const output = emptyResult(), repo = enumerationRepository(ctx), agents = enumerateAgents(result, ctx);
+  const agentByName = new Map(agents.runtimeAgents.map((entry) => [entry.name, entry.id]));
+  const symbolOwners = new Map;
+  for (const scope of agents.scopes) {
+    const owners = agents.agentForScope(scope.key);
+    const checker = ctx.checkerFor(scope.file.path);
+    if (!owners.length || !checker)
+      continue;
+    visit(scope.node, (node) => {
+      if (!import_typescript16.default.isIdentifier(node) || !/ALLOW|MCP_NAME/.test(node.text))
+        return;
+      const declaration = valueDeclaration(resolvedSymbol(node, checker));
+      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);
+      if (!existing)
+        symbolOwners.set(key, existing = new Set);
+      for (const id of owners)
+        existing.add(id);
+    });
+  }
+  const ownersAt = (node, path) => {
+    const scope = agents.scopes.filter((s) => s.file.path === path && s.node.getStart() <= node.getStart() && s.node.getEnd() >= node.getEnd()).sort((a, b) => a.node.getWidth() - b.node.getWidth())[0];
+    return scope ? agents.agentForScope(scope.key) : [];
+  };
+  const memo = createFrameworkMemo();
+  const thinkIds = new Set;
+  for (const runtime of agents.runtimeAgents) {
+    const file = repo.files.find((entry) => entry.path === runtime.evidence[0]?.path), checker = file && ctx.checkerFor(file.path);
+    if (!file || !checker)
+      continue;
+    visit(file.source, (node) => {
+      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);
+    });
+  }
+  const add = (name, file, node, source, reason, owners = []) => {
+    const evidenceFile = repo.files.find((entry2) => entry2.source.fileName === node.getSourceFile().fileName) ?? file;
+    const entry = artifact("tool", name, evidenceFile, node, reason, repo.status(file.path));
+    entry.catalogSource = source;
+    entry.usedByAgentIds = owners;
+    output.artifacts.push(entry);
+    return entry;
+  };
+  for (const file of repo.files) {
+    if (!/\.[cm]?[jt]sx?$/.test(file.path) || TEST_PATH4.test(file.path) || EVAL_PATH2.test(file.path) || /^scripts\//.test(file.path) && !repo.deployedFiles.has(file.path))
+      continue;
+    const checker = ctx.checkerFor(file.path), declarations = new Map;
+    visit(file.source, (node) => {
+      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_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) {
+          const owners2 = agents.agentForScope(`${file.path}#${node.name.text}`);
+          const names = [...THINK_WORKSPACE_TOOLS];
+          if (inheritedTrue(node, "workspaceBash", checker))
+            names.push("bash");
+          for (const name of names)
+            add(name, file, node, "think", "Think workspace tool inherited by this concrete agent", owners2);
+        }
+      }
+      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_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_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_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_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_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_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_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_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;
+        entry.namePattern = `tool_<${server}ServerId>_*`;
+        return;
+      }
+      for (const tool of strings(allow, checker)) {
+        const name = `tool_<${server}ServerIdNoDashes>_${tool.name}`;
+        const entry = add(name, file, tool.node, "mcp_allowlist", "Literal MCP allowlist converted by the Agents SDK tool_<serverId>_<name> contract", owners);
+        entry.id = componentId("tool", file.path, `${server}:${name}`);
+        entry.serverName = server;
+        entry.namePattern = name;
+      }
+    });
+    for (const [name, initializer] of declarations) {
+      const match = name.match(/^(.*)_ALLOWED_TOOLS$/);
+      if (!match)
+        continue;
+      const serverName = strings(declarations.get(`${match[1]}_MCP_NAME`), checker)[0]?.name;
+      if (!serverName)
+        continue;
+      for (const tool of strings(initializer, checker)) {
+        const entry = add(`${serverName}_${tool.name}`, file, tool.node, "mcp_allowlist", "Explicit named MCP allowlist with server-prefixed model name");
+        entry.serverName = serverName;
+        entry.usedByAgentIds = [...symbolOwners.get(`${file.source.fileName}:${name}`) ?? []].sort();
+      }
+    }
+  }
+  const merged = new Map;
+  for (const item of output.artifacts) {
+    const previous = merged.get(item.name);
+    if (previous) {
+      previous.usedByAgentIds = [...new Set([...previous.usedByAgentIds, ...item.usedByAgentIds])].sort();
+      const seen = new Set(previous.evidence.map((e) => `${e.path}:${e.line}`));
+      previous.evidence.push(...item.evidence.filter((e) => !seen.has(`${e.path}:${e.line}`)));
+      if (item.status === "in_prod" || item.status === "reachable" && previous.status === "defined_only")
+        previous.status = item.status;
+    } else {
+      item.id = `tool:catalog:${item.name}`;
+      merged.set(item.name, item);
+    }
+  }
+  output.artifacts = [...merged.values()];
+  return stableResult(output);
+}
+
+// src/harness-extract/enumerators/index.ts
+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: "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, ...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;
+  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") {
+      const own = item.definitionVariants ?? (item.body ? [{ sourcePath: item.sourcePath, body: item.body, evidence: item.evidence }] : []);
+      let variants = definitions.get(key);
+      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) {
+      merged.set(key, { ...item, evidence: [...item.evidence], usedByAgentIds: [...item.usedByAgentIds] });
+      continue;
+    }
+    const rank = { defined_only: 0, reachable: 1, in_prod: 2 };
+    if (item.status && (!previous.status || rank[item.status] > rank[previous.status]))
+      previous.status = item.status;
+    previous.usedByAgentIds = [...new Set([...previous.usedByAgentIds, ...item.usedByAgentIds])].sort();
+    const evidence = new Set(previous.evidence.map((entry) => `${entry.path}:${entry.line}`));
+    previous.evidence.push(...item.evidence.filter((entry) => !evidence.has(`${entry.path}:${entry.line}`)));
+    if (!previous.body && item.body && !previous.definitionVariants)
+      previous.body = item.body;
+  }
+  for (const [key, variants] of definitions) {
+    const item = merged.get(key);
+    if (variants.length > 1 || item.id !== variants[0].id)
+      item.definitionVariants = variants;
+    if (new Set(variants.map((entry) => entry.body)).size > 1)
+      delete item.body;
+  }
+  const output = [...merged.values()].sort((a, b) => a.id.localeCompare(b.id));
+  const runtimeAgents = components.runtimeAgents.map((entry) => ({
+    ...entry,
+    artifactIds: [...new Set([...entry.artifactIds, ...output.filter((item) => item.usedByAgentIds.includes(entry.id)).map((item) => item.id)])].sort()
+  }));
+  return { runtimeAgents, artifacts: output };
+}
+
+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 };