@moda-ai/cli 1.55.71 → 1.55.73

package/dist/{cli-tgjvf91h.js → cli-h5ar0v9v.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,6 +108,9 @@ import {
   __toESM
 } from "./cli-0v6na3yp.js";
 
+// src/harness-extract/enumerators/agents.ts
+var import_typescript12 = __toESM(require_typescript(), 1);
+
 // src/harness-extract/index.ts
 var import_typescript10 = __toESM(require_typescript(), 1);
 import { resolve as resolve13 } from "node:path";
@@ -3136,12 +3142,60 @@ function effectiveField(object, key) {
   });
   return fields;
 }
+var WRITTEN_SYMBOLS = new WeakMap;
+function writtenSymbols(file, checker) {
+  let written = WRITTEN_SYMBOLS.get(file);
+  if (written)
+    return written;
+  const found = new Set;
+  const add = (node) => {
+    const root = rootIdentifier(node);
+    const symbol = root ? resolvedSymbol(root, checker) : undefined;
+    if (symbol)
+      found.add(symbol);
+  };
+  const visit = (node) => {
+    if (import_typescript5.default.isBinaryExpression(node) && node.operatorToken.kind >= import_typescript5.default.SyntaxKind.FirstAssignment && node.operatorToken.kind <= import_typescript5.default.SyntaxKind.LastAssignment)
+      add(node.left);
+    else if (import_typescript5.default.isDeleteExpression(node))
+      add(node.expression);
+    else if ((import_typescript5.default.isPrefixUnaryExpression(node) || import_typescript5.default.isPostfixUnaryExpression(node)) && (node.operator === import_typescript5.default.SyntaxKind.PlusPlusToken || node.operator === import_typescript5.default.SyntaxKind.MinusMinusToken))
+      add(node.operand);
+    else if (import_typescript5.default.isCallExpression(node) && node.arguments.length > 0) {
+      const callee = unwrap(node.expression);
+      if (import_typescript5.default.isPropertyAccessExpression(callee) && callee.name.text === "assign")
+        add(node.arguments[0]);
+    }
+    import_typescript5.default.forEachChild(node, visit);
+  };
+  visit(file);
+  written = found;
+  WRITTEN_SYMBOLS.set(file, written);
+  return written;
+}
+function gatewayRequestLiteral(argument, checker) {
+  const value = unwrap(argument);
+  if (import_typescript5.default.isObjectLiteralExpression(value))
+    return value;
+  if (!import_typescript5.default.isIdentifier(value))
+    return;
+  const symbol = resolvedSymbol(value, checker);
+  const declaration = valueDeclaration(symbol);
+  if (!symbol || !declaration || !import_typescript5.default.isVariableDeclaration(declaration) || !declaration.initializer)
+    return;
+  if (!(import_typescript5.default.getCombinedNodeFlags(declaration) & import_typescript5.default.NodeFlags.Const))
+    return;
+  const literal = unwrap(declaration.initializer);
+  if (!import_typescript5.default.isObjectLiteralExpression(literal))
+    return;
+  return writtenSymbols(declaration.getSourceFile(), checker).has(symbol) ? undefined : literal;
+}
 var GATEWAY_METHODS = new Set(["call", "stream"]);
 var GATEWAY_BODY_KEYS = { system: "system", messages: "messages", prompt: "prompt", model: "model", tools: "tools" };
 var modelGatewaySink = {
   id: "model-gateway",
   sdk: "model-gateway",
-  match(call) {
+  match(call, ctx) {
     if (!import_typescript5.default.isCallExpression(call) || call.arguments.length !== 1)
       return;
     const callee = unwrap(call.expression);
@@ -3150,8 +3204,8 @@ var modelGatewaySink = {
     const receiver = unwrap(callee.expression);
     if (!import_typescript5.default.isPropertyAccessExpression(receiver) || receiver.name.text !== "models")
       return;
-    const request = unwrap(call.arguments[0]);
-    if (!import_typescript5.default.isObjectLiteralExpression(request) || !propertyValue(request, "kind"))
+    const request = gatewayRequestLiteral(call.arguments[0], ctx.checker);
+    if (!request || !propertyValue(request, "kind"))
       return;
     const roles = [];
     for (const body of effectiveField(request, "body")) {
@@ -9092,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;
@@ -9136,7 +9190,7 @@ function stripJsonc(text) {
 }
 function parseJsonLoose(text) {
   try {
-    return JSON.parse(stripJsonc(text));
+    return JSON.parse(stripJsonc2(text));
   } catch {
     return;
   }
@@ -18983,7 +19037,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-6p1czt5h.js");
+        const { runGithubActionsAnalyze } = await import("./harness-github-actions-p4011crc.js");
         const result = await runGithubActionsAnalyze(rootDir, {
           writeReport: (report2) => {
             const normalized = normalizeHarnessReport(report2);
@@ -19129,7 +19183,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-4z7h9mam.js");
+        const { enumerateHarnessComponents, mergeEnumeratedComponents } = await import("./index-femt9s00.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);
@@ -19156,10 +19218,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-8pzrw7v9.js");
-      const result = extractHarness2(rootDir, { fresh: true });
+      const { extractHarnessWithContext: extractHarnessWithContext2, serializeExtractResult } = await import("./index-4z7h9mam.js");
+      const { enumerateHarnessComponents, mergeEnumeratedComponents } = await import("./index-femt9s00.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 } : {}
       });
@@ -19939,18 +20005,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}
 `);
@@ -19960,11 +20027,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();
@@ -20132,7 +20199,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;
   }
@@ -26342,25 +26409,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(":");
@@ -26573,8 +26644,6 @@ function collectModelLiterals(rootDir) {
 
 // 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"]);
@@ -27194,4 +27263,954 @@ 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/common.ts
+var import_typescript11 = __toESM(require_typescript(), 1);
+import { readdirSync as readdirSync8, readFileSync as readFileSync15 } from "node:fs";
+import { dirname as dirname10, join as join13, posix as posix2, relative as relative10 } from "node:path";
+var cache2 = new WeakMap;
+var SKIP = new Set(["node_modules", "dist", "build", "out", "vendor", "coverage", "__pycache__"]);
+var TEST_PATH4 = /(?:^|\/)(?:test|tests|__tests__|test-fixtures|fixtures?|__fixtures__|__mocks__|e2e)\/|\.(?:test|spec)\.[cm]?[jt]sx?$/i;
+var EVAL_PATH2 = /(?:^|\/)evals?\/|\.evals?\.[cm]?[jt]sx?$/i;
+function enumerationRepository(ctx) {
+  const existing = cache2.get(ctx);
+  if (existing)
+    return existing;
+  const files = [];
+  const walk = (dir) => {
+    for (const entry of readdirSync8(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+      const abs = join13(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!entry.name.startsWith(".") && !SKIP.has(entry.name))
+          walk(abs);
+      } else if (entry.isFile() && /\.(?:[cm]?[jt]sx?|py|jsonc?|toml)$/.test(entry.name) && !/\.d\.[cm]?ts$/.test(entry.name)) {
+        const path = relative10(ctx.rootDir, abs).split("\\").join("/");
+        try {
+          const text = readFileSync15(abs, "utf8");
+          if (text.length > 1024 * 1024)
+            continue;
+          const source = ctx.programFor(path)?.getSourceFile(abs) ?? import_typescript11.default.createSourceFile(abs, text, import_typescript11.default.ScriptTarget.Latest, true, path.endsWith("tsx") ? import_typescript11.default.ScriptKind.TSX : import_typescript11.default.ScriptKind.TS);
+          files.push({ path, text, source });
+        } catch {}
+      }
+    }
+  };
+  walk(ctx.rootDir);
+  const workers = [];
+  const paths = new Set(files.map((file) => file.path));
+  const closure = (main) => {
+    const found = new Set, pending = [main];
+    for (let index = 0;index < pending.length; index++) {
+      const path = pending[index];
+      if (found.has(path))
+        continue;
+      found.add(path);
+      const file = files.find((entry) => entry.path === path);
+      if (!file)
+        continue;
+      for (const ref of import_typescript11.default.preProcessFile(file.text, true, true).importedFiles) {
+        if (!ref.fileName.startsWith("."))
+          continue;
+        const base = posix2.normalize(posix2.join(posix2.dirname(path), ref.fileName)).replace(/\.[cm]?js$/, "");
+        const target = [base, ...[".ts", ".tsx", ".js", ".mjs", "/index.ts", "/index.js"].map((suffix) => base + suffix)].find((candidate) => paths.has(candidate));
+        if (target)
+          pending.push(target);
+      }
+    }
+    return found;
+  };
+  for (const file of files)
+    if (/(?:^|\/)wrangler(?:\.[\w.-]+)?\.(?:jsonc?|toml)$/.test(file.path)) {
+      try {
+        const config2 = file.path.endsWith(".toml") ? parse(file.text) : JSON.parse(stripJsonc(file.text));
+        const variants = [["default", config2], ...Object.entries(config2.env ?? {}).map(([name, section]) => [name, { ...config2, ...section, queues: section.queues, workflows: section.workflows }])];
+        for (const [environment, section] of variants) {
+          if (typeof section.main !== "string" || isTestWorkerConfig({ path: file.path, name: section.name, mains: [section.main] }))
+            continue;
+          const main = posix2.normalize(posix2.join(dirname10(file.path), section.main));
+          workers.push({ id: `${file.path}#${environment}`, main, cron: Boolean(section.triggers?.crons?.length), queueBindings: new Set((section.queues?.producers ?? []).flatMap((producer) => typeof producer.binding === "string" ? [producer.binding] : [])), workflowClasses: (section.workflows ?? []).flatMap((binding) => typeof binding.class_name === "string" && !binding.script_name ? [binding.class_name] : []), files: closure(main) });
+        }
+      } catch {}
+    }
+  const queueBindingsFor = (path) => {
+    const owners = workers.filter((worker) => worker.files.has(path));
+    return new Set(owners[0] ? [...owners[0].queueBindings].filter((binding) => owners.every((worker) => worker.queueBindings.has(binding))) : []);
+  };
+  const reach = buildImportGraphReachability(ctx.rootDir);
+  const repo = { files, workers, queueBindingsFor, cronEntrypoints: new Set(workers.filter((worker) => worker.cron).map((worker) => worker.main)), deployedFiles: reach.inProd, status: (path) => reach.inProd.has(path) || reach.reachable.has(path) ? "reachable" : "defined_only" };
+  cache2.set(ctx, repo);
+  return repo;
+}
+function lineOf5(node) {
+  return node.getSourceFile().getLineAndCharacterOfPosition(node.getStart()).line + 1;
+}
+function nameOf(node) {
+  if (!node)
+    return;
+  if (import_typescript11.default.isComputedPropertyName(node) && import_typescript11.default.isStringLiteralLike(node.expression))
+    return node.expression.text;
+  return import_typescript11.default.isIdentifier(node) || import_typescript11.default.isStringLiteralLike(node) || import_typescript11.default.isNumericLiteral(node) ? node.text : undefined;
+}
+function visit(node, fn) {
+  fn(node);
+  import_typescript11.default.forEachChild(node, (child) => visit(child, fn));
+}
+function componentId(kind, path, name) {
+  return `${kind}:${path}:${name}`;
+}
+function artifact(type, name, file, node, reason, status) {
+  return { id: componentId(type, file.path, name), type, name, scope: "shared", sourcePath: file.path, usedByAgentIds: [], confidence: 1, evidence: [{ path: file.path, line: lineOf5(node), reason }], status };
+}
+function agent(name, file, node, reason, status) {
+  return { id: componentId("agent", file.path, name), name, kind: "runtime_agent", root: ".", entrypointIds: [], channelAdapterIds: [], artifactIds: [], identityNamespaceIds: [], deploymentIds: [], frameworkIds: [], modelProviderIds: [], confidence: 1, evidence: [{ path: file.path, line: lineOf5(node), reason }], status };
+}
+function emptyResult() {
+  return { runtimeAgents: [], artifacts: [], warnings: [] };
+}
+function stableResult(result) {
+  const unique2 = (values) => [...new Map(values.map((x) => [x.id, x])).values()].sort((a, b) => a.id.localeCompare(b.id));
+  return { runtimeAgents: unique2(result.runtimeAgents), artifacts: unique2(result.artifacts), warnings: [...new Set(result.warnings)].sort() };
+}
+
+// src/harness-extract/enumerators/agents.ts
+function agentForScope(scope, enumeration) {
+  return enumeration.agentForScope(scope);
+}
+function createAgentScopeResolver(result, ctx) {
+  return enumerateAgents(result, ctx).agentForScope;
+}
+var enumerations = new WeakMap;
+var AGENT_BASES3 = new Set(["Think", "Agent", "AIChatAgent", "McpAgent"]);
+var HTTP_METHODS2 = new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"]);
+function routeOf(fn, file) {
+  const name = functionName(fn);
+  if (name && HTTP_METHODS2.has(name) && /(?:^|\/)(?:route|\+server)\.[cm]?[jt]sx?$/.test(file.path))
+    return `${name} ${file.path}`;
+  const parent = fn.parent;
+  if (parent && import_typescript12.default.isCallExpression(parent) && import_typescript12.default.isPropertyAccessExpression(parent.expression) && /^(get|post|put|patch|delete|all|on)$/.test(parent.expression.name.text)) {
+    const path = parent.arguments.find(import_typescript12.default.isStringLiteralLike);
+    if (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_typescript12.default.isClassDeclaration(node) || import_typescript12.default.isClassExpression(node)) && node.name) {
+        const name2 = node.name.text;
+        const info = checker ? frameworkBaseOf(node, checker, memo) : undefined;
+        const directBase = node.heritageClauses?.flatMap((h) => h.types).map((x) => x.expression.getText()) ?? [];
+        const protocolEvents = new Set;
+        visit(node, (member2) => {
+          if (import_typescript12.default.isStringLiteralLike(member2))
+            protocolEvents.add(member2.text);
+        });
+        const realtime = protocolEvents.has("session.update") && protocolEvents.has("response.create") && [...protocolEvents].some((event) => event.includes("function_call"));
+        const exported = import_typescript12.default.getCombinedModifierFlags(node) & import_typescript12.default.ModifierFlags.Export;
+        const abstract = import_typescript12.default.getCombinedModifierFlags(node) & import_typescript12.default.ModifierFlags.Abstract;
+        if (!abstract && (exported || bound.has(name2)) && (info?.base && AGENT_BASES3.has(info.base) || directBase.some((x) => AGENT_BASES3.has(x)) || exported && realtime)) {
+          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_typescript12.default.isMethodDeclaration(node) || import_typescript12.default.isGetAccessorDeclaration(node) || import_typescript12.default.isSetAccessorDeclaration(node) ? node : import_typescript12.default.isPropertyAssignment(node.parent) ? node.parent : undefined;
+        const object = member2 && import_typescript12.default.isObjectLiteralExpression(member2.parent) ? member2.parent : undefined;
+        if (object)
+          parts.unshift(import_typescript12.default.isVariableDeclaration(object.parent) && import_typescript12.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_typescript12.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_typescript12.default.SyntaxKind.TrueKeyword)
+      return true;
+    if (condition.kind === import_typescript12.default.SyntaxKind.FalseKeyword)
+      return false;
+    if (import_typescript12.default.isPrefixUnaryExpression(condition) && condition.operator === import_typescript12.default.SyntaxKind.ExclamationToken) {
+      const value = bindingTruth(condition.operand, worker);
+      return value === undefined ? undefined : !value;
+    }
+    if (import_typescript12.default.isPropertyAccessExpression(condition) && /^(?:this\.)?env$/.test(condition.expression.getText()) && (worker ? repo.workers.find((entry) => entry.id === worker)?.queueBindings : repo.queueBindingsFor(condition.getSourceFile().fileName.slice(ctx.rootDir.length + 1)))?.has(condition.name.text))
+      return true;
+    return;
+  };
+  const returns = (node) => Boolean(node && (import_typescript12.default.isReturnStatement(node) || import_typescript12.default.isBlock(node) && node.statements.length && import_typescript12.default.isReturnStatement(node.statements[node.statements.length - 1])));
+  const deployed = (node, worker) => {
+    for (let current = node;current.parent; current = current.parent) {
+      const parent = current.parent;
+      if (import_typescript12.default.isIfStatement(parent)) {
+        const truth = bindingTruth(parent.expression, worker);
+        if (truth !== undefined && (current === parent.thenStatement ? !truth : current === parent.elseStatement ? truth : false))
+          return false;
+      }
+      if (import_typescript12.default.isBlock(parent))
+        for (const prior of parent.statements) {
+          if (prior.getStart() >= current.getStart())
+            break;
+          if (import_typescript12.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_typescript12.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_typescript12.default.isObjectLiteralExpression(tools) && tools.properties.length === 0) && !(import_typescript12.default.isArrayLiteralExpression(tools) && tools.elements.length === 0));
+    scope.aliases.push(site.scope);
+  }
+  const targetsOf = (node, file) => {
+    const checker = ctx.checkerFor(file.path);
+    if (!checker)
+      return [];
+    const at = import_typescript12.default.isPropertyAccessExpression(node) ? node.name : node;
+    const declaration = valueDeclaration(resolvedSymbol(at, checker));
+    if (!declaration)
+      return [];
+    const direct = byNode.get(declaration) ?? scopes.get(keyOf(declaration));
+    if (direct)
+      return [direct];
+    if (import_typescript12.default.isVariableDeclaration(declaration) && declaration.initializer) {
+      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_typescript12.default.isWhileStatement(node) || import_typescript12.default.isDoStatement(node) || import_typescript12.default.isForStatement(node) || import_typescript12.default.isForOfStatement(node))
+        scope.hasLoop = true;
+      if ((import_typescript12.default.isIdentifier(node) || import_typescript12.default.isStringLiteralLike(node)) && /^(?:tool_calls|toolCalls|tool_use|tool_result|tool_results|toolResults)$/.test(node.text)) {
+        scope.hasTools = true;
+        scope.toolFeedback = true;
+      }
+      if (import_typescript12.default.isObjectLiteralExpression(node)) {
+        const fields = new Map(node.properties.filter(import_typescript12.default.isPropertyAssignment).map((p2) => [nameOf(p2.name), p2.initializer]));
+        const type = fields.get("type");
+        if (type && import_typescript12.default.isStringLiteralLike(type) && type.text === "tool" && fields.has("name"))
+          scope.forcedOutput = true;
+      }
+      if (import_typescript12.default.isCallExpression(node) || import_typescript12.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_typescript12.default.isPropertyAccessExpression(at) && at.expression.kind === import_typescript12.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_typescript12.default.isIdentifier(at) || import_typescript12.default.isPropertyAccessExpression(at))
+            connect(at);
+          import_typescript12.default.forEachChild(at, connectArgument);
+        };
+        for (const argument of node.arguments ?? [])
+          connectArgument(argument);
+        for (const argument of node.arguments ?? [])
+          if (import_typescript12.default.isObjectLiteralExpression(argument)) {
+            const fields = new Set(argument.properties.map((p2) => nameOf(p2.name)));
+            if (fields.has("model") && fields.has("messages") && fields.has("tools")) {
+              markModel(scope, node);
+              scope.hasTools = true;
+            }
+          }
+        if (/(?:^|\.)(?:stepCountIs|isStepCount)$/.test(node.expression.getText()) && node.arguments?.[0] && import_typescript12.default.isNumericLiteral(node.arguments?.[0]) && Number(node.arguments?.[0].text) > 1) {
+          scope.hasLoop = true;
+          scope.configuredSteps = true;
+        }
+      }
+      if (import_typescript12.default.isPropertyAssignment(node) && nameOf(node.name) === "maxSteps" && import_typescript12.default.isNumericLiteral(node.initializer) && Number(node.initializer.text) > 1) {
+        scope.hasLoop = true;
+        scope.configuredSteps = true;
+      }
+      import_typescript12.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 emitted = agent(cls.name, cls.file, cls.node, "Concrete agent/framework class or realtime model/tool bridge", repo.status(cls.file.path));
+    agents.set(emitted.id, emitted);
+  }
+  for (const scope of scopes.values()) {
+    let nestedInFunction = false;
+    for (let parent = scope.node.parent;parent && !import_typescript12.default.isClassLike(parent); parent = parent.parent)
+      if (isFunctionLike(parent)) {
+        nestedInFunction = true;
+        break;
+      }
+    if (scope.className && !nestedInFunction) {
+      let member2 = scope.node;
+      while (member2.parent && !import_typescript12.default.isClassLike(member2.parent))
+        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 emitted = agent(name, boundary.file, scope.node, "Function or route owns a multi-step model/tool feedback loop", repo.status(boundary.file.path));
+      agents.set(emitted.id, emitted);
+      assign(boundary.key, emitted.id);
+    }
+  }
+  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_typescript13 = __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_typescript13.default.SymbolFlags.Alias)
+        exported = checker.getAliasedSymbol(exported);
+      const declaration = exported && valueDeclaration(exported);
+      if (declaration && import_typescript13.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_typescript13.default.isClassDeclaration(node) || !node.name || import_typescript13.default.getCombinedModifierFlags(node) & import_typescript13.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_typescript13.default.getCombinedModifierFlags(member2) & import_typescript13.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_typescript13.default.isParenthesizedExpression(node) || import_typescript13.default.isAsExpression(node) || import_typescript13.default.isSatisfiesExpression(node) || import_typescript13.default.isNonNullExpression(node)) {
+        resolveWorker(node.expression);
+        return;
+      }
+      if (import_typescript13.default.isCallExpression(node) && /(?:^|\.)withSentry$/.test(node.expression.getText())) {
+        for (const argument of node.arguments)
+          resolveWorker(argument);
+        return;
+      }
+      if (import_typescript13.default.isExportAssignment(node)) {
+        resolveWorker(node.expression);
+        return;
+      }
+      if (import_typescript13.default.isVariableDeclaration(node)) {
+        resolveWorker(node.initializer);
+        return;
+      }
+      if (import_typescript13.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_typescript13.default.SymbolFlags.Alias ? checker.getAliasedSymbol(exported) : exported);
+    resolveWorker(symbol && valueDeclaration(symbol));
+    const collectImplementations = (node) => {
+      if (!import_typescript13.default.isClassLike(node) || workerClasses.has(nodeKey(node)))
+        return;
+      workerClasses.add(nodeKey(node));
+      for (const member2 of node.members) {
+        if (import_typescript13.default.getCombinedModifierFlags(member2) & import_typescript13.default.ModifierFlags.Static)
+          continue;
+        const name = nameOf(member2.name);
+        const implementation = byKey.get(nodeKey(member2)) ?? (import_typescript13.default.isPropertyDeclaration(member2) && member2.initializer ? byKey.get(nodeKey(member2.initializer)) : undefined);
+        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_typescript13.default.isIdentifier(node) && checker) {
+        resolveScheduled(valueDeclaration(resolvedSymbol(node, checker)), seen2);
+        return;
+      }
+      if (import_typescript13.default.isVariableDeclaration(node) || import_typescript13.default.isPropertyAssignment(node) || import_typescript13.default.isPropertyDeclaration(node)) {
+        resolveScheduled(node.initializer, seen2);
+        return;
+      }
+      if (import_typescript13.default.isShorthandPropertyAssignment(node)) {
+        resolveScheduled(checker && valueDeclaration(checker.getShorthandAssignmentValueSymbol(node)), seen2);
+        return;
+      }
+      if (import_typescript13.default.isParenthesizedExpression(node) || import_typescript13.default.isAsExpression(node) || import_typescript13.default.isSatisfiesExpression(node) || import_typescript13.default.isNonNullExpression(node)) {
+        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_typescript13.default.isObjectLiteralExpression(node) ? node.properties : import_typescript13.default.isClassLike(node) ? node.members : [];
+      const handlers = members.filter((member2) => nameOf(member2.name) === "scheduled" && !(import_typescript13.default.getCombinedModifierFlags(member2) & import_typescript13.default.ModifierFlags.Static));
+      for (const member2 of handlers)
+        resolveScheduled(member2);
+      if (!handlers.length && import_typescript13.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_typescript14 = __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_typescript14.default.isIdentifier(node)) {
+    const declaration = checker && valueDeclaration(resolvedSymbol(node, checker));
+    if (!declaration || !import_typescript14.default.isVariableDeclaration(declaration))
+      return [];
+    return strings(declaration.initializer, checker, seen);
+  }
+  if (import_typescript14.default.isArrayLiteralExpression(node))
+    return node.elements.flatMap((entry) => import_typescript14.default.isSpreadElement(entry) ? strings(entry.expression, checker, seen) : strings(entry, checker, seen));
+  if (import_typescript14.default.isStringLiteralLike(node))
+    return [{ name: node.text, node }];
+  if (import_typescript14.default.isNewExpression(node) && node.expression.getText() === "Set")
+    return strings(node.arguments?.[0], checker, seen);
+  return [];
+}
+function property(object, name) {
+  const entry = object.properties.find((item) => item.name && nameOf(item.name) === name);
+  return entry && import_typescript14.default.isPropertyAssignment(entry) ? entry.initializer : entry && import_typescript14.default.isShorthandPropertyAssignment(entry) ? entry.name : undefined;
+}
+function inheritedTrue(node, propertyName2, checker, seen = new Set) {
+  if (seen.has(node))
+    return false;
+  seen.add(node);
+  const own = node.members.find((member2) => nameOf(member2.name) === propertyName2);
+  if (own && import_typescript14.default.isPropertyDeclaration(own) && own.initializer)
+    return unwrap(own.initializer).kind === import_typescript14.default.SyntaxKind.TrueKeyword;
+  if (checker)
+    for (const base of node.heritageClauses?.flatMap((h) => h.types) ?? []) {
+      const declaration = valueDeclaration(resolvedSymbol(base.expression, checker));
+      if (declaration && (import_typescript14.default.isClassDeclaration(declaration) || import_typescript14.default.isClassExpression(declaration)))
+        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_typescript14.default.isIdentifier(node) || !/ALLOW|MCP_NAME/.test(node.text))
+        return;
+      const declaration = valueDeclaration(resolvedSymbol(node, checker));
+      if (!declaration || !import_typescript14.default.isVariableDeclaration(declaration) || !import_typescript14.default.isIdentifier(declaration.name))
+        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_typescript14.default.isClassDeclaration(node) || import_typescript14.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_typescript14.default.isVariableDeclaration(node) && import_typescript14.default.isIdentifier(node.name) && node.initializer)
+        declarations.set(node.name.text, node.initializer);
+    });
+    visit(file.source, (node) => {
+      if ((import_typescript14.default.isClassDeclaration(node) || import_typescript14.default.isClassExpression(node)) && node.name && agentByName.has(node.name.text)) {
+        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_typescript14.default.isPropertyAccessExpression(node) && node.name.text === "activate_skill" || import_typescript14.default.isPropertyAssignment(node) && nameOf(node.name) === "activate_skill") {
+        const owner = ownersAt(node, file.path);
+        add("activate_skill", file, node, "think", "Source explicitly exposes Think skill activation", owner);
+      }
+      if (import_typescript14.default.isCallExpression(node) && import_typescript14.default.isPropertyAccessExpression(node.expression) && /^(?:registerTool|tool)$/.test(node.expression.name.text) && checker) {
+        const receiver = valueDeclaration(resolvedSymbol(node.expression.expression, checker));
+        const init = receiver && import_typescript14.default.isVariableDeclaration(receiver) && receiver.initializer ? unwrap(receiver.initializer) : undefined;
+        const origin = init && import_typescript14.default.isNewExpression(init) && import_typescript14.default.isIdentifier(init.expression) ? importOrigin(init.expression, checker) : undefined;
+        const name = node.arguments[0];
+        if (origin?.module.startsWith("@modelcontextprotocol/sdk/") && origin.imported === "McpServer" && name && import_typescript14.default.isStringLiteralLike(name)) {
+          add(name.text, file, name, "mcp_server", "MCP SDK server explicitly registers this model-facing tool name", ownersAt(node, file.path));
+        }
+      }
+      if (import_typescript14.default.isCallExpression(node) && import_typescript14.default.isPropertyAccessExpression(node.expression) && node.expression.expression.getText() === "Output" && node.expression.name.text === "object") {
+        const owners2 = ownersAt(node, file.path).filter((id) => thinkIds.has(id));
+        if (owners2.length && checker && import_typescript14.default.isIdentifier(node.expression.expression) && ["ai", "@cloudflare/think"].includes(importOrigin(node.expression.expression, checker)?.module ?? ""))
+          add("think_final_answer", file, node, "think", "Think structured output is offered as the framework final-answer tool", owners2);
+      }
+      if (import_typescript14.default.isCallExpression(node) && import_typescript14.default.isIdentifier(node.expression) && node.expression.text === "createExecuteRuntime") {
+        const owners2 = ownersAt(node, file.path).filter((id) => thinkIds.has(id));
+        if (owners2.length && checker && importOrigin(node.expression, checker)?.module.startsWith("@cloudflare/think"))
+          add("execute", file, node, "think", "Think Code Mode runtime explicitly enabled for this agent", owners2);
+      }
+      if (!import_typescript14.default.isObjectLiteralExpression(node))
+        return;
+      const serverNames = strings(property(node, "name"), checker), allow = property(node, "allow");
+      if (serverNames.length !== 1 || !allow || !property(node, "url"))
+        return;
+      const server = serverNames[0].name;
+      const owners = ownersAt(node, file.path);
+      if (import_typescript14.default.isStringLiteralLike(unwrap(allow)) && unwrap(allow).text === "all") {
+        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) }
+];
+function enumerateHarnessComponents(result, ctx) {
+  const agents = enumerateAgents(result, ctx), workflows = enumerateWorkflows(result, ctx), catalog = enumerateToolCatalog(result, ctx);
+  return stableResult({ runtimeAgents: agents.runtimeAgents, artifacts: [...workflows.artifacts, ...catalog.artifacts], warnings: [...workflows.warnings, ...catalog.warnings] });
+}
+function mergeEnumeratedComponents(artifacts, components) {
+  const merged = new Map;
+  const definitions = new Map;
+  for (const item of [...artifacts, ...components.artifacts]) {
+    const key = item.type === "tool" ? `tool:${item.name}` : item.id;
+    if (item.type === "tool" && item.body) {
+      let variants = definitions.get(key);
+      if (!variants)
+        definitions.set(key, variants = []);
+      if (!variants.some((entry) => entry.id === item.id && entry.body === item.body))
+        variants.push({ id: item.id, sourcePath: item.sourcePath, body: item.body, evidence: [...item.evidence], usedByAgentIds: [...item.usedByAgentIds] });
+    }
+    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, EXTRACT_SCHEMA_VERSION, agentForScope, createAgentScopeResolver, enumerateAgents, enumerateWorkflows, enumerateToolCatalog, ENUMERATORS, enumerateHarnessComponents, mergeEnumeratedComponents, toolNamesOf, clearExtractCache, extractHarness, extractHarnessWithContext, serializeExtractResult, runEnumerators, assignAgentIds, runHarnessCommand, writeHarnessAnalyzeResult, emitWrittenArtifacts, analyzeHarnessPrompts, isToolGroupPlaceholder, repairExternalAnalystReport, deriveRelationshipsFromGraph, deterministicArtifacts, deterministicGraphItems, mergeDeterministicArtifacts, analystRefutations, describeCodingAgentEvent, analystEventProgress, isRetryableExternalAnalystFailure, sleep, summarizeInvalidAnalystReport, isDeterministicLocalAnalyst, resolveHarnessAnalyzeConcern, resolveExternalHarnessAnalystInvocation, detectAvailableCodingAgents, codingAgentDisplayName, runCodingAgent, readOnlyClaudeExtraArgs, resolveAnalystModel, renderExternalHarnessAnalystPrompt, CONCERN_CANDIDATE_KINDS, SEED_CANDIDATE_KIND_LABELS, renderAnalystCandidateLines, renderAnalystSeedLines, truncateText, scanHarness, summarizeHarness, buildSourceSnapshot, writeHumanProgress, describeSyncIdentity, describeSyncTenantLabel, findFresherHarnessReports, writeHarnessArtifacts, assertHarnessGraphSyncQuality, graphForSync, inventoryFiles, numericEnv, numericEnvAllowZero, computeDeterministicFloor, stableId, titleFromId, promptNameFromPath };