@moda-ai/cli 1.55.85 → 1.55.87

package/dist/{cli-7vywvw8v.js → cli-vvn3x5tj.js}

@@ -109,10 +109,10 @@ import {
 } from "./cli-0v6na3yp.js";
 
 // src/harness-extract/enumerators/agents.ts
-var import_typescript14 = __toESM(require_typescript(), 1);
+var import_typescript15 = __toESM(require_typescript(), 1);
 
 // src/harness-extract/index.ts
-var import_typescript13 = __toESM(require_typescript(), 1);
+var import_typescript14 = __toESM(require_typescript(), 1);
 import { resolve as resolve13 } from "node:path";
 
 // src/harness-extract/ast.ts
@@ -18072,6 +18072,8 @@ class PromptResolver {
   callersByName = new Map;
   aliasesByName = new Map;
   callersIndexed = false;
+  resolvedCallers = new WeakMap;
+  locallyWrittenParameters = new WeakMap;
   methodIndex;
   constructor(context, options) {
     this.context = context;
@@ -18463,8 +18465,48 @@ class PromptResolver {
         return;
       }
       const checker = this.context.checkerFor(this.relative(callee.expression.getSourceFile().fileName));
-      const receiverType = checker?.getTypeAtLocation(callee.expression);
-      const arrayReceiver = import_typescript8.default.isArrayLiteralExpression(this.objectLiteralOf(callee.expression) ?? callee.expression) || !!checker && !!receiverType && (receiverType.isUnion() ? receiverType.types : [receiverType]).every((type) => checker.isArrayType(type) || checker.isTupleType(type));
+      const arrayType = (type, awaited = false) => {
+        if (!type)
+          return false;
+        if (import_typescript8.default.isArrayTypeNode(type) || import_typescript8.default.isTupleTypeNode(type))
+          return true;
+        if (import_typescript8.default.isTypeOperatorNode(type))
+          return arrayType(type.type, awaited);
+        if (!import_typescript8.default.isTypeReferenceNode(type))
+          return false;
+        const name = type.typeName.getText();
+        return /^(?:Readonly)?Array$/.test(name) || awaited && name === "Promise" && arrayType(type.typeArguments?.[0]);
+      };
+      const arraySeen = new Set;
+      const isArrayReceiver = (expression, awaited = false) => {
+        const raw = unwrapNode(expression);
+        if (import_typescript8.default.isAwaitExpression(raw))
+          return isArrayReceiver(raw.expression, true);
+        const receiver = unwrap2(expression);
+        if (arraySeen.has(receiver))
+          return false;
+        arraySeen.add(receiver);
+        if (import_typescript8.default.isAwaitExpression(receiver))
+          return isArrayReceiver(receiver.expression, true);
+        if (import_typescript8.default.isIdentifier(receiver)) {
+          for (const declaration of this.declarationsOf(receiver)) {
+            if ((import_typescript8.default.isVariableDeclaration(declaration) || import_typescript8.default.isParameter(declaration)) && (arrayType(declaration.type) || declaration.initializer && isArrayReceiver(declaration.initializer)))
+              return true;
+          }
+        }
+        if (import_typescript8.default.isCallExpression(receiver)) {
+          for (const declaration of this.declarationsOf(import_typescript8.default.isPropertyAccessExpression(receiver.expression) ? receiver.expression.name : receiver.expression)) {
+            const fn = functionOf(declaration);
+            if (fn && arrayType(fn.type, awaited))
+              return true;
+          }
+        }
+        const type = checker?.getTypeAtLocation(receiver);
+        if (import_typescript8.default.isArrayLiteralExpression(this.objectLiteralOf(receiver) ?? receiver) || !!checker && !!type && (type.isUnion() ? type.types : [type]).every((item) => checker.isArrayType(item) || checker.isTupleType(item)))
+          return true;
+        return import_typescript8.default.isCallExpression(receiver) && import_typescript8.default.isPropertyAccessExpression(receiver.expression) && ARRAY_ASSEMBLY_METHODS.has(receiver.expression.name.text) && receiver.expression.name.text !== "join" && isArrayReceiver(receiver.expression.expression);
+      };
+      const arrayReceiver = isArrayReceiver(callee.expression);
       if ((method === "find" || method === "findLast") && arrayReceiver) {
         this.value(callee.expression, owner, { ...flag(walk, "dynamic-key"), project: [ARRAY_ELEMENT, ...walk.project] });
         return;
@@ -18570,6 +18612,10 @@ class PromptResolver {
       if (walk.seen.has(fn))
         continue;
       const name = functionName2(fn);
+      if (walk.depth + 1 > this.maxDepth) {
+        this.markUnresolved(call, "depth-limit", walk);
+        continue;
+      }
       const next = this.step(walk, fn, `builder ${name ?? "function"} called at ${this.where(call)}`);
       if (!next)
         continue;
@@ -18676,6 +18722,8 @@ class PromptResolver {
       return;
     }
     if (import_typescript8.default.isVariableDeclaration(declaration)) {
+      if (/^\d+$/.test(next.project[0] ?? "") && this.assembly(declaration, ownerFor(declaration, name, owner), next, at, true))
+        return;
       if (!owner && next.flags.includes("interpolated") && declaration.initializer) {
         let scope = declaration.parent;
         while (scope && !import_typescript8.default.isFunctionLike(scope))
@@ -18749,12 +18797,12 @@ class PromptResolver {
     if (fn)
       this.builderBody(fn, { node: declaration, name, kind: "builder" }, next);
   }
-  assembly(declaration, owner, walk, at) {
+  assembly(declaration, owner, walk, at, probe = false) {
     if (!import_typescript8.default.isIdentifier(declaration.name))
-      return;
+      return false;
     const scope = enclosingScope2(declaration);
     if (!scope)
-      return;
+      return false;
     const assignments = [];
     const findRebinding = (node) => {
       if (import_typescript8.default.isFunctionLike(node))
@@ -18800,7 +18848,7 @@ class PromptResolver {
         return new Set;
       const next = new Set(seen).add(value);
       if (import_typescript8.default.isIdentifier(value)) {
-        const entry = this.declarationsOf(value).find((item) => import_typescript8.default.isVariableDeclaration(item));
+        const entry = this.declarationsOf(value).find((item) => import_typescript8.default.isVariableDeclaration(item) || import_typescript8.default.isParameter(item));
         if (entry === declaration)
           return versionsAt(value);
         if (entry && import_typescript8.default.isVariableDeclaration(entry) && entry.initializer && entry.parent.flags & import_typescript8.default.NodeFlags.Const)
@@ -18911,15 +18959,24 @@ class PromptResolver {
       });
     };
     const isThis = (identifier) => references(identifier);
+    let indexedMutation = false;
     const visit = (node) => {
       if (import_typescript8.default.isFunctionLike(node) && !invoked(node))
         return;
       if (import_typescript8.default.isCallExpression(node) && import_typescript8.default.isPropertyAccessExpression(node.expression) && references(node.expression.expression) && /^(?:push|unshift|splice)$/.test(node.expression.name.text)) {
+        if (/^\d+$/.test(walk.project[0] ?? "")) {
+          indexedMutation = true;
+          this.markUnresolved(node, "dynamic-key", walk);
+          return;
+        }
+        if (probe)
+          return;
         const args = node.expression.name.text === "splice" ? node.arguments.slice(2) : node.arguments;
+        const elementWalk = walk.project[0] === ARRAY_ELEMENT || walk.project[0] === FLATMAP_ELEMENT ? { ...walk, project: walk.project.slice(1) } : walk;
         for (const argument of args)
-          this.value(argument, owner, walk);
+          this.value(argument, owner, elementWalk);
       }
-      if (import_typescript8.default.isBinaryExpression(node) && import_typescript8.default.isIdentifier(node.left) && (isThis(node.left) || readVersions.has(node))) {
+      if (!probe && import_typescript8.default.isBinaryExpression(node) && import_typescript8.default.isIdentifier(node.left) && (isThis(node.left) || readVersions.has(node))) {
         if (node.operatorToken.kind === import_typescript8.default.SyntaxKind.PlusEqualsToken)
           this.value(node.right, owner, walk);
         if (node.operatorToken.kind === import_typescript8.default.SyntaxKind.EqualsToken && node.right !== declaration.initializer)
@@ -18928,8 +18985,37 @@ class PromptResolver {
       import_typescript8.default.forEachChild(node, visit);
     };
     visit(scope);
+    return indexedMutation;
+  }
+  parameterHasLocalWrites(parameter) {
+    const cached = this.locallyWrittenParameters.get(parameter);
+    if (cached !== undefined)
+      return cached;
+    let written = false;
+    const name = import_typescript8.default.isIdentifier(parameter.name) ? parameter.name.text : undefined;
+    const scope = enclosingScope2(parameter);
+    const isParameter = (expression) => import_typescript8.default.isIdentifier(expression) && expression.text === name && this.declarationsOf(expression).includes(parameter);
+    const visit = (node) => {
+      if (written)
+        return;
+      if (import_typescript8.default.isBinaryExpression(node) && [import_typescript8.default.SyntaxKind.EqualsToken, import_typescript8.default.SyntaxKind.PlusEqualsToken].includes(node.operatorToken.kind)) {
+        written = isParameter(node.left) || import_typescript8.default.isElementAccessExpression(node.left) && isParameter(node.left.expression);
+      } else if (import_typescript8.default.isCallExpression(node) && import_typescript8.default.isPropertyAccessExpression(node.expression) && /^(?:push|unshift|splice)$/.test(node.expression.name.text)) {
+        written = isParameter(node.expression.expression);
+      }
+      if (!written)
+        import_typescript8.default.forEachChild(node, visit);
+    };
+    if (scope)
+      visit(scope);
+    this.locallyWrittenParameters.set(parameter, written);
+    return written;
   }
   parameter(declaration, at, owner, walk) {
+    if (import_typescript8.default.isParameter(declaration) && import_typescript8.default.isIdentifier(declaration.name) && !walk.seen.has(declaration) && this.parameterHasLocalWrites(declaration)) {
+      const local = { ...walk, seen: new Set(walk.seen).add(declaration) };
+      this.assembly(declaration, owner, local, at);
+    }
     const bound = walk.bindings.get(declaration);
     if (bound) {
       const project = [...bound.project ?? [], ...walk.project];
@@ -18991,6 +19077,9 @@ class PromptResolver {
     }
   }
   callersOf(fn) {
+    const cached = this.resolvedCallers.get(fn);
+    if (cached)
+      return cached;
     const name = functionName2(fn);
     if (!name)
       return [];
@@ -18998,12 +19087,14 @@ class PromptResolver {
     const names = [name, ...this.aliasesByName.get(name) ?? []];
     const candidates = names.flatMap((alias) => this.callersByName.get(alias) ?? []);
     const signatures = this.implementedSignatures(fn, name);
-    return candidates.filter((call) => {
+    const callers = candidates.filter((call) => {
       const callee = import_typescript8.default.isPropertyAccessExpression(call.expression) ? call.expression.name : call.expression;
       const checker = this.context.checkerFor(this.relative(call.getSourceFile().fileName));
       const members = checker && import_typescript8.default.isPropertyAccessExpression(call.expression) ? receiverClasses(call.expression.expression, checker).flatMap((cls) => cls.members.filter((member) => member.name?.getText() === name)) : [];
       return [...this.declarationsOf(callee), ...members].some((declaration) => functionOf(declaration) === fn || declaration === fn || signatures.has(declaration) && !!checker && contextualReceiverMatches(call, fn, checker));
     });
+    this.resolvedCallers.set(fn, callers);
+    return callers;
   }
   implementedSignatures(fn, name) {
     const checker = this.context.checkerFor(this.relative(fn.getSourceFile().fileName));
@@ -19305,6 +19396,8 @@ function contains(outer, inner) {
   return inner.getStart() >= outer.getStart() && inner.getEnd() <= outer.getEnd();
 }
 function enclosingScope2(declaration) {
+  if (import_typescript8.default.isParameter(declaration) && import_typescript8.default.isFunctionLike(declaration.parent) && "body" in declaration.parent)
+    return declaration.parent.body;
   for (let node = declaration.parent;node; node = node.parent) {
     if (import_typescript8.default.isBlock(node) || import_typescript8.default.isSourceFile(node) || import_typescript8.default.isModuleBlock(node))
       return node;
@@ -19472,7 +19565,7 @@ function unresolvedReports(resolution, sites) {
   const resolvedSites = new Set(resolution.refs.flatMap((ref) => ref.callSiteIds.map((id) => `${id}|${ref.role}`)));
   const reports = new Map;
   for (const value of resolution.unresolved) {
-    if (resolvedSites.has(`${value.callSiteId}|${value.role}`))
+    if (value.reason !== "depth-limit" && resolvedSites.has(`${value.callSiteId}|${value.role}`))
       continue;
     const site = sites.get(value.callSiteId);
     if (!site)
@@ -19823,7 +19916,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-ma33g263.js");
+        const { runGithubActionsAnalyze } = await import("./harness-github-actions-q2j5hhqb.js");
         const result = await runGithubActionsAnalyze(rootDir, {
           writeReport: (report2) => {
             const normalized = normalizeHarnessReport(report2);
@@ -19974,8 +20067,8 @@ async function runHarnessCommand(context) {
         }
         const { artifacts, unknowns, canonicalAgentIdentities } = deterministicGraphItems(rootDir, promote === "all" ? undefined : promote);
         tagComponentStatus({ runtimeAgents: [], artifacts }, rootDir);
-        const { extractHarnessWithContext: extractHarnessWithContext2 } = await import("./index-2bctz222.js");
-        const { enumerateHarnessComponents, mergeEnumeratedComponents } = await import("./index-jvs3ksx6.js");
+        const { extractHarnessWithContext: extractHarnessWithContext2 } = await import("./index-z8cpym48.js");
+        const { enumerateHarnessComponents, mergeEnumeratedComponents } = await import("./index-fg91fjtb.js");
         let components = { runtimeAgents: [], artifacts: [], warnings: [] };
         if (promote === "all" || promote === "topology" || promote === "tools") {
           const { result, ctx } = extractHarnessWithContext2(rootDir);
@@ -20009,12 +20102,16 @@ async function runHarnessCommand(context) {
     }
     case "extract": {
       writeHumanProgress(context, "Harness extract: tracing model call sites (no LLM, no network)...");
-      const { extractHarnessWithContext: extractHarnessWithContext2, serializeExtractResult } = await import("./index-2bctz222.js");
-      const { enumerateHarnessComponents, mergeEnumeratedComponents } = await import("./index-jvs3ksx6.js");
+      const { extractHarnessWithContext: extractHarnessWithContext2, serializeExtractResult } = await import("./index-z8cpym48.js");
+      const { enumerateHarnessComponents, mergeEnumeratedComponents } = await import("./index-fg91fjtb.js");
       const { result, ctx } = extractHarnessWithContext2(rootDir, { fresh: true });
-      const artifacts = deterministicArtifacts(rootDir);
+      const items = deterministicGraphItems(rootDir);
+      const artifacts = items.artifacts;
       tagComponentStatus({ runtimeAgents: [], artifacts }, rootDir);
-      const graph = mergeEnumeratedComponents(artifacts, enumerateHarnessComponents(result, ctx));
+      const graph = {
+        ...mergeEnumeratedComponents(artifacts, enumerateHarnessComponents(result, ctx)),
+        unknowns: items.unknowns.filter((item) => item.id.startsWith("unresolved_prompt_depth_"))
+      };
       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), graph }, {
         status: result.warnings.length > 0 ? "degraded" : "success",
@@ -20913,8 +21010,8 @@ var CONCERN_PROMOTED_ARTIFACT_TYPES = {
   evals: new Set(["model_config", "eval"])
 };
 async function deterministicFloorGraph(rootDir, options = {}) {
-  const { extractHarnessWithContext: extractHarnessWithContext2 } = await import("./index-2bctz222.js");
-  const { enumerateHarnessComponents, mergeEnumeratedComponents } = await import("./index-jvs3ksx6.js");
+  const { extractHarnessWithContext: extractHarnessWithContext2 } = await import("./index-z8cpym48.js");
+  const { enumerateHarnessComponents, mergeEnumeratedComponents } = await import("./index-fg91fjtb.js");
   const { result, ctx } = extractHarnessWithContext2(rootDir);
   const items = deterministicGraphItems(rootDir);
   const components = mergeEnumeratedComponents(items.artifacts, enumerateHarnessComponents(result, ctx));
@@ -21062,7 +21159,7 @@ function mergeDeterministicArtifacts(graph, rootDir, options = {}) {
   try {
     promoted = promoteHarnessCandidates(detectHarnessCandidates(rootDir), rootDir, { fullEvidence: true });
     if (!allowedTypes || allowedTypes.has("prompt"))
-      promoted = withCallSitePrompts(rootDir, promoted);
+      promoted = withCallSitePrompts(rootDir, promoted, graph.unknowns ??= []);
   } catch {
     promoted = [];
   }
@@ -21203,14 +21300,32 @@ function remapCanonicalArtifactAgents(graph, artifacts = graph.artifacts, dropUn
     });
   }
 }
-function withCallSitePrompts(rootDir, promoted) {
+function withCallSitePrompts(rootDir, promoted, unknowns = []) {
   if (process.env.MODA_HARNESS_CALLSITE_PROMPTS === "0")
     return promoted;
   try {
     const { result, ctx } = extractHarnessWithContext(rootDir);
     const sites = result.callSites.filter((site) => !site.isTest);
     const toolDefinitions = result.toolDefinitions ?? [];
-    return promptArtifactsFromCallSites(sites, ctx, promoted, { toolDefinitions, agentForScope: createAgentScopeResolver(result, ctx) }).artifacts;
+    const assembled = promptArtifactsFromCallSites(sites, ctx, promoted, { toolDefinitions, agentForScope: createAgentScopeResolver(result, ctx) });
+    for (const report of assembled.unresolved) {
+      const limited = report.values.filter((value) => value.reason === "depth-limit");
+      if (!limited.length)
+        continue;
+      const id = stableId("unresolved_prompt_depth", `${report.callSiteId}:${report.role}`);
+      if (unknowns.some((unknown) => unknown.id === id))
+        continue;
+      unknowns.push({
+        id,
+        question: `trace depth limit: ${report.role} prompt at ${report.path}:${report.line} has unresolved source paths.`,
+        candidateIds: [],
+        evidence: [
+          { path: report.path, line: report.line, reason: "trace depth limit at model call site" },
+          ...limited.map((value) => ({ path: value.path, line: value.line, reason: `trace depth limit: ${value.expression}` }))
+        ]
+      });
+    }
+    return assembled.artifacts;
   } catch {
     return promoted;
   }
@@ -28882,6 +28997,126 @@ function toolArtifacts(tools, runtimeAgents = []) {
   });
 }
 
+// src/harness-extract/handoffs.ts
+var import_typescript13 = __toESM(require_typescript(), 1);
+var MAX_OWNER_HOPS = 6;
+var MAX_CALLERS_PER_HOP = 25;
+function collectHandoffs(inputs) {
+  const { rootDir } = inputs;
+  const handoffs = [];
+  const classes = [];
+  const ref = (cls) => {
+    const name = className(cls);
+    return name ? { name, path: relPath(rootDir, cls.getSourceFile().fileName), line: lineOf(cls) } : undefined;
+  };
+  const repoClass = (found) => {
+    const init = found && import_typescript13.default.isVariableDeclaration(found) && found.initializer ? unwrap(found.initializer) : undefined;
+    const decl = init && import_typescript13.default.isClassExpression(init) ? init : found;
+    if (!decl || !(import_typescript13.default.isClassDeclaration(decl) || import_typescript13.default.isClassExpression(decl)))
+      return;
+    const file = decl.getSourceFile();
+    return file.isDeclarationFile || /[\\/]node_modules[\\/]/.test(file.fileName) ? undefined : decl;
+  };
+  const targetsOf = (expression, checker, depth = 0) => {
+    if (depth > 4)
+      return [];
+    const node = unwrap(expression);
+    if (import_typescript13.default.isPropertyAccessExpression(node) || import_typescript13.default.isElementAccessExpression(node)) {
+      const object = objectOf(node.expression, checker);
+      if (object) {
+        const key = import_typescript13.default.isPropertyAccessExpression(node) ? node.name.text : import_typescript13.default.isStringLiteralLike(unwrap(node.argumentExpression)) ? unwrap(node.argumentExpression).text : undefined;
+        const members = object.properties.filter((p2) => import_typescript13.default.isPropertyAssignment(p2) || import_typescript13.default.isShorthandPropertyAssignment(p2));
+        const picked = key !== undefined ? members.filter((p2) => propertyNameText(p2.name) === key) : [];
+        return (picked.length > 0 ? picked : members).flatMap((p2) => import_typescript13.default.isPropertyAssignment(p2) ? targetsOf(p2.initializer, checker, depth + 1) : targetsOf(p2.name, checker, depth + 1));
+      }
+    }
+    const cls = repoClass(valueDeclaration(resolvedSymbol(node, checker)));
+    return cls ? [cls] : [];
+  };
+  const ownersOf = (call) => {
+    const own = enclosingClass(call);
+    const owned = own && ref(own);
+    if (owned)
+      return [{ ...owned, via: "own code" }];
+    const out = [];
+    const seen = new Set;
+    const withOuter = (node) => {
+      const out2 = [];
+      for (let f = inputs.namedEnclosingFunction(node);f; f = inputs.namedEnclosingFunction(f.fn))
+        out2.push(f);
+      return out2;
+    };
+    let frontier = withOuter(call);
+    for (let hop = 0;hop < MAX_OWNER_HOPS && frontier.length > 0; hop += 1) {
+      const next = [];
+      for (const fn of frontier) {
+        if (seen.has(fn.fn))
+          continue;
+        seen.add(fn.fn);
+        for (const caller of inputs.calls.callersOf(fn.fn, fn.name, MAX_CALLERS_PER_HOP)) {
+          const cls = enclosingClass(caller);
+          const owner = cls && ref(cls);
+          if (owner) {
+            const via = `${relPath(rootDir, caller.getSourceFile().fileName)}:${lineOf(caller)}`;
+            if (!out.some((o) => o.name === owner.name && o.path === owner.path))
+              out.push({ ...owner, via });
+          } else {
+            next.push(...withOuter(caller));
+          }
+        }
+      }
+      frontier = next;
+    }
+    return out;
+  };
+  for (const { source, checker } of inputs.files) {
+    const visit2 = (node) => {
+      if ((import_typescript13.default.isClassDeclaration(node) || import_typescript13.default.isClassExpression(node)) && node.heritageClauses) {
+        const extended = node.heritageClauses.find((clause) => clause.token === import_typescript13.default.SyntaxKind.ExtendsKeyword)?.types[0];
+        const named = ref(node);
+        if (extended && named)
+          classes.push({ ...named, base: extended.expression.getText(source) });
+      }
+      if (import_typescript13.default.isCallExpression(node) && node.arguments.length > 0) {
+        const targets = targetsOf(node.arguments[0], checker).map(ref).filter((r) => Boolean(r));
+        if (targets.length > 0) {
+          const cls = enclosingClass(node);
+          const fn = inputs.namedEnclosingFunction(node);
+          handoffs.push({
+            path: relPath(rootDir, source.fileName),
+            line: lineOf(node),
+            col: colOf(node),
+            callee: node.expression.getText(source).replace(/\s+/g, ""),
+            targets: dedupe(targets),
+            ...cls && className(cls) ? { enclosingClass: className(cls) } : {},
+            ...fn ? { enclosingFunction: fn.name } : {},
+            scope: inputs.scopeOf(node),
+            owners: ownersOf(node)
+          });
+        }
+      }
+      import_typescript13.default.forEachChild(node, visit2);
+    };
+    visit2(source);
+  }
+  return { handoffs, classes };
+}
+function objectOf(expression, checker) {
+  const node = unwrap(expression);
+  if (import_typescript13.default.isObjectLiteralExpression(node))
+    return node;
+  const decl = valueDeclaration(resolvedSymbol(node, checker));
+  if (decl && import_typescript13.default.isVariableDeclaration(decl) && decl.initializer) {
+    const init = unwrap(decl.initializer);
+    return import_typescript13.default.isObjectLiteralExpression(init) ? init : undefined;
+  }
+  return;
+}
+function dedupe(refs) {
+  const seen = new Set;
+  return refs.filter((r) => !seen.has(`${r.path}:${r.name}`) && seen.add(`${r.path}:${r.name}`));
+}
+
 // src/harness-extract/types.ts
 var EXTRACT_SCHEMA_VERSION = 1;
 
@@ -28934,7 +29169,7 @@ function functionScope(rootDir, fn, name) {
   const parts = [qualifiedName(fn, name)];
   const object = objectLiteralOf2(fn);
   if (object) {
-    const holder = object.parent && import_typescript13.default.isVariableDeclaration(object.parent) && import_typescript13.default.isIdentifier(object.parent.name) ? object.parent.name.text : `L${lineOf(object)}`;
+    const holder = object.parent && import_typescript14.default.isVariableDeclaration(object.parent) && import_typescript14.default.isIdentifier(object.parent.name) ? object.parent.name.text : `L${lineOf(object)}`;
     parts.unshift(holder);
   }
   for (let outer = namedEnclosingFunction(object ?? fn);outer; outer = namedEnclosingFunction(outer.fn))
@@ -28942,8 +29177,8 @@ function functionScope(rootDir, fn, name) {
   return `${relPath(rootDir, fn.getSourceFile().fileName)}#${parts.join(".")}`;
 }
 function objectLiteralOf2(fn) {
-  const member2 = import_typescript13.default.isMethodDeclaration(fn) || import_typescript13.default.isGetAccessorDeclaration(fn) || import_typescript13.default.isSetAccessorDeclaration(fn) ? fn : import_typescript13.default.isPropertyAssignment(fn.parent) ? fn.parent : undefined;
-  return member2 && import_typescript13.default.isObjectLiteralExpression(member2.parent) ? member2.parent : undefined;
+  const member2 = import_typescript14.default.isMethodDeclaration(fn) || import_typescript14.default.isGetAccessorDeclaration(fn) || import_typescript14.default.isSetAccessorDeclaration(fn) ? fn : import_typescript14.default.isPropertyAssignment(fn.parent) ? fn.parent : undefined;
+  return member2 && import_typescript14.default.isObjectLiteralExpression(member2.parent) ? member2.parent : undefined;
 }
 function scopeOf(rootDir, node) {
   const named = namedEnclosingFunction(node);
@@ -28982,12 +29217,12 @@ function findAgentClasses(program, checker, memo) {
     if (source.isDeclarationFile || /[\\/]node_modules[\\/]/.test(source.fileName))
       continue;
     const visit2 = (node) => {
-      if ((import_typescript13.default.isClassDeclaration(node) || import_typescript13.default.isClassExpression(node)) && node.heritageClauses) {
+      if ((import_typescript14.default.isClassDeclaration(node) || import_typescript14.default.isClassExpression(node)) && node.heritageClauses) {
         const base = frameworkBaseOf(node, checker, memo).base;
         if (base && AGENT_CLASS_BASES.has(base))
           out.push(node);
       }
-      import_typescript13.default.forEachChild(node, visit2);
+      import_typescript14.default.forEachChild(node, visit2);
     };
     visit2(source);
   }
@@ -29031,35 +29266,35 @@ function siteFields(sources, rootDir) {
   return out;
 }
 function paramFlow(node, fn, checker, hops = 0) {
-  if (!import_typescript13.default.isExpression(node) || hops > 2)
+  if (!import_typescript14.default.isExpression(node) || hops > 2)
     return;
   const expr = unwrap(node);
-  if (import_typescript13.default.isBinaryExpression(expr) && (expr.operatorToken.kind === import_typescript13.default.SyntaxKind.QuestionQuestionToken || expr.operatorToken.kind === import_typescript13.default.SyntaxKind.BarBarToken)) {
+  if (import_typescript14.default.isBinaryExpression(expr) && (expr.operatorToken.kind === import_typescript14.default.SyntaxKind.QuestionQuestionToken || expr.operatorToken.kind === import_typescript14.default.SyntaxKind.BarBarToken)) {
     return paramFlow(expr.left, fn, checker, hops);
   }
-  if (import_typescript13.default.isPropertyAccessExpression(expr) && import_typescript13.default.isIdentifier(unwrap(expr.expression))) {
+  if (import_typescript14.default.isPropertyAccessExpression(expr) && import_typescript14.default.isIdentifier(unwrap(expr.expression))) {
     const inner = paramFlow(expr.expression, fn, checker, hops);
     return inner && inner.key === undefined ? { param: inner.param, key: expr.name.text } : undefined;
   }
-  if (!import_typescript13.default.isIdentifier(expr))
+  if (!import_typescript14.default.isIdentifier(expr))
     return;
   const declaration = valueDeclaration(resolvedSymbol(expr, checker));
   if (!declaration)
     return;
-  if (import_typescript13.default.isParameter(declaration) && declaration.parent === fn && !declaration.dotDotDotToken)
+  if (import_typescript14.default.isParameter(declaration) && declaration.parent === fn && !declaration.dotDotDotToken)
     return { param: declaration };
-  if (import_typescript13.default.isBindingElement(declaration) && import_typescript13.default.isObjectBindingPattern(declaration.parent) && import_typescript13.default.isParameter(declaration.parent.parent) && declaration.parent.parent.parent === fn && !declaration.dotDotDotToken) {
+  if (import_typescript14.default.isBindingElement(declaration) && import_typescript14.default.isObjectBindingPattern(declaration.parent) && import_typescript14.default.isParameter(declaration.parent.parent) && declaration.parent.parent.parent === fn && !declaration.dotDotDotToken) {
     const key = propertyNameText(declaration.propertyName ?? declaration.name);
     return key ? { param: declaration.parent.parent, key } : undefined;
   }
-  if (import_typescript13.default.isVariableDeclaration(declaration) && declaration.initializer && enclosingFunction(declaration) === fn && declaration.parent.flags & import_typescript13.default.NodeFlags.Const) {
+  if (import_typescript14.default.isVariableDeclaration(declaration) && declaration.initializer && enclosingFunction(declaration) === fn && declaration.parent.flags & import_typescript14.default.NodeFlags.Const) {
     return paramFlow(declaration.initializer, fn, checker, hops + 1);
   }
   return;
 }
 function roleParamFlow(arg, fn, checker) {
   const object = unwrap(arg.node);
-  if (arg.key !== undefined && !arg.key.includes(".") && import_typescript13.default.isObjectLiteralExpression(object)) {
+  if (arg.key !== undefined && !arg.key.includes(".") && import_typescript14.default.isObjectLiteralExpression(object)) {
     const value = propertyValue(object, arg.key);
     const flow = value ? paramFlow(value, fn, checker) : undefined;
     return flow ? { ...flow, viaProperty: true } : undefined;
@@ -29071,9 +29306,9 @@ function descendArg(argument, path) {
   let index = 0;
   for (;index < path.length; index += 1) {
     let value = unwrap(node);
-    if (import_typescript13.default.isCallExpression(value) && value.expression.getText() === "JSON.stringify" && value.arguments[0])
+    if (import_typescript14.default.isCallExpression(value) && value.expression.getText() === "JSON.stringify" && value.arguments[0])
       value = unwrap(value.arguments[0]);
-    const next = import_typescript13.default.isObjectLiteralExpression(value) ? propertyValue(value, path[index]) : undefined;
+    const next = import_typescript14.default.isObjectLiteralExpression(value) ? propertyValue(value, path[index]) : undefined;
     if (!next)
       break;
     node = next;
@@ -29151,7 +29386,7 @@ function runExtract(rootDir, options) {
           sites.push({ site, entry, anchor, sources, level: 0 });
         };
         const visit2 = (node) => {
-          if (import_typescript13.default.isCallExpression(node) || import_typescript13.default.isNewExpression(node)) {
+          if (import_typescript14.default.isCallExpression(node) || import_typescript14.default.isNewExpression(node)) {
             for (const recognizer of CALL_SINKS) {
               let match;
               const begin = performance.now();
@@ -29166,7 +29401,7 @@ function runExtract(rootDir, options) {
                 break;
               }
             }
-          } else if (import_typescript13.default.isClassDeclaration(node) || import_typescript13.default.isClassExpression(node)) {
+          } else if (import_typescript14.default.isClassDeclaration(node) || import_typescript14.default.isClassExpression(node)) {
             for (const recognizer of classRecognizers) {
               try {
                 for (const match of recognizer.match(node, ctx2))
@@ -29176,7 +29411,7 @@ function runExtract(rootDir, options) {
               }
             }
           }
-          import_typescript13.default.forEachChild(node, visit2);
+          import_typescript14.default.forEachChild(node, visit2);
         };
         visit2(source);
       }
@@ -29228,7 +29463,7 @@ function runExtract(rootDir, options) {
           const sources = [];
           for (const { source: role, flow } of flowing) {
             const argument = call.arguments[named.fn.parameters.indexOf(flow.param)];
-            if (!argument || import_typescript13.default.isSpreadElement(argument))
+            if (!argument || import_typescript14.default.isSpreadElement(argument))
               continue;
             const arg = descendArg(argument, [flow.key, flow.viaProperty ? undefined : role.arg.key].filter((part) => Boolean(part)));
             sources.push({ ...role, bindings: extendBindings(role.bindings, callerBindings), arg });
@@ -29367,6 +29602,19 @@ function runExtract(rootDir, options) {
     timings.tools = Date.now() - begin;
     result.durationMs = Date.now() - started;
   }
+  if (options.handoffs ?? true) {
+    const begin = Date.now();
+    try {
+      const files2 = [...repo?.owner.entries() ?? []].filter(([file]) => !isTestPath(relPath(rootDir, file))).map(([file, entry]) => ({ source: entry.program.getSourceFile(file), checker: entry.checker() })).filter((f) => Boolean(f.source));
+      const found = collectHandoffs({ rootDir, files: files2, calls, scopeOf: (node) => scopeOf(rootDir, node), namedEnclosingFunction });
+      result.handoffs = found.handoffs;
+      result.classes = found.classes;
+    } catch (error) {
+      warnings.push(`handoffs: ${error.message}`);
+    }
+    timings.handoffs = Date.now() - begin;
+    result.durationMs = Date.now() - started;
+  }
   return { result, ctx };
 }
 function nodeSpanning(source, start, end) {
@@ -29380,7 +29628,7 @@ function nodeSpanning(source, start, end) {
       return;
     }
     best = node;
-    import_typescript13.default.forEachChild(node, visit2);
+    import_typescript14.default.forEachChild(node, visit2);
   };
   visit2(source);
   return best;
@@ -29441,8 +29689,8 @@ function routeOf(fn, file) {
   if (name && HTTP_METHODS2.has(name) && /(?:^|\/)(?:route|\+server)\.[cm]?[jt]sx?$/.test(file.path))
     return `${name} ${file.path}`;
   const parent = fn.parent;
-  if (parent && import_typescript14.default.isCallExpression(parent) && import_typescript14.default.isPropertyAccessExpression(parent.expression) && /^(get|post|put|patch|delete|all|on)$/.test(parent.expression.name.text)) {
-    const path = parent.arguments.find(import_typescript14.default.isStringLiteralLike);
+  if (parent && import_typescript15.default.isCallExpression(parent) && import_typescript15.default.isPropertyAccessExpression(parent.expression) && /^(get|post|put|patch|delete|all|on)$/.test(parent.expression.name.text)) {
+    const path = parent.arguments.find(import_typescript15.default.isStringLiteralLike);
     if (path)
       return `${parent.expression.name.text.toUpperCase()} ${path.text} (${file.path})`;
   }
@@ -29464,18 +29712,18 @@ function enumerateAgents(result, ctx) {
       continue;
     const checker = ctx.checkerFor(file.path);
     visit(file.source, (node) => {
-      if ((import_typescript14.default.isClassDeclaration(node) || import_typescript14.default.isClassExpression(node)) && node.name) {
+      if ((import_typescript15.default.isClassDeclaration(node) || import_typescript15.default.isClassExpression(node)) && node.name) {
         const name2 = node.name.text;
         const info = checker ? frameworkBaseOf(node, checker, memo) : undefined;
         const directBase = node.heritageClauses?.flatMap((h) => h.types).map((x) => x.expression.getText()) ?? [];
         const protocolEvents = new Set;
         visit(node, (member2) => {
-          if (import_typescript14.default.isStringLiteralLike(member2))
+          if (import_typescript15.default.isStringLiteralLike(member2))
             protocolEvents.add(member2.text);
         });
         const realtime = protocolEvents.has("session.update") && protocolEvents.has("response.create") && [...protocolEvents].some((event) => event.includes("function_call"));
-        const exported = import_typescript14.default.getCombinedModifierFlags(node) & import_typescript14.default.ModifierFlags.Export;
-        const abstract = import_typescript14.default.getCombinedModifierFlags(node) & import_typescript14.default.ModifierFlags.Abstract;
+        const exported = import_typescript15.default.getCombinedModifierFlags(node) & import_typescript15.default.ModifierFlags.Export;
+        const abstract = import_typescript15.default.getCombinedModifierFlags(node) & import_typescript15.default.ModifierFlags.Abstract;
         if (!abstract && (exported || bound.has(name2)) && (info?.base && AGENT_BASES4.has(info.base) || directBase.some((x) => AGENT_BASES4.has(x)) || exported && realtime)) {
           classes.push({ file, node, name: name2, chain: info?.chain ?? [name2, ...directBase] });
         }
@@ -29513,10 +29761,10 @@ function enumerateAgents(result, ctx) {
       };
       if (name) {
         const parts = [qualified(node, name)];
-        const member2 = import_typescript14.default.isMethodDeclaration(node) || import_typescript14.default.isGetAccessorDeclaration(node) || import_typescript14.default.isSetAccessorDeclaration(node) ? node : import_typescript14.default.isPropertyAssignment(node.parent) ? node.parent : undefined;
-        const object = member2 && import_typescript14.default.isObjectLiteralExpression(member2.parent) ? member2.parent : undefined;
+        const member2 = import_typescript15.default.isMethodDeclaration(node) || import_typescript15.default.isGetAccessorDeclaration(node) || import_typescript15.default.isSetAccessorDeclaration(node) ? node : import_typescript15.default.isPropertyAssignment(node.parent) ? node.parent : undefined;
+        const object = member2 && import_typescript15.default.isObjectLiteralExpression(member2.parent) ? member2.parent : undefined;
         if (object)
-          parts.unshift(import_typescript14.default.isVariableDeclaration(object.parent) && import_typescript14.default.isIdentifier(object.parent.name) ? object.parent.name.text : `L${lineOf5(object)}`);
+          parts.unshift(import_typescript15.default.isVariableDeclaration(object.parent) && import_typescript15.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);
@@ -29538,7 +29786,7 @@ function enumerateAgents(result, ctx) {
     const checker = ctx.checkerFor(node.getSourceFile().fileName.slice(ctx.rootDir.length + 1));
     const bases = node.heritageClauses?.flatMap((clause) => clause.types).flatMap((base) => {
       const declaration = checker && valueDeclaration(resolvedSymbol(base.expression, checker));
-      return declaration && import_typescript14.default.isClassLike(declaration) ? classChain(declaration, seen) : [];
+      return declaration && import_typescript15.default.isClassLike(declaration) ? classChain(declaration, seen) : [];
     }) ?? [];
     return [node, ...bases];
   };
@@ -29554,32 +29802,32 @@ function enumerateAgents(result, ctx) {
     return;
   };
   const bindingTruth = (condition, worker) => {
-    if (condition.kind === import_typescript14.default.SyntaxKind.TrueKeyword)
+    if (condition.kind === import_typescript15.default.SyntaxKind.TrueKeyword)
       return true;
-    if (condition.kind === import_typescript14.default.SyntaxKind.FalseKeyword)
+    if (condition.kind === import_typescript15.default.SyntaxKind.FalseKeyword)
       return false;
-    if (import_typescript14.default.isPrefixUnaryExpression(condition) && condition.operator === import_typescript14.default.SyntaxKind.ExclamationToken) {
+    if (import_typescript15.default.isPrefixUnaryExpression(condition) && condition.operator === import_typescript15.default.SyntaxKind.ExclamationToken) {
       const value = bindingTruth(condition.operand, worker);
       return value === undefined ? undefined : !value;
     }
-    if (import_typescript14.default.isPropertyAccessExpression(condition) && /^(?:this\.)?env$/.test(condition.expression.getText()) && (worker ? repo.workers.find((entry) => entry.id === worker)?.queueBindings : repo.queueBindingsFor(condition.getSourceFile().fileName.slice(ctx.rootDir.length + 1)))?.has(condition.name.text))
+    if (import_typescript15.default.isPropertyAccessExpression(condition) && /^(?:this\.)?env$/.test(condition.expression.getText()) && (worker ? repo.workers.find((entry) => entry.id === worker)?.queueBindings : repo.queueBindingsFor(condition.getSourceFile().fileName.slice(ctx.rootDir.length + 1)))?.has(condition.name.text))
       return true;
     return;
   };
-  const returns = (node) => Boolean(node && (import_typescript14.default.isReturnStatement(node) || import_typescript14.default.isBlock(node) && node.statements.length && import_typescript14.default.isReturnStatement(node.statements[node.statements.length - 1])));
+  const returns = (node) => Boolean(node && (import_typescript15.default.isReturnStatement(node) || import_typescript15.default.isBlock(node) && node.statements.length && import_typescript15.default.isReturnStatement(node.statements[node.statements.length - 1])));
   const deployed = (node, worker) => {
     for (let current = node;current.parent; current = current.parent) {
       const parent = current.parent;
-      if (import_typescript14.default.isIfStatement(parent)) {
+      if (import_typescript15.default.isIfStatement(parent)) {
         const truth = bindingTruth(parent.expression, worker);
         if (truth !== undefined && (current === parent.thenStatement ? !truth : current === parent.elseStatement ? truth : false))
           return false;
       }
-      if (import_typescript14.default.isBlock(parent))
+      if (import_typescript15.default.isBlock(parent))
         for (const prior of parent.statements) {
           if (prior.getStart() >= current.getStart())
             break;
-          if (import_typescript14.default.isIfStatement(prior)) {
+          if (import_typescript15.default.isIfStatement(prior)) {
             const truth = bindingTruth(prior.expression, worker);
             if (truth !== undefined && returns(truth ? prior.thenStatement : prior.elseStatement))
               return false;
@@ -29605,7 +29853,7 @@ function enumerateAgents(result, ctx) {
     const descend = (node) => {
       if (node.getStart() <= offset && node.getEnd() >= offset) {
         anchor = node;
-        import_typescript14.default.forEachChild(node, descend);
+        import_typescript15.default.forEachChild(node, descend);
       }
     };
     descend(file.source);
@@ -29614,21 +29862,21 @@ function enumerateAgents(result, ctx) {
       continue;
     markModel(scope, anchor);
     const tools = site.toolsArg ? ctx.nodeAt(site.toolsArg) : undefined;
-    scope.hasTools ||= Boolean(tools && !(import_typescript14.default.isObjectLiteralExpression(tools) && tools.properties.length === 0) && !(import_typescript14.default.isArrayLiteralExpression(tools) && tools.elements.length === 0));
+    scope.hasTools ||= Boolean(tools && !(import_typescript15.default.isObjectLiteralExpression(tools) && tools.properties.length === 0) && !(import_typescript15.default.isArrayLiteralExpression(tools) && tools.elements.length === 0));
     scope.aliases.push(site.scope);
   }
   const targetsOf = (node, file) => {
     const checker = ctx.checkerFor(file.path);
     if (!checker)
       return [];
-    const at = import_typescript14.default.isPropertyAccessExpression(node) ? node.name : node;
+    const at = import_typescript15.default.isPropertyAccessExpression(node) ? node.name : node;
     const declaration = valueDeclaration(resolvedSymbol(at, checker));
     if (!declaration)
       return [];
     const direct = byNode.get(declaration) ?? scopes.get(keyOf(declaration));
     if (direct)
       return [direct];
-    if ((import_typescript14.default.isVariableDeclaration(declaration) || import_typescript14.default.isPropertyAssignment(declaration) || import_typescript14.default.isPropertyDeclaration(declaration)) && declaration.initializer) {
+    if ((import_typescript15.default.isVariableDeclaration(declaration) || import_typescript15.default.isPropertyAssignment(declaration) || import_typescript15.default.isPropertyDeclaration(declaration)) && declaration.initializer) {
       const fn = byNode.get(declaration.initializer) ?? scopes.get(keyOf(declaration.initializer));
       if (fn)
         return [fn];
@@ -29640,19 +29888,19 @@ function enumerateAgents(result, ctx) {
       if (node !== scope.node && isFunctionLike(node)) {
         return;
       }
-      if (import_typescript14.default.isWhileStatement(node) || import_typescript14.default.isDoStatement(node) || import_typescript14.default.isForStatement(node) || import_typescript14.default.isForOfStatement(node))
+      if (import_typescript15.default.isWhileStatement(node) || import_typescript15.default.isDoStatement(node) || import_typescript15.default.isForStatement(node) || import_typescript15.default.isForOfStatement(node))
         scope.hasLoop = true;
-      if ((import_typescript14.default.isIdentifier(node) || import_typescript14.default.isStringLiteralLike(node)) && /^(?:tool_calls|toolCalls|tool_use|tool_result|tool_results|toolResults)$/.test(node.text)) {
+      if ((import_typescript15.default.isIdentifier(node) || import_typescript15.default.isStringLiteralLike(node)) && /^(?:tool_calls|toolCalls|tool_use|tool_result|tool_results|toolResults)$/.test(node.text)) {
         scope.hasTools = true;
         scope.toolFeedback = true;
       }
-      if (import_typescript14.default.isObjectLiteralExpression(node)) {
-        const fields = new Map(node.properties.filter(import_typescript14.default.isPropertyAssignment).map((p2) => [nameOf(p2.name), p2.initializer]));
+      if (import_typescript15.default.isObjectLiteralExpression(node)) {
+        const fields = new Map(node.properties.filter(import_typescript15.default.isPropertyAssignment).map((p2) => [nameOf(p2.name), p2.initializer]));
         const type = fields.get("type");
-        if (type && import_typescript14.default.isStringLiteralLike(type) && type.text === "tool" && fields.has("name"))
+        if (type && import_typescript15.default.isStringLiteralLike(type) && type.text === "tool" && fields.has("name"))
           scope.forcedOutput = true;
       }
-      if (import_typescript14.default.isCallExpression(node) || import_typescript14.default.isNewExpression(node)) {
+      if (import_typescript15.default.isCallExpression(node) || import_typescript15.default.isNewExpression(node)) {
         const callee = node.expression.getText();
         if (/(?:chat\.)?completions\.create$|messages\.(?:create|stream)$|responses\.(?:create|stream)$/.test(callee))
           markModel(scope, node);
@@ -29660,7 +29908,7 @@ function enumerateAgents(result, ctx) {
           markModel(scope, node);
         const connect = (at) => {
           for (const target of byNode.has(at) ? [byNode.get(at)] : targetsOf(at, scope.file)) {
-            if (import_typescript14.default.isPropertyAccessExpression(at) && at.expression.kind === import_typescript14.default.SyntaxKind.ThisKeyword) {
+            if (import_typescript15.default.isPropertyAccessExpression(at) && at.expression.kind === import_typescript15.default.SyntaxKind.ThisKeyword) {
               virtualEdges.set(`${scope.key}|${target.key}`, at.name.text);
               scope.virtualCalls.set(target.key, at.name.text);
             }
@@ -29679,30 +29927,30 @@ function enumerateAgents(result, ctx) {
             connect(at);
             return;
           }
-          if (import_typescript14.default.isIdentifier(at) || import_typescript14.default.isPropertyAccessExpression(at))
+          if (import_typescript15.default.isIdentifier(at) || import_typescript15.default.isPropertyAccessExpression(at))
             connect(at);
-          import_typescript14.default.forEachChild(at, connectArgument);
+          import_typescript15.default.forEachChild(at, connectArgument);
         };
         for (const argument of node.arguments ?? [])
           connectArgument(argument);
         for (const argument of node.arguments ?? [])
-          if (import_typescript14.default.isObjectLiteralExpression(argument)) {
+          if (import_typescript15.default.isObjectLiteralExpression(argument)) {
             const fields = new Set(argument.properties.map((p2) => nameOf(p2.name)));
             if (fields.has("model") && fields.has("messages") && fields.has("tools")) {
               markModel(scope, node);
               scope.hasTools = true;
             }
           }
-        if (/(?:^|\.)(?:stepCountIs|isStepCount)$/.test(node.expression.getText()) && node.arguments?.[0] && import_typescript14.default.isNumericLiteral(node.arguments?.[0]) && Number(node.arguments?.[0].text) > 1) {
+        if (/(?:^|\.)(?:stepCountIs|isStepCount)$/.test(node.expression.getText()) && node.arguments?.[0] && import_typescript15.default.isNumericLiteral(node.arguments?.[0]) && Number(node.arguments?.[0].text) > 1) {
           scope.hasLoop = true;
           scope.configuredSteps = true;
         }
       }
-      if (import_typescript14.default.isPropertyAssignment(node) && nameOf(node.name) === "maxSteps" && import_typescript14.default.isNumericLiteral(node.initializer) && Number(node.initializer.text) > 1) {
+      if (import_typescript15.default.isPropertyAssignment(node) && nameOf(node.name) === "maxSteps" && import_typescript15.default.isNumericLiteral(node.initializer) && Number(node.initializer.text) > 1) {
         scope.hasLoop = true;
         scope.configuredSteps = true;
       }
-      import_typescript14.default.forEachChild(node, inspect);
+      import_typescript15.default.forEachChild(node, inspect);
     };
     inspect(scope.node);
   }
@@ -29732,14 +29980,14 @@ function enumerateAgents(result, ctx) {
   }
   for (const scope of scopes.values()) {
     let nestedInFunction = false;
-    for (let parent = scope.node.parent;parent && !import_typescript14.default.isClassLike(parent); parent = parent.parent)
+    for (let parent = scope.node.parent;parent && !import_typescript15.default.isClassLike(parent); parent = parent.parent)
       if (isFunctionLike(parent)) {
         nestedInFunction = true;
         break;
       }
     if (scope.className && !nestedInFunction) {
       let member2 = scope.node;
-      while (member2.parent && !import_typescript14.default.isClassLike(member2.parent))
+      while (member2.parent && !import_typescript15.default.isClassLike(member2.parent))
         member2 = member2.parent;
       const memberName = "name" in member2 ? nameOf(member2.name) : undefined;
       for (const cls of classes) {
@@ -29779,8 +30027,8 @@ function enumerateAgents(result, ctx) {
           const virtual = virtualEdges.get(`${scope.key}|${callee}`), concrete = classes.find((cls) => componentId("agent", cls.file.path, cls.name) === id);
           const callerClass = enclosingClass(scope.node);
           if (virtual && concrete && callerClass && concrete.nodes.some((node) => keyOf(node) === keyOf(callerClass))) {
-            const implementation = concrete.nodes.flatMap((node) => node.members.filter((member2) => nameOf(member2.name) === virtual && !(import_typescript14.default.getCombinedModifierFlags(member2) & import_typescript14.default.ModifierFlags.Static)))[0];
-            const implementationKey = implementation && (scopes.has(keyOf(implementation)) ? keyOf(implementation) : import_typescript14.default.isPropertyDeclaration(implementation) && implementation.initializer && scopes.has(keyOf(implementation.initializer)) ? keyOf(implementation.initializer) : undefined);
+            const implementation = concrete.nodes.flatMap((node) => node.members.filter((member2) => nameOf(member2.name) === virtual && !(import_typescript15.default.getCombinedModifierFlags(member2) & import_typescript15.default.ModifierFlags.Static)))[0];
+            const implementationKey = implementation && (scopes.has(keyOf(implementation)) ? keyOf(implementation) : import_typescript15.default.isPropertyDeclaration(implementation) && implementation.initializer && scopes.has(keyOf(implementation.initializer)) ? keyOf(implementation.initializer) : undefined);
             if (implementationKey)
               targetKey = implementationKey;
           }
@@ -29835,7 +30083,7 @@ function enumerateAgents(result, ctx) {
 }
 
 // src/harness-extract/enumerators/workflows.ts
-var import_typescript15 = __toESM(require_typescript(), 1);
+var import_typescript16 = __toESM(require_typescript(), 1);
 function enumerateWorkflows(result, ctx) {
   const output = emptyResult();
   const repo = enumerationRepository(ctx);
@@ -29848,10 +30096,10 @@ function enumerateWorkflows(result, ctx) {
       continue;
     for (const name of worker.workflowClasses) {
       let exported = checker.getExportsOfModule(module).find((symbol) => symbol.name === name);
-      if (exported && exported.flags & import_typescript15.default.SymbolFlags.Alias)
+      if (exported && exported.flags & import_typescript16.default.SymbolFlags.Alias)
         exported = checker.getAliasedSymbol(exported);
       const declaration = exported && valueDeclaration(exported);
-      if (declaration && import_typescript15.default.isClassDeclaration(declaration))
+      if (declaration && import_typescript16.default.isClassDeclaration(declaration))
         bindings.add(nodeKey(declaration));
     }
   }
@@ -29860,7 +30108,7 @@ function enumerateWorkflows(result, ctx) {
     if (!/\.[cm]?[jt]sx?$/.test(file.path) || TEST_PATH4.test(file.path) || EVAL_PATH2.test(file.path))
       continue;
     visit(file.source, (node) => {
-      if (!import_typescript15.default.isClassDeclaration(node) || !node.name || import_typescript15.default.getCombinedModifierFlags(node) & import_typescript15.default.ModifierFlags.Abstract)
+      if (!import_typescript16.default.isClassDeclaration(node) || !node.name || import_typescript16.default.getCombinedModifierFlags(node) & import_typescript16.default.ModifierFlags.Abstract)
         return;
       const checker = ctx.checkerFor(file.path);
       const base = checker ? frameworkBaseOf(node, checker, memo)?.base : undefined;
@@ -29885,7 +30133,7 @@ function enumerateWorkflows(result, ctx) {
       if (!cls || !workerClasses.has(nodeKey(cls)))
         return calls;
       const member2 = scope.node.parent === cls ? scope.node : scope.node.parent;
-      if (import_typescript15.default.getCombinedModifierFlags(member2) & import_typescript15.default.ModifierFlags.Static)
+      if (import_typescript16.default.getCombinedModifierFlags(member2) & import_typescript16.default.ModifierFlags.Static)
         return calls;
       return new Set([...calls].map((key) => {
         const method = scope.virtualCalls.get(key);
@@ -29899,24 +30147,24 @@ function enumerateWorkflows(result, ctx) {
       if (!node || visited.has(node))
         return;
       visited.add(node);
-      if (import_typescript15.default.isParenthesizedExpression(node) || import_typescript15.default.isAsExpression(node) || import_typescript15.default.isSatisfiesExpression(node) || import_typescript15.default.isNonNullExpression(node)) {
+      if (import_typescript16.default.isParenthesizedExpression(node) || import_typescript16.default.isAsExpression(node) || import_typescript16.default.isSatisfiesExpression(node) || import_typescript16.default.isNonNullExpression(node)) {
         resolveWorker(node.expression);
         return;
       }
-      if (import_typescript15.default.isCallExpression(node) && /(?:^|\.)withSentry$/.test(node.expression.getText())) {
+      if (import_typescript16.default.isCallExpression(node) && /(?:^|\.)withSentry$/.test(node.expression.getText())) {
         for (const argument of node.arguments)
           resolveWorker(argument);
         return;
       }
-      if (import_typescript15.default.isExportAssignment(node)) {
+      if (import_typescript16.default.isExportAssignment(node)) {
         resolveWorker(node.expression);
         return;
       }
-      if (import_typescript15.default.isVariableDeclaration(node)) {
+      if (import_typescript16.default.isVariableDeclaration(node)) {
         resolveWorker(node.initializer);
         return;
       }
-      if (import_typescript15.default.isIdentifier(node) && checker) {
+      if (import_typescript16.default.isIdentifier(node) && checker) {
         resolveWorker(valueDeclaration(resolvedSymbol(node, checker)));
         return;
       }
@@ -29924,17 +30172,17 @@ function enumerateWorkflows(result, ctx) {
     };
     const module = mainFile && checker?.getSymbolAtLocation(mainFile.source);
     const exported = module && checker?.getExportsOfModule(module).find((symbol2) => symbol2.name === "default");
-    const symbol = exported && checker && (exported.flags & import_typescript15.default.SymbolFlags.Alias ? checker.getAliasedSymbol(exported) : exported);
+    const symbol = exported && checker && (exported.flags & import_typescript16.default.SymbolFlags.Alias ? checker.getAliasedSymbol(exported) : exported);
     resolveWorker(symbol && valueDeclaration(symbol));
     const collectImplementations = (node) => {
-      if (!import_typescript15.default.isClassLike(node) || workerClasses.has(nodeKey(node)))
+      if (!import_typescript16.default.isClassLike(node) || workerClasses.has(nodeKey(node)))
         return;
       workerClasses.add(nodeKey(node));
       for (const member2 of node.members) {
-        if (import_typescript15.default.getCombinedModifierFlags(member2) & import_typescript15.default.ModifierFlags.Static)
+        if (import_typescript16.default.getCombinedModifierFlags(member2) & import_typescript16.default.ModifierFlags.Static)
           continue;
         const name = nameOf(member2.name);
-        const implementation = byKey.get(nodeKey(member2)) ?? (import_typescript15.default.isPropertyDeclaration(member2) && member2.initializer ? byKey.get(nodeKey(member2.initializer)) : undefined);
+        const implementation = byKey.get(nodeKey(member2)) ?? (import_typescript16.default.isPropertyDeclaration(member2) && member2.initializer ? byKey.get(nodeKey(member2.initializer)) : undefined);
         if (name && !implementations.has(name))
           implementations.set(name, implementation?.key ?? "(non-callable override)");
       }
@@ -29961,19 +30209,19 @@ function enumerateWorkflows(result, ctx) {
       if (!node || seen2.has(node))
         return;
       seen2.add(node);
-      if (import_typescript15.default.isIdentifier(node) && checker) {
+      if (import_typescript16.default.isIdentifier(node) && checker) {
         resolveScheduled(valueDeclaration(resolvedSymbol(node, checker)), seen2);
         return;
       }
-      if (import_typescript15.default.isVariableDeclaration(node) || import_typescript15.default.isPropertyAssignment(node) || import_typescript15.default.isPropertyDeclaration(node)) {
+      if (import_typescript16.default.isVariableDeclaration(node) || import_typescript16.default.isPropertyAssignment(node) || import_typescript16.default.isPropertyDeclaration(node)) {
         resolveScheduled(node.initializer, seen2);
         return;
       }
-      if (import_typescript15.default.isShorthandPropertyAssignment(node)) {
+      if (import_typescript16.default.isShorthandPropertyAssignment(node)) {
         resolveScheduled(checker && valueDeclaration(checker.getShorthandAssignmentValueSymbol(node)), seen2);
         return;
       }
-      if (import_typescript15.default.isParenthesizedExpression(node) || import_typescript15.default.isAsExpression(node) || import_typescript15.default.isSatisfiesExpression(node) || import_typescript15.default.isNonNullExpression(node)) {
+      if (import_typescript16.default.isParenthesizedExpression(node) || import_typescript16.default.isAsExpression(node) || import_typescript16.default.isSatisfiesExpression(node) || import_typescript16.default.isNonNullExpression(node)) {
         resolveScheduled(node.expression, seen2);
         return;
       }
@@ -29983,11 +30231,11 @@ function enumerateWorkflows(result, ctx) {
       if (seen2.has(node))
         return;
       seen2.add(node);
-      const members = import_typescript15.default.isObjectLiteralExpression(node) ? node.properties : import_typescript15.default.isClassLike(node) ? node.members : [];
-      const handlers = members.filter((member2) => nameOf(member2.name) === "scheduled" && !(import_typescript15.default.getCombinedModifierFlags(member2) & import_typescript15.default.ModifierFlags.Static));
+      const members = import_typescript16.default.isObjectLiteralExpression(node) ? node.properties : import_typescript16.default.isClassLike(node) ? node.members : [];
+      const handlers = members.filter((member2) => nameOf(member2.name) === "scheduled" && !(import_typescript16.default.getCombinedModifierFlags(member2) & import_typescript16.default.ModifierFlags.Static));
       for (const member2 of handlers)
         resolveScheduled(member2);
-      if (!handlers.length && import_typescript15.default.isClassLike(node) && checker)
+      if (!handlers.length && import_typescript16.default.isClassLike(node) && checker)
         for (const base of node.heritageClauses?.flatMap((clause) => clause.types) ?? []) {
           const declaration = valueDeclaration(resolvedSymbol(base.expression, checker));
           if (declaration)
@@ -30033,7 +30281,7 @@ function enumerateWorkflows(result, ctx) {
 }
 
 // src/harness-extract/enumerators/catalog.ts
-var import_typescript16 = __toESM(require_typescript(), 1);
+var import_typescript17 = __toESM(require_typescript(), 1);
 var THINK_WORKSPACE_TOOLS = ["read", "write", "edit", "list", "find", "grep", "delete"];
 function strings(expression, checker, seen = new Set) {
   if (!expression)
@@ -30042,35 +30290,35 @@ function strings(expression, checker, seen = new Set) {
   if (seen.has(node))
     return [];
   seen.add(node);
-  if (import_typescript16.default.isIdentifier(node)) {
+  if (import_typescript17.default.isIdentifier(node)) {
     const declaration = checker && valueDeclaration(resolvedSymbol(node, checker));
-    if (!declaration || !import_typescript16.default.isVariableDeclaration(declaration))
+    if (!declaration || !import_typescript17.default.isVariableDeclaration(declaration))
       return [];
     return strings(declaration.initializer, checker, seen);
   }
-  if (import_typescript16.default.isArrayLiteralExpression(node))
-    return node.elements.flatMap((entry) => import_typescript16.default.isSpreadElement(entry) ? strings(entry.expression, checker, seen) : strings(entry, checker, seen));
-  if (import_typescript16.default.isStringLiteralLike(node))
+  if (import_typescript17.default.isArrayLiteralExpression(node))
+    return node.elements.flatMap((entry) => import_typescript17.default.isSpreadElement(entry) ? strings(entry.expression, checker, seen) : strings(entry, checker, seen));
+  if (import_typescript17.default.isStringLiteralLike(node))
     return [{ name: node.text, node }];
-  if (import_typescript16.default.isNewExpression(node) && node.expression.getText() === "Set")
+  if (import_typescript17.default.isNewExpression(node) && node.expression.getText() === "Set")
     return strings(node.arguments?.[0], checker, seen);
   return [];
 }
 function property(object, name) {
   const entry = object.properties.find((item) => item.name && nameOf(item.name) === name);
-  return entry && import_typescript16.default.isPropertyAssignment(entry) ? entry.initializer : entry && import_typescript16.default.isShorthandPropertyAssignment(entry) ? entry.name : undefined;
+  return entry && import_typescript17.default.isPropertyAssignment(entry) ? entry.initializer : entry && import_typescript17.default.isShorthandPropertyAssignment(entry) ? entry.name : undefined;
 }
 function inheritedTrue(node, propertyName2, checker, seen = new Set) {
   if (seen.has(node))
     return false;
   seen.add(node);
   const own = node.members.find((member2) => nameOf(member2.name) === propertyName2);
-  if (own && import_typescript16.default.isPropertyDeclaration(own) && own.initializer)
-    return unwrap(own.initializer).kind === import_typescript16.default.SyntaxKind.TrueKeyword;
+  if (own && import_typescript17.default.isPropertyDeclaration(own) && own.initializer)
+    return unwrap(own.initializer).kind === import_typescript17.default.SyntaxKind.TrueKeyword;
   if (checker)
     for (const base of node.heritageClauses?.flatMap((h) => h.types) ?? []) {
       const declaration = valueDeclaration(resolvedSymbol(base.expression, checker));
-      if (declaration && (import_typescript16.default.isClassDeclaration(declaration) || import_typescript16.default.isClassExpression(declaration)))
+      if (declaration && (import_typescript17.default.isClassDeclaration(declaration) || import_typescript17.default.isClassExpression(declaration)))
         return inheritedTrue(declaration, propertyName2, checker, seen);
     }
   return false;
@@ -30079,9 +30327,9 @@ function hasSkillSources(node, checker, seen = new Set) {
   if (seen.has(node))
     return false;
   seen.add(node);
-  const member2 = node.members.find((member3) => nameOf(member3.name) === "getSkills" && !(import_typescript16.default.getCombinedModifierFlags(member3) & import_typescript16.default.ModifierFlags.Static));
+  const member2 = node.members.find((member3) => nameOf(member3.name) === "getSkills" && !(import_typescript17.default.getCombinedModifierFlags(member3) & import_typescript17.default.ModifierFlags.Static));
   if (member2) {
-    const hook = import_typescript16.default.isMethodDeclaration(member2) ? member2 : import_typescript16.default.isPropertyDeclaration(member2) && member2.initializer && (import_typescript16.default.isArrowFunction(unwrap(member2.initializer)) || import_typescript16.default.isFunctionExpression(unwrap(member2.initializer))) ? unwrap(member2.initializer) : undefined;
+    const hook = import_typescript17.default.isMethodDeclaration(member2) ? member2 : import_typescript17.default.isPropertyDeclaration(member2) && member2.initializer && (import_typescript17.default.isArrowFunction(unwrap(member2.initializer)) || import_typescript17.default.isFunctionExpression(unwrap(member2.initializer))) ? unwrap(member2.initializer) : undefined;
     if (!hook?.body)
       return false;
     const enabled = (expression, visited = new Set, depth = 0) => {
@@ -30089,32 +30337,32 @@ function hasSkillSources(node, checker, seen = new Set) {
       if (visited.has(value) || depth > 8)
         return false;
       visited.add(value);
-      if (import_typescript16.default.isConditionalExpression(value))
+      if (import_typescript17.default.isConditionalExpression(value))
         return enabled(value.whenTrue, new Set(visited), depth + 1) || enabled(value.whenFalse, new Set(visited), depth + 1);
-      if (checker && (import_typescript16.default.isIdentifier(value) || import_typescript16.default.isPropertyAccessExpression(value))) {
-        const declaration = valueDeclaration(resolvedSymbol(import_typescript16.default.isPropertyAccessExpression(value) ? value.name : value, checker));
-        if (declaration && import_typescript16.default.isVariableDeclaration(declaration) && declaration.initializer && declaration.parent.flags & import_typescript16.default.NodeFlags.Const) {
+      if (checker && (import_typescript17.default.isIdentifier(value) || import_typescript17.default.isPropertyAccessExpression(value))) {
+        const declaration = valueDeclaration(resolvedSymbol(import_typescript17.default.isPropertyAccessExpression(value) ? value.name : value, checker));
+        if (declaration && import_typescript17.default.isVariableDeclaration(declaration) && declaration.initializer && declaration.parent.flags & import_typescript17.default.NodeFlags.Const) {
           let populated = false;
           const symbol = resolvedSymbol(declaration.name, checker);
           const scan = (node2) => {
-            if (import_typescript16.default.isCallExpression(node2) && import_typescript16.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))
+            if (import_typescript17.default.isCallExpression(node2) && import_typescript17.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_typescript16.default.isBinaryExpression(node2) && node2.operatorToken.kind === import_typescript16.default.SyntaxKind.EqualsToken && import_typescript16.default.isElementAccessExpression(node2.left) && resolvedSymbol(node2.left.expression, checker) === symbol)
+            if (import_typescript17.default.isBinaryExpression(node2) && node2.operatorToken.kind === import_typescript17.default.SyntaxKind.EqualsToken && import_typescript17.default.isElementAccessExpression(node2.left) && resolvedSymbol(node2.left.expression, checker) === symbol)
               populated = true;
-            import_typescript16.default.forEachChild(node2, scan);
+            import_typescript17.default.forEachChild(node2, scan);
           };
           scan(declaration.getSourceFile());
           return populated || enabled(declaration.initializer, visited, depth + 1);
         }
       }
-      return value.kind !== import_typescript16.default.SyntaxKind.NullKeyword && value.getText() !== "undefined" && (!import_typescript16.default.isArrayLiteralExpression(value) || value.elements.length > 0);
+      return value.kind !== import_typescript17.default.SyntaxKind.NullKeyword && value.getText() !== "undefined" && (!import_typescript17.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_typescript16.default.isClassDeclaration(declaration) || import_typescript16.default.isClassExpression(declaration)) && hasSkillSources(declaration, checker, seen))
+      if (declaration && (import_typescript17.default.isClassDeclaration(declaration) || import_typescript17.default.isClassExpression(declaration)) && hasSkillSources(declaration, checker, seen))
         return true;
     }
   return false;
@@ -30129,10 +30377,10 @@ function enumerateToolCatalog(result, ctx) {
     if (!owners.length || !checker)
       continue;
     visit(scope.node, (node) => {
-      if (!import_typescript16.default.isIdentifier(node) || !/ALLOW|MCP_NAME/.test(node.text))
+      if (!import_typescript17.default.isIdentifier(node) || !/ALLOW|MCP_NAME/.test(node.text))
         return;
       const declaration = valueDeclaration(resolvedSymbol(node, checker));
-      if (!declaration || !import_typescript16.default.isVariableDeclaration(declaration) || !import_typescript16.default.isIdentifier(declaration.name))
+      if (!declaration || !import_typescript17.default.isVariableDeclaration(declaration) || !import_typescript17.default.isIdentifier(declaration.name))
         return;
       const key = `${declaration.getSourceFile().fileName}:${declaration.name.text}`;
       let existing = symbolOwners.get(key);
@@ -30153,7 +30401,7 @@ function enumerateToolCatalog(result, ctx) {
     if (!file || !checker)
       continue;
     visit(file.source, (node) => {
-      if ((import_typescript16.default.isClassDeclaration(node) || import_typescript16.default.isClassExpression(node)) && node.name?.text === runtime.name && frameworkBaseOf(node, checker, memo)?.base === "Think")
+      if ((import_typescript17.default.isClassDeclaration(node) || import_typescript17.default.isClassExpression(node)) && node.name?.text === runtime.name && frameworkBaseOf(node, checker, memo)?.base === "Think")
         thinkIds.add(runtime.id);
     });
   }
@@ -30170,11 +30418,11 @@ function enumerateToolCatalog(result, ctx) {
       continue;
     const checker = ctx.checkerFor(file.path), declarations = new Map;
     visit(file.source, (node) => {
-      if (import_typescript16.default.isVariableDeclaration(node) && import_typescript16.default.isIdentifier(node.name) && node.initializer)
+      if (import_typescript17.default.isVariableDeclaration(node) && import_typescript17.default.isIdentifier(node.name) && node.initializer)
         declarations.set(node.name.text, node.initializer);
     });
     visit(file.source, (node) => {
-      if ((import_typescript16.default.isClassDeclaration(node) || import_typescript16.default.isClassExpression(node)) && node.name && agentByName.has(node.name.text)) {
+      if ((import_typescript17.default.isClassDeclaration(node) || import_typescript17.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) {
@@ -30188,37 +30436,37 @@ function enumerateToolCatalog(result, ctx) {
             add(name, file, node, "think", "Think workspace tool inherited by this concrete agent", owners2);
         }
       }
-      if (import_typescript16.default.isPropertyAccessExpression(node) && node.name.text === "activate_skill" || import_typescript16.default.isPropertyAssignment(node) && nameOf(node.name) === "activate_skill") {
+      if (import_typescript17.default.isPropertyAccessExpression(node) && node.name.text === "activate_skill" || import_typescript17.default.isPropertyAssignment(node) && nameOf(node.name) === "activate_skill") {
         const owner = ownersAt(node, file.path);
         add("activate_skill", file, node, "think", "Source explicitly exposes Think skill activation", owner);
       }
-      if (import_typescript16.default.isCallExpression(node) && import_typescript16.default.isPropertyAccessExpression(node.expression) && /^(?:registerTool|tool)$/.test(node.expression.name.text) && checker) {
+      if (import_typescript17.default.isCallExpression(node) && import_typescript17.default.isPropertyAccessExpression(node.expression) && /^(?:registerTool|tool)$/.test(node.expression.name.text) && checker) {
         const receiver = valueDeclaration(resolvedSymbol(node.expression.expression, checker));
-        const init = receiver && import_typescript16.default.isVariableDeclaration(receiver) && receiver.initializer ? unwrap(receiver.initializer) : undefined;
-        const origin = init && import_typescript16.default.isNewExpression(init) && import_typescript16.default.isIdentifier(init.expression) ? importOrigin(init.expression, checker) : undefined;
+        const init = receiver && import_typescript17.default.isVariableDeclaration(receiver) && receiver.initializer ? unwrap(receiver.initializer) : undefined;
+        const origin = init && import_typescript17.default.isNewExpression(init) && import_typescript17.default.isIdentifier(init.expression) ? importOrigin(init.expression, checker) : undefined;
         const name = node.arguments[0];
-        if (origin?.module.startsWith("@modelcontextprotocol/sdk/") && origin.imported === "McpServer" && name && import_typescript16.default.isStringLiteralLike(name)) {
+        if (origin?.module.startsWith("@modelcontextprotocol/sdk/") && origin.imported === "McpServer" && name && import_typescript17.default.isStringLiteralLike(name)) {
           add(name.text, file, name, "mcp_server", "MCP SDK server explicitly registers this model-facing tool name", ownersAt(node, file.path));
         }
       }
-      if (import_typescript16.default.isCallExpression(node) && import_typescript16.default.isPropertyAccessExpression(node.expression) && node.expression.expression.getText() === "Output" && node.expression.name.text === "object") {
+      if (import_typescript17.default.isCallExpression(node) && import_typescript17.default.isPropertyAccessExpression(node.expression) && node.expression.expression.getText() === "Output" && node.expression.name.text === "object") {
         const owners2 = ownersAt(node, file.path).filter((id) => thinkIds.has(id));
-        if (owners2.length && checker && import_typescript16.default.isIdentifier(node.expression.expression) && ["ai", "@cloudflare/think"].includes(importOrigin(node.expression.expression, checker)?.module ?? ""))
+        if (owners2.length && checker && import_typescript17.default.isIdentifier(node.expression.expression) && ["ai", "@cloudflare/think"].includes(importOrigin(node.expression.expression, checker)?.module ?? ""))
           add("think_final_answer", file, node, "think", "Think structured output is offered as the framework final-answer tool", owners2);
       }
-      if (import_typescript16.default.isCallExpression(node) && import_typescript16.default.isIdentifier(node.expression) && node.expression.text === "createExecuteRuntime") {
+      if (import_typescript17.default.isCallExpression(node) && import_typescript17.default.isIdentifier(node.expression) && node.expression.text === "createExecuteRuntime") {
         const owners2 = ownersAt(node, file.path).filter((id) => thinkIds.has(id));
         if (owners2.length && checker && importOrigin(node.expression, checker)?.module.startsWith("@cloudflare/think"))
           add("execute", file, node, "think", "Think Code Mode runtime explicitly enabled for this agent", owners2);
       }
-      if (!import_typescript16.default.isObjectLiteralExpression(node))
+      if (!import_typescript17.default.isObjectLiteralExpression(node))
         return;
       const serverNames = strings(property(node, "name"), checker), allow = property(node, "allow");
       if (serverNames.length !== 1 || !allow || !property(node, "url"))
         return;
       const server = serverNames[0].name;
       const owners = ownersAt(node, file.path);
-      if (import_typescript16.default.isStringLiteralLike(unwrap(allow)) && unwrap(allow).text === "all") {
+      if (import_typescript17.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;