@moda-ai/cli 1.55.86 → 1.55.88

package/dist/cli.js

@@ -2975,25 +2975,25 @@ function leafManifestFields(leaf, commands) {
 import { fileURLToPath } from "url";
 import { realpathSync } from "fs";
 async function runPromptsCommand(...args) {
-  return (await import("./prompts-gsyrzgmg.js")).runPromptsCommand(...args);
+  return (await import("./prompts-ys1abkb1.js")).runPromptsCommand(...args);
 }
 async function runSkillsCommand(...args) {
   return (await import("./skills-knpeqryb.js")).runSkillsCommand(...args);
 }
 async function runHarnessCommand(...args) {
-  return (await import("./harness-tnhe63n3.js")).runHarnessCommand(...args);
+  return (await import("./harness-5v0wxmj7.js")).runHarnessCommand(...args);
 }
 async function runSyncCommand(...args) {
-  return (await import("./sync-60t12kz3.js")).runSyncCommand(...args);
+  return (await import("./sync-vp8jwq7g.js")).runSyncCommand(...args);
 }
 async function runRegistryCommand(...args) {
   return (await import("./registry-c64qr7ta.js")).runRegistryCommand(...args);
 }
 async function runDoctorCommand(...args) {
-  return (await import("./doctor-k2xv4n03.js")).runDoctorCommand(...args);
+  return (await import("./doctor-6gjvc25v.js")).runDoctorCommand(...args);
 }
 async function runStatusCommand(...args) {
-  return (await import("./doctor-k2xv4n03.js")).runStatusCommand(...args);
+  return (await import("./doctor-6gjvc25v.js")).runStatusCommand(...args);
 }
 async function runAuthCommand(...args) {
   return (await import("./profile-commands-1fdvrs5y.js")).runAuthCommand(...args);
@@ -3005,7 +3005,7 @@ async function runProfilesCommand(...args) {
   return (await import("./profile-commands-1fdvrs5y.js")).runProfilesCommand(...args);
 }
 async function runAgentCommand(...args) {
-  return (await import("./agent-515pvq3z.js")).runAgentCommand(...args);
+  return (await import("./agent-85087h8a.js")).runAgentCommand(...args);
 }
 async function runProductionCommand(...args) {
   return (await import("./production-intelligence-f9sd68te.js")).runProductionCommand(...args);
@@ -6769,7 +6769,7 @@ var commandRegistry = createCommandRegistry([
     resetApiRequestCountBeforeRun: true,
     telemetry: "result-and-error",
     handler: async (context) => {
-      const { runInit } = await import("./index-zfg5y1b9.js");
+      const { runInit } = await import("./index-rcfrwtk2.js");
       if (context.outputMode === "agent-stream") {
         context.output.writeEvent({
           event: "started",

package/dist/{doctor-k2xv4n03.js → doctor-6gjvc25v.js}

@@ -3,9 +3,9 @@ import {
   promptsDiscoveredCheck,
   runDoctorCommand,
   runStatusCommand
-} from "./cli-gevrs592.js";
+} from "./cli-4g7gn0yn.js";
 import"./cli-rrggdmf8.js";
-import"./cli-gqrt2rbm.js";
+import"./cli-fr85gngq.js";
 import"./cli-mm48br00.js";
 import"./cli-k0vxtzxb.js";
 import"./cli-22yvg5kh.js";

package/dist/{harness-tnhe63n3.js → harness-5v0wxmj7.js}

@@ -48,7 +48,7 @@ import {
   writeHarnessAnalyzeResult,
   writeHarnessArtifacts,
   writeHumanProgress
-} from "./cli-py31vwrx.js";
+} from "./cli-m5epf2gm.js";
 import"./cli-k0vxtzxb.js";
 import"./cli-97fnztpy.js";
 import {

package/dist/{harness-github-actions-x2jgh0e8.js → harness-github-actions-gkhfqybk.js}

@@ -1,6 +1,6 @@
 import {
   buildSourceSnapshot
-} from "./cli-py31vwrx.js";
+} from "./cli-m5epf2gm.js";
 import"./cli-k0vxtzxb.js";
 import"./cli-97fnztpy.js";
 import"./cli-y333w08f.js";

package/dist/index-c12v9gjq.js

@@ -0,0 +1,554 @@
+import {
+  EVAL_PATH,
+  TEST_PATH,
+  artifact,
+  componentId,
+  createAgentScopeResolver,
+  createFrameworkMemo,
+  emitToolsCached,
+  emptyResult,
+  enclosingClass,
+  enumerateAgents,
+  enumerationRepository,
+  frameworkBaseOf,
+  importOrigin,
+  nameOf,
+  resolvedSymbol,
+  returnExpressions,
+  stableResult,
+  surfaceOf,
+  toolArtifacts,
+  unwrap,
+  valueDeclaration,
+  visit,
+  workspacePackages
+} from "./cli-m5epf2gm.js";
+import"./cli-k0vxtzxb.js";
+import"./cli-97fnztpy.js";
+import"./cli-y333w08f.js";
+import"./cli-22yvg5kh.js";
+import"./cli-87xy1evx.js";
+import"./cli-5ms8rw8x.js";
+import"./cli-e0kbye4s.js";
+import"./cli-z1t3sf7b.js";
+import"./cli-k4tqwah4.js";
+import {
+  require_typescript
+} from "./cli-y7dtztan.js";
+import"./cli-9kfxkxmk.js";
+import"./cli-p5grm12t.js";
+import {
+  __toESM
+} from "./cli-0v6na3yp.js";
+
+// src/harness-extract/enumerators/workflows.ts
+var import_typescript = __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_typescript.default.SymbolFlags.Alias)
+        exported = checker.getAliasedSymbol(exported);
+      const declaration = exported && valueDeclaration(exported);
+      if (declaration && import_typescript.default.isClassDeclaration(declaration))
+        bindings.add(nodeKey(declaration));
+    }
+  }
+  const memo = createFrameworkMemo();
+  for (const file of repo.files) {
+    if (!/\.[cm]?[jt]sx?$/.test(file.path) || TEST_PATH.test(file.path) || EVAL_PATH.test(file.path))
+      continue;
+    visit(file.source, (node) => {
+      if (!import_typescript.default.isClassDeclaration(node) || !node.name || import_typescript.default.getCombinedModifierFlags(node) & import_typescript.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 member = scope.node.parent === cls ? scope.node : scope.node.parent;
+      if (import_typescript.default.getCombinedModifierFlags(member) & import_typescript.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_typescript.default.isParenthesizedExpression(node) || import_typescript.default.isAsExpression(node) || import_typescript.default.isSatisfiesExpression(node) || import_typescript.default.isNonNullExpression(node)) {
+        resolveWorker(node.expression);
+        return;
+      }
+      if (import_typescript.default.isCallExpression(node) && /(?:^|\.)withSentry$/.test(node.expression.getText())) {
+        for (const argument of node.arguments)
+          resolveWorker(argument);
+        return;
+      }
+      if (import_typescript.default.isExportAssignment(node)) {
+        resolveWorker(node.expression);
+        return;
+      }
+      if (import_typescript.default.isVariableDeclaration(node)) {
+        resolveWorker(node.initializer);
+        return;
+      }
+      if (import_typescript.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_typescript.default.SymbolFlags.Alias ? checker.getAliasedSymbol(exported) : exported);
+    resolveWorker(symbol && valueDeclaration(symbol));
+    const collectImplementations = (node) => {
+      if (!import_typescript.default.isClassLike(node) || workerClasses.has(nodeKey(node)))
+        return;
+      workerClasses.add(nodeKey(node));
+      for (const member of node.members) {
+        if (import_typescript.default.getCombinedModifierFlags(member) & import_typescript.default.ModifierFlags.Static)
+          continue;
+        const name = nameOf(member.name);
+        const implementation = byKey.get(nodeKey(member)) ?? (import_typescript.default.isPropertyDeclaration(member) && member.initializer ? byKey.get(nodeKey(member.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_typescript.default.isIdentifier(node) && checker) {
+        resolveScheduled(valueDeclaration(resolvedSymbol(node, checker)), seen2);
+        return;
+      }
+      if (import_typescript.default.isVariableDeclaration(node) || import_typescript.default.isPropertyAssignment(node) || import_typescript.default.isPropertyDeclaration(node)) {
+        resolveScheduled(node.initializer, seen2);
+        return;
+      }
+      if (import_typescript.default.isShorthandPropertyAssignment(node)) {
+        resolveScheduled(checker && valueDeclaration(checker.getShorthandAssignmentValueSymbol(node)), seen2);
+        return;
+      }
+      if (import_typescript.default.isParenthesizedExpression(node) || import_typescript.default.isAsExpression(node) || import_typescript.default.isSatisfiesExpression(node) || import_typescript.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_typescript.default.isObjectLiteralExpression(node) ? node.properties : import_typescript.default.isClassLike(node) ? node.members : [];
+      const handlers = members.filter((member) => nameOf(member.name) === "scheduled" && !(import_typescript.default.getCombinedModifierFlags(member) & import_typescript.default.ModifierFlags.Static));
+      for (const member of handlers)
+        resolveScheduled(member);
+      if (!handlers.length && import_typescript.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_typescript2 = __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_typescript2.default.isIdentifier(node)) {
+    const declaration = checker && valueDeclaration(resolvedSymbol(node, checker));
+    if (!declaration || !import_typescript2.default.isVariableDeclaration(declaration))
+      return [];
+    return strings(declaration.initializer, checker, seen);
+  }
+  if (import_typescript2.default.isArrayLiteralExpression(node))
+    return node.elements.flatMap((entry) => import_typescript2.default.isSpreadElement(entry) ? strings(entry.expression, checker, seen) : strings(entry, checker, seen));
+  if (import_typescript2.default.isStringLiteralLike(node))
+    return [{ name: node.text, node }];
+  if (import_typescript2.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_typescript2.default.isPropertyAssignment(entry) ? entry.initializer : entry && import_typescript2.default.isShorthandPropertyAssignment(entry) ? entry.name : undefined;
+}
+function inheritedTrue(node, propertyName, checker, seen = new Set) {
+  if (seen.has(node))
+    return false;
+  seen.add(node);
+  const own = node.members.find((member) => nameOf(member.name) === propertyName);
+  if (own && import_typescript2.default.isPropertyDeclaration(own) && own.initializer)
+    return unwrap(own.initializer).kind === import_typescript2.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_typescript2.default.isClassDeclaration(declaration) || import_typescript2.default.isClassExpression(declaration)))
+        return inheritedTrue(declaration, propertyName, checker, seen);
+    }
+  return false;
+}
+function hasSkillSources(node, checker, seen = new Set) {
+  if (seen.has(node))
+    return false;
+  seen.add(node);
+  const member = node.members.find((member2) => nameOf(member2.name) === "getSkills" && !(import_typescript2.default.getCombinedModifierFlags(member2) & import_typescript2.default.ModifierFlags.Static));
+  if (member) {
+    const hook = import_typescript2.default.isMethodDeclaration(member) ? member : import_typescript2.default.isPropertyDeclaration(member) && member.initializer && (import_typescript2.default.isArrowFunction(unwrap(member.initializer)) || import_typescript2.default.isFunctionExpression(unwrap(member.initializer))) ? unwrap(member.initializer) : undefined;
+    if (!hook?.body)
+      return false;
+    const enabled = (expression, visited = new Set, depth = 0) => {
+      const value = unwrap(expression);
+      if (visited.has(value) || depth > 8)
+        return false;
+      visited.add(value);
+      if (import_typescript2.default.isConditionalExpression(value))
+        return enabled(value.whenTrue, new Set(visited), depth + 1) || enabled(value.whenFalse, new Set(visited), depth + 1);
+      if (checker && (import_typescript2.default.isIdentifier(value) || import_typescript2.default.isPropertyAccessExpression(value))) {
+        const declaration = valueDeclaration(resolvedSymbol(import_typescript2.default.isPropertyAccessExpression(value) ? value.name : value, checker));
+        if (declaration && import_typescript2.default.isVariableDeclaration(declaration) && declaration.initializer && declaration.parent.flags & import_typescript2.default.NodeFlags.Const) {
+          let populated = false;
+          const symbol = resolvedSymbol(declaration.name, checker);
+          const scan = (node2) => {
+            if (import_typescript2.default.isCallExpression(node2) && import_typescript2.default.isPropertyAccessExpression(node2.expression) && ["push", "unshift", "splice"].includes(node2.expression.name.text) && resolvedSymbol(node2.expression.expression, checker) === symbol && node2.arguments.length > (node2.expression.name.text === "splice" ? 2 : 0))
+              populated = true;
+            if (import_typescript2.default.isBinaryExpression(node2) && node2.operatorToken.kind === import_typescript2.default.SyntaxKind.EqualsToken && import_typescript2.default.isElementAccessExpression(node2.left) && resolvedSymbol(node2.left.expression, checker) === symbol)
+              populated = true;
+            import_typescript2.default.forEachChild(node2, scan);
+          };
+          scan(declaration.getSourceFile());
+          return populated || enabled(declaration.initializer, visited, depth + 1);
+        }
+      }
+      return value.kind !== import_typescript2.default.SyntaxKind.NullKeyword && value.getText() !== "undefined" && (!import_typescript2.default.isArrayLiteralExpression(value) || value.elements.length > 0);
+    };
+    return returnExpressions(hook).some((expression) => enabled(expression));
+  }
+  if (checker)
+    for (const base of node.heritageClauses?.flatMap((h) => h.types) ?? []) {
+      const declaration = valueDeclaration(resolvedSymbol(base.expression, checker));
+      if (declaration && (import_typescript2.default.isClassDeclaration(declaration) || import_typescript2.default.isClassExpression(declaration)) && hasSkillSources(declaration, checker, seen))
+        return true;
+    }
+  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_typescript2.default.isIdentifier(node) || !/ALLOW|MCP_NAME/.test(node.text))
+        return;
+      const declaration = valueDeclaration(resolvedSymbol(node, checker));
+      if (!declaration || !import_typescript2.default.isVariableDeclaration(declaration) || !import_typescript2.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_typescript2.default.isClassDeclaration(node) || import_typescript2.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_PATH.test(file.path) || EVAL_PATH.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_typescript2.default.isVariableDeclaration(node) && import_typescript2.default.isIdentifier(node.name) && node.initializer)
+        declarations.set(node.name.text, node.initializer);
+    });
+    visit(file.source, (node) => {
+      if ((import_typescript2.default.isClassDeclaration(node) || import_typescript2.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");
+          if (hasSkillSources(node, checker))
+            names.push("read_skill_resource");
+          for (const name of names)
+            add(name, file, node, "think", "Think workspace tool inherited by this concrete agent", owners2);
+        }
+      }
+      if (import_typescript2.default.isPropertyAccessExpression(node) && node.name.text === "activate_skill" || import_typescript2.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_typescript2.default.isCallExpression(node) && import_typescript2.default.isPropertyAccessExpression(node.expression) && /^(?:registerTool|tool)$/.test(node.expression.name.text) && checker) {
+        const receiver = valueDeclaration(resolvedSymbol(node.expression.expression, checker));
+        const init = receiver && import_typescript2.default.isVariableDeclaration(receiver) && receiver.initializer ? unwrap(receiver.initializer) : undefined;
+        const origin = init && import_typescript2.default.isNewExpression(init) && import_typescript2.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_typescript2.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_typescript2.default.isCallExpression(node) && import_typescript2.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_typescript2.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_typescript2.default.isCallExpression(node) && import_typescript2.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_typescript2.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_typescript2.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;
+  const packageOf = workspacePackages(ctx.rootDir);
+  for (const item of output.artifacts) {
+    const path = item.sourcePath ?? "";
+    const surface = surfaceOf(path, packageOf(path));
+    const key = `${item.name}\x00${surface}`;
+    const previous = merged.get(key);
+    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}@${encodeURIComponent(surface)}`;
+      merged.set(key, item);
+    }
+  }
+  output.artifacts = [...merged.values()];
+  return stableResult(output);
+}
+
+// src/harness-extract/enumerators/index.ts
+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."));
+  const extractedByName = new Map;
+  for (const item of registry) {
+    let list = extractedByName.get(item.name);
+    if (!list)
+      extractedByName.set(item.name, list = []);
+    list.push(item);
+  }
+  const toolKey = (item) => {
+    if (registry.includes(item))
+      return `tool:${item.id}`;
+    const candidates = extractedByName.get(item.name) ?? [];
+    if (candidates.length === 0)
+      return item.id.startsWith("tool:catalog:") ? `tool:${item.id}` : `tool:${item.name}`;
+    const paths = new Set([item.sourcePath, ...item.evidence.map((entry) => entry.path)].filter(Boolean));
+    const target = candidates.find((candidate) => candidate.sourcePath && paths.has(candidate.sourcePath) || candidate.definitionVariants?.some((variant) => variant.sourcePath && paths.has(variant.sourcePath))) ?? candidates.find((candidate) => !candidate.id.includes("@")) ?? candidates[0];
+    return `tool:${target.id}`;
+  };
+  for (const item of [...registry, ...artifacts, ...components.artifacts.filter((item2) => !registry.includes(item2))]) {
+    const key = item.type === "tool" ? toolKey(item) : 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 {
+  mergeEnumeratedComponents,
+  enumerateWorkflows,
+  enumerateToolCatalog,
+  enumerateHarnessComponents,
+  enumerateAgents,
+  createAgentScopeResolver
+};

package/dist/{index-h9r08433.js → index-jwg6s0gb.js}

@@ -1,6 +1,5 @@
 import {
   CALL_SINKS,
-  ENUMERATORS,
   EXTRACT_SCHEMA_VERSION,
   allValues,
   assignAgentIds,
@@ -15,13 +14,12 @@ import {
   registerCallSink,
   registerClassSink,
   renderings,
-  runEnumerators,
   scopeOf,
   selectKey,
   serializeExtractResult,
   toolNamesOf,
   valueChildren
-} from "./cli-py31vwrx.js";
+} from "./cli-m5epf2gm.js";
 import"./cli-k0vxtzxb.js";
 import"./cli-97fnztpy.js";
 import"./cli-y333w08f.js";
@@ -41,7 +39,6 @@ export {
   serializeExtractResult,
   selectKey,
   scopeOf,
-  runEnumerators,
   renderings,
   registerClassSink,
   registerCallSink,
@@ -56,6 +53,5 @@ export {
   assignAgentIds,
   allValues,
   EXTRACT_SCHEMA_VERSION,
-  ENUMERATORS,
   CALL_SINKS
 };