@moda-ai/cli 1.55.80 → 1.55.82

package/dist/{cli-kq1b4vy0.js → cli-pjat0vfe.js}

@@ -348,7 +348,7 @@ function hasProperty(object, key) {
 }
 
 // src/harness-extract/calls.ts
-var import_typescript3 = __toESM(require_typescript(), 1);
+var import_typescript4 = __toESM(require_typescript(), 1);
 
 // src/harness-extract/trace.ts
 var import_typescript2 = __toESM(require_typescript(), 1);
@@ -1537,1710 +1537,1795 @@ function mayNotRun(at, declaration) {
   return false;
 }
 
-// src/harness-extract/calls.ts
-class CallIndex {
-  program;
-  checker;
-  byName;
-  aliases = new Map;
-  members = new Map;
-  checkingDefaults = new Set;
-  constructor(program, checker) {
-    this.program = program;
-    this.checker = checker;
+// src/harness-extract/sinks.ts
+var import_typescript3 = __toESM(require_typescript(), 1);
+var URL_MODEL_KEY = "?model";
+var ANTHROPIC_MODULE = /^@anthropic-ai\//;
+var OPENAI_MODULE = /^openai(?:\/|$)/;
+var OPENAI_COMPATIBLE_MODULE = /^(?:groq-sdk|together-ai|@cerebras\/cerebras_cloud_sdk|fireworks-ai|portkey-ai|@portkey-ai\/|@azure\/openai|deepseek|@helicone\/|cohere-ai)/;
+var AI_SDK_CALLS = new Set(["generateText", "streamText", "generateObject", "streamObject"]);
+var AI_SDK_DECIDE = new Set(["experimental_decide", "decide", "experimental_evaluate", "evaluate"]);
+var AI_SDK_AGENTS = new Set(["Agent", "Experimental_Agent", "ToolLoopAgent"]);
+var PROVIDER_MODULE = /^(?:@ai-sdk\/(?!react$|ui-utils$|rsc$|provider$|provider-utils$|svelte$|vue$|solid$|angular$|valibot$)[\w-]+|@openrouter\/ai-sdk-provider|workers-ai-provider|ollama-ai-provider(?:-v2)?|@requesty\/ai-sdk|@portkey-ai\/vercel-provider|@mistralai\/ai-sdk)$/;
+var MODEL_HOST = /^https?:\/\/(?:openrouter\.ai|api\.openai\.com|api\.anthropic\.com|generativelanguage\.googleapis\.com|api\.groq\.com|api\.together\.(?:xyz|ai)|api\.mistral\.ai|api\.deepseek\.com|api\.fireworks\.ai|api\.x\.ai|api\.perplexity\.ai|gateway\.ai\.cloudflare\.com)\//;
+var SPEECH_ENDPOINT = /^https?:\/\/api\.elevenlabs\.io\/v\d+\/(?:text-to-speech|speech-to-text|speech-to-speech|text-to-dialogue|sound-generation)\b/;
+var MODEL_PATH = /\/chat\/completions\b|\/v1\/messages\b|\/v1\/responses\b|:generateContent\b|:streamGenerateContent\b/;
+var FRAMEWORK_MODULE = /^(?:agents(?:\/.*)?|@cloudflare\/think|@cloudflare\/ai-chat|@cloudflare\/agents|cloudflare:workers|cloudflare:workflows)$/;
+var FRAMEWORK_BASES = new Set(["Think", "Agent", "AIChatAgent", "McpAgent", "DurableObject", "WorkflowEntrypoint", "AgentWorkflow"]);
+var HOOK_BASES = new Set(["Think", "Agent", "AIChatAgent", "McpAgent"]);
+var HOOK_METHODS = {
+  getModel: "model",
+  getTools: "tools",
+  getSystemPrompt: "system",
+  configureContext: "system",
+  getInstructions: "system",
+  instructions: "system",
+  system: "system",
+  systemPrompt: "system",
+  buildSystemPrompt: "system",
+  formatAgentToolInput: "messages"
+};
+var HOOK_PROPERTIES = { model: "model", systemPrompt: "system", instructions: "system", system: "system" };
+var TURN_HOOKS = new Set(["beforeTurn", "beforeStep", "prepareStep"]);
+var TURN_CONFIG_KEYS = { model: "model", system: "system", tools: "tools", messages: "messages" };
+function providerName(module) {
+  if (module === "ai" || module === "@ai-sdk/gateway")
+    return "ai-gateway";
+  if (module === "@openrouter/ai-sdk-provider")
+    return "openrouter";
+  if (module === "workers-ai-provider")
+    return "workers-ai";
+  if (module.startsWith("ollama-ai-provider"))
+    return "ollama";
+  const scoped = /^@[\w-]+\/(?:ai-sdk-)?([\w-]+)$/.exec(module);
+  return scoped ? scoped[1] : module;
+}
+function requestRoles(argument, keys, ctx) {
+  if (!argument)
+    return [];
+  const object = objectLiteralOf(argument, ctx.checker);
+  const roles = [];
+  if (object && unwrap(argument) === object) {
+    for (const [key, role] of Object.entries(keys)) {
+      const value = propertyValue(object, key);
+      if (value && !spreadAfter(object, key))
+        roles.push({ role, node: value });
+      else if ((value || !hasProperty(object, key)) && object.properties.some((property) => import_typescript3.default.isSpreadAssignment(property))) {
+        roles.push({ role, node: argument, key });
+      }
+    }
+    return dedupeRoles(roles);
   }
-  build() {
-    const byName = new Map;
-    for (const source of this.program.getSourceFiles()) {
-      if (source.isDeclarationFile || /[\\/]node_modules[\\/]/.test(source.fileName))
-        continue;
-      const imported = importAliases(source);
+  for (const [key, role] of Object.entries(keys)) {
+    if (!object || hasProperty(object, key) || object.properties.some((property) => import_typescript3.default.isSpreadAssignment(property))) {
+      roles.push({ role, node: argument, key });
+    }
+  }
+  return dedupeRoles(roles);
+}
+function spreadAfter(object, key) {
+  let last = -1;
+  object.properties.forEach((property, index) => {
+    if (!import_typescript3.default.isSpreadAssignment(property) && property.name && propertyNameText(property.name) === key)
+      last = index;
+  });
+  return object.properties.some((property, index) => index > last && import_typescript3.default.isSpreadAssignment(property));
+}
+function dedupeRoles(roles) {
+  const seen = new Set;
+  return roles.filter((role) => {
+    if (seen.has(role.role))
+      return false;
+    seen.add(role.role);
+    return true;
+  });
+}
+function typeOrigin(type, checker) {
+  if (!type)
+    return;
+  if (import_typescript3.default.isUnionTypeNode(type) || import_typescript3.default.isIntersectionTypeNode(type)) {
+    for (const member of type.types) {
+      const origin = typeOrigin(member, checker);
+      if (origin)
+        return origin;
+    }
+    return;
+  }
+  if (import_typescript3.default.isTypeReferenceNode(type)) {
+    let name = type.typeName;
+    while (import_typescript3.default.isQualifiedName(name))
+      name = name.left;
+    return importOrigin(name, checker);
+  }
+  return;
+}
+function valueOrigin(expression, checker, depth = 0, seen = new Set) {
+  const expr = unwrap(expression);
+  if (depth > 6 || seen.has(expr))
+    return;
+  seen.add(expr);
+  if (import_typescript3.default.isNewExpression(expr) || import_typescript3.default.isCallExpression(expr)) {
+    const root = rootIdentifier(expr.expression);
+    const origin = root ? importOrigin(root, checker) : undefined;
+    if (origin)
+      return origin;
+    const fn = resolvedFunction(expr.expression, checker);
+    if (fn) {
+      const declared = typeOrigin(fn.type, checker);
+      if (declared)
+        return declared;
+      for (const ret of returnExpressions(fn)) {
+        const found = valueOrigin(ret, checker, depth + 1, seen);
+        if (found)
+          return found;
+      }
+    }
+    return;
+  }
+  let declaration;
+  if (import_typescript3.default.isIdentifier(expr)) {
+    const origin = importOrigin(expr, checker);
+    if (origin)
+      return origin;
+    declaration = valueDeclaration(resolvedSymbol(expr, checker));
+  } else if (import_typescript3.default.isPropertyAccessExpression(expr)) {
+    declaration = valueDeclaration(resolvedSymbol(expr.name, checker));
+  }
+  if (!declaration)
+    return;
+  if (import_typescript3.default.isVariableDeclaration(declaration) || import_typescript3.default.isPropertyDeclaration(declaration) || import_typescript3.default.isParameter(declaration) || import_typescript3.default.isPropertySignature(declaration) || import_typescript3.default.isPropertyAssignment(declaration)) {
+    const declared = "type" in declaration ? typeOrigin(declaration.type, checker) : undefined;
+    if (declared)
+      return declared;
+    const initializer = "initializer" in declaration ? declaration.initializer : undefined;
+    if (initializer)
+      return valueOrigin(initializer, checker, depth + 1, seen);
+    if (import_typescript3.default.isPropertyDeclaration(declaration)) {
+      const key = propertyNameText(declaration.name);
+      let found;
       const visit = (node) => {
-        if ((import_typescript3.default.isParameter(node) || import_typescript3.default.isVariableDeclaration(node)) && node.initializer && import_typescript3.default.isIdentifier(node.name)) {
-          let init = unwrap(node.initializer);
-          if (import_typescript3.default.isBinaryExpression(init) && (init.operatorToken.kind === import_typescript3.default.SyntaxKind.QuestionQuestionToken || init.operatorToken.kind === import_typescript3.default.SyntaxKind.BarBarToken))
-            init = unwrap(init.right);
-          if (import_typescript3.default.isIdentifier(init)) {
-            const entry = { declaration: node, target: init };
-            const list = this.aliases.get(init.text);
-            if (list)
-              list.push(entry);
-            else
-              this.aliases.set(init.text, [entry]);
-          }
-        }
-        if ((import_typescript3.default.isPropertyAssignment(node) || import_typescript3.default.isShorthandPropertyAssignment(node)) && import_typescript3.default.isObjectLiteralExpression(node.parent)) {
-          const value = import_typescript3.default.isShorthandPropertyAssignment(node) ? node.name : unwrap(node.initializer);
-          const property = import_typescript3.default.isIdentifier(node.name) || import_typescript3.default.isStringLiteral(node.name) ? node.name.text : undefined;
-          if (property && import_typescript3.default.isIdentifier(value)) {
-            const entry = { property, literal: node.parent, target: value };
-            const list = this.members.get(value.text);
-            if (list)
-              list.push(entry);
-            else
-              this.members.set(value.text, [entry]);
-          }
-        }
-        if (import_typescript3.default.isCallExpression(node)) {
-          const callee = unwrap(node.expression);
-          const name = import_typescript3.default.isIdentifier(callee) ? callee.text : import_typescript3.default.isPropertyAccessExpression(callee) ? callee.name.text : undefined;
-          if (name) {
-            const original = import_typescript3.default.isIdentifier(callee) ? imported.get(name) : undefined;
-            for (const key of original && original !== name ? [name, original] : [name]) {
-              const list = byName.get(key);
-              if (list)
-                list.push(node);
-              else
-                byName.set(key, [node]);
-            }
-          }
+        if (found)
+          return;
+        if (import_typescript3.default.isBinaryExpression(node) && node.operatorToken.kind === import_typescript3.default.SyntaxKind.EqualsToken && import_typescript3.default.isPropertyAccessExpression(node.left) && node.left.expression.kind === import_typescript3.default.SyntaxKind.ThisKeyword && node.left.name.text === key) {
+          found = valueOrigin(node.right, checker, depth + 1, seen);
         }
         import_typescript3.default.forEachChild(node, visit);
       };
-      visit(source);
+      import_typescript3.default.forEachChild(declaration.parent, visit);
+      return found;
     }
-    return byName;
-  }
-  callersOf(fn, name, limit, within) {
-    const all = this.allCallersOf(fn, name, within ? Number.MAX_SAFE_INTEGER : limit);
-    if (!within)
-      return all;
-    return all.filter((call) => within.getSourceFile(call.getSourceFile().fileName) === call.getSourceFile()).slice(0, limit);
   }
-  allCallersOf(fn, name, limit) {
-    this.byName ??= this.build();
-    const out = this.direct(name, limit, (declaration) => declares(declaration, fn));
-    if (isDefaultExport(fn) && name !== "default" && out.length < limit)
-      out.push(...this.direct("default", limit - out.length, (declaration) => declares(declaration, fn), new Set(out)));
-    for (const alias of this.aliases.get(name) ?? []) {
-      if (out.length >= limit)
-        break;
-      const symbol = resolvedSymbol(alias.target, this.checker);
-      if (!symbol?.declarations?.some((declaration) => declares(declaration, fn)))
-        continue;
-      if (!this.defaultCanApply(alias.declaration))
-        continue;
-      const aliasName = alias.declaration.name.text;
-      out.push(...this.direct(aliasName, limit - out.length, (declaration) => declaration === alias.declaration));
+  return;
+}
+function providerInstance(expression, checker, depth = 0) {
+  const expr = unwrap(expression);
+  if (depth > 6)
+    return;
+  if (import_typescript3.default.isIdentifier(expr)) {
+    const origin = importOrigin(expr, checker);
+    if (origin) {
+      if (origin.module === "ai" && origin.imported === "gateway")
+        return "ai";
+      return PROVIDER_MODULE.test(origin.module) && !/^create/.test(origin.imported) && origin.imported !== "*" ? origin.module : undefined;
     }
-    for (const member of this.members.get(name) ?? []) {
-      if (out.length >= limit)
-        break;
-      const symbol = resolvedSymbol(member.target, this.checker);
-      if (!symbol?.declarations?.some((declaration) => declares(declaration, fn)))
-        continue;
-      for (const param of this.holders(member.literal)) {
-        out.push(...this.memberCalls(param, member.property, limit - out.length));
-      }
+    const declaration = valueDeclaration(resolvedSymbol(expr, checker));
+    if (declaration && (import_typescript3.default.isVariableDeclaration(declaration) || import_typescript3.default.isPropertyDeclaration(declaration)) && declaration.initializer) {
+      const initializer = declaration.initializer;
+      return memoized(declaration, () => providerInstance(initializer, checker, depth + 1));
     }
-    return out;
+    return;
   }
-  holders(literal) {
-    let node = literal;
-    while (node.parent && (import_typescript3.default.isParenthesizedExpression(node.parent) || import_typescript3.default.isAsExpression(node.parent) || import_typescript3.default.isSatisfiesExpression(node.parent)))
-      node = node.parent;
-    const parent = node.parent;
-    const out = [];
-    if (parent && import_typescript3.default.isCallExpression(parent)) {
-      const index = parent.arguments.indexOf(node);
-      const fn = index >= 0 ? resolvedFunction(parent.expression, this.checker) : undefined;
-      if (fn && fn.parameters[index])
-        out.push(fn.parameters[index]);
-    } else if (parent && import_typescript3.default.isParameter(parent) && parent.initializer === node) {
-      out.push(parent);
-    } else if (parent && import_typescript3.default.isVariableDeclaration(parent) && parent.initializer === node && import_typescript3.default.isIdentifier(parent.name)) {
-      for (const alias of this.aliases.get(parent.name.text) ?? []) {
-        if (import_typescript3.default.isParameter(alias.declaration) && valueDeclaration(resolvedSymbol(alias.target, this.checker)) === parent)
-          out.push(alias.declaration);
-      }
+  if (import_typescript3.default.isPropertyAccessExpression(expr)) {
+    const declaration = valueDeclaration(resolvedSymbol(expr.name, checker));
+    if (declaration && (import_typescript3.default.isPropertyDeclaration(declaration) || import_typescript3.default.isPropertyAssignment(declaration) || import_typescript3.default.isVariableDeclaration(declaration)) && declaration.initializer) {
+      const initializer = declaration.initializer;
+      return memoized(declaration, () => providerInstance(initializer, checker, depth + 1));
     }
-    return out;
+    return;
   }
-  memberCalls(param, property, limit) {
-    const out = [];
-    for (const call of this.byName.get(property) ?? []) {
-      if (out.length >= limit)
-        break;
-      const callee = unwrap(call.expression);
-      if (import_typescript3.default.isPropertyAccessExpression(callee)) {
-        const receiver = unwrap(callee.expression);
-        if (import_typescript3.default.isIdentifier(receiver) && valueDeclaration(resolvedSymbol(receiver, this.checker)) === param)
-          out.push(call);
-      } else if (import_typescript3.default.isIdentifier(callee)) {
-        const declaration = valueDeclaration(resolvedSymbol(callee, this.checker));
-        if (!declaration || !import_typescript3.default.isBindingElement(declaration))
-          continue;
-        const holder = declaration.parent.parent;
-        const init = import_typescript3.default.isVariableDeclaration(holder) && holder.initializer ? unwrap(holder.initializer) : undefined;
-        if (holder === param || init && import_typescript3.default.isIdentifier(init) && valueDeclaration(resolvedSymbol(init, this.checker)) === param)
-          out.push(call);
-      }
+  if (import_typescript3.default.isCallExpression(expr)) {
+    const root = rootIdentifier(expr.expression);
+    const origin = root ? importOrigin(root, checker) : undefined;
+    if (origin) {
+      if (PROVIDER_MODULE.test(origin.module) && /^create/.test(origin.imported))
+        return origin.module;
+      if (origin.module === "ai" && (origin.imported === "customProvider" || origin.imported === "createGateway"))
+        return "ai";
+      return;
     }
-    return out;
-  }
-  defaultCanApply(declaration) {
-    if (!import_typescript3.default.isParameter(declaration) || this.checkingDefaults.has(declaration))
-      return true;
-    const init = declaration.initializer ? unwrap(declaration.initializer) : undefined;
-    if (!init || !import_typescript3.default.isIdentifier(init))
-      return true;
-    const fn = declaration.parent;
-    const name = isFunctionLike(fn) ? functionName(fn) : undefined;
-    if (!name || !isFunctionLike(fn))
-      return true;
-    const index = fn.parameters.indexOf(declaration);
-    this.checkingDefaults.add(declaration);
-    try {
-      const callers = this.callersOf(fn, name, 20);
-      if (callers.length === 0 || callers.length >= 20)
-        return true;
-      return callers.some((call) => {
-        if (call.arguments.slice(0, index + 1).some((argument2) => import_typescript3.default.isSpreadElement(argument2)))
-          return true;
-        const argument = call.arguments[index];
-        if (!argument)
-          return true;
-        const inner = unwrap(argument);
-        if (import_typescript3.default.isIdentifier(inner) && inner.text === "undefined" || import_typescript3.default.isVoidExpression(inner))
-          return true;
-        const passed = import_typescript3.default.isIdentifier(inner) ? valueDeclaration(resolvedSymbol(inner, this.checker)) : undefined;
-        if (passed && declaration.initializer && declares(passed, resolvedFunction(declaration.initializer, this.checker) ?? fn))
-          return true;
-        return !definitelyDefined(inner, this.checker);
+    const fn = resolvedFunction(expr.expression, checker);
+    if (fn) {
+      return memoized(fn, () => {
+        for (const ret of returnExpressions(fn)) {
+          const found = providerInstance(ret, checker, depth + 1);
+          if (found)
+            return found;
+        }
+        return;
       });
-    } finally {
-      this.checkingDefaults.delete(declaration);
-    }
-  }
-  direct(name, limit, matches, found) {
-    const candidates = this.byName.get(name) ?? [];
-    const out = [];
-    let checked = 0;
-    for (const call of candidates) {
-      if (found?.has(call))
-        continue;
-      if (out.length >= limit || checked >= limit * 20)
-        break;
-      checked += 1;
-      const callee = unwrap(call.expression);
-      const nameNode = import_typescript3.default.isPropertyAccessExpression(callee) ? callee.name : callee;
-      const symbol = resolvedSymbol(nameNode, this.checker);
-      if (symbol?.declarations?.some(matches))
-        out.push(call);
     }
-    return out;
   }
+  return;
 }
-
-class RepoCallIndex {
-  entries;
-  indexes = new Map;
-  owned = new Map;
-  constructor(entries) {
-    this.entries = entries;
-  }
-  indexFor(entry) {
-    let index = this.indexes.get(entry);
-    if (!index) {
-      index = new CallIndex(entry.program, entry.checker());
-      this.indexes.set(entry, index);
-    }
-    return index;
-  }
-  indexedCallersOf(fn, name, limit, within) {
-    const out = [];
-    const seen = new Set;
-    const fnFile = fn.getSourceFile().fileName;
-    for (const entry of this.entries) {
-      if (out.length >= limit)
-        break;
-      if (!entry.program.getSourceFile(fnFile))
-        continue;
-      let owned = this.owned.get(entry);
-      if (!owned) {
-        owned = new Set(entry.owned);
-        this.owned.set(entry, owned);
-      }
-      for (const call of this.indexFor(entry).callersOf(fn, name, Number.MAX_SAFE_INTEGER)) {
-        const source = call.getSourceFile();
-        if (!owned.has(source.fileName))
-          continue;
-        const key = `${source.fileName}:${call.pos}`;
-        if (seen.has(key))
-          continue;
-        if (within && within.getSourceFile(source.fileName) !== source)
-          continue;
-        seen.add(key);
-        out.push({ call, entry });
-        if (out.length >= limit)
-          break;
-      }
-    }
-    return out;
-  }
-  callersOf(fn, name, limit, within) {
-    const own = within ? this.entries.find((entry) => entry.program === within) : undefined;
-    if (own)
-      return this.indexFor(own).callersOf(fn, name, limit);
-    return this.indexedCallersOf(fn, name, limit, within).map((indexed) => indexed.call);
-  }
+var providerMemo = new WeakMap;
+function memoized(node, compute) {
+  if (providerMemo.has(node))
+    return providerMemo.get(node) ?? undefined;
+  providerMemo.set(node, null);
+  const value = compute();
+  providerMemo.set(node, value ?? null);
+  return value;
 }
-function importAliases(source) {
-  const aliases = new Map;
-  for (const statement of source.statements) {
-    const clause = import_typescript3.default.isImportDeclaration(statement) ? statement.importClause : undefined;
-    if (!clause || clause.isTypeOnly)
-      continue;
-    if (clause.name)
-      aliases.set(clause.name.text, "default");
-    if (clause.namedBindings && import_typescript3.default.isNamedImports(clause.namedBindings)) {
-      for (const element of clause.namedBindings.elements) {
-        if (element.propertyName)
-          aliases.set(element.name.text, element.propertyName.text);
-      }
-    }
+var MODEL_METHOD = /model|chat|completion|responses|messages|image|embedding|speech|transcription/i;
+function providerModelCall(call, checker) {
+  const model = call.arguments[0];
+  if (!model || import_typescript3.default.isSpreadElement(model) || import_typescript3.default.isObjectLiteralExpression(unwrap(model)))
+    return;
+  const callee = unwrap(call.expression);
+  if (import_typescript3.default.isIdentifier(callee)) {
+    const module = providerInstance(callee, checker);
+    return module ? { module, model } : undefined;
   }
-  return aliases;
-}
-function isDefaultExport(fn) {
-  const holder = import_typescript3.default.isVariableDeclaration(fn.parent) ? fn.parent : fn;
-  if (import_typescript3.default.canHaveModifiers(holder) && import_typescript3.default.getModifiers(holder)?.some((modifier) => modifier.kind === import_typescript3.default.SyntaxKind.DefaultKeyword))
-    return true;
-  if (import_typescript3.default.isExportAssignment(fn.parent))
-    return true;
-  const name = functionName(fn);
-  return Boolean(name && fn.getSourceFile().statements.some((statement) => import_typescript3.default.isExportAssignment(statement) && !statement.isExportEquals && import_typescript3.default.isIdentifier(statement.expression) && statement.expression.text === name));
+  if (import_typescript3.default.isPropertyAccessExpression(callee) && MODEL_METHOD.test(callee.name.text)) {
+    const module = providerInstance(callee.expression, checker);
+    return module ? { module, method: callee.name.text, model } : undefined;
+  }
+  return;
 }
-function sameNode(a, b) {
-  return a === b || a.kind === b.kind && a.pos === b.pos && a.end === b.end && a.getSourceFile().fileName === b.getSourceFile().fileName;
+function chainEndsWith(chain, tail) {
+  if (!chain || chain.length <= tail.length)
+    return false;
+  return tail.every((part, index) => chain[chain.length - tail.length + index] === part);
 }
-function declares(declaration, fn) {
-  if (sameNode(declaration, fn))
-    return true;
-  if ((import_typescript3.default.isVariableDeclaration(declaration) || import_typescript3.default.isPropertyAssignment(declaration) || import_typescript3.default.isPropertyDeclaration(declaration)) && declaration.initializer && sameNode(unwrap(declaration.initializer), fn))
-    return true;
-  if (import_typescript3.default.isExportAssignment(declaration) && sameNode(unwrap(declaration.expression), fn))
-    return true;
-  return false;
+function receiverOf(callee, tailLength) {
+  let current = unwrap(callee);
+  for (let index = 0;index < tailLength && import_typescript3.default.isPropertyAccessExpression(current); index += 1)
+    current = unwrap(current.expression);
+  return current;
 }
-function definitelyDefined(expression, checker, seen = new Set) {
-  const node = unwrap(expression);
-  if (seen.has(node))
-    return false;
-  seen.add(node);
-  if (import_typescript3.default.isStringLiteralLike(node) || import_typescript3.default.isNumericLiteral(node) || import_typescript3.default.isObjectLiteralExpression(node) || import_typescript3.default.isArrayLiteralExpression(node) || import_typescript3.default.isArrowFunction(node) || import_typescript3.default.isFunctionExpression(node) || node.kind === import_typescript3.default.SyntaxKind.NullKeyword || node.kind === import_typescript3.default.SyntaxKind.TrueKeyword || node.kind === import_typescript3.default.SyntaxKind.FalseKeyword)
-    return true;
-  if (import_typescript3.default.isIdentifier(node)) {
-    const declaration = valueDeclaration(resolvedSymbol(node, checker));
-    if (declaration && (import_typescript3.default.isFunctionDeclaration(declaration) || import_typescript3.default.isClassDeclaration(declaration)))
-      return true;
-    if (declaration && import_typescript3.default.isVariableDeclaration(declaration) && declaration.initializer && import_typescript3.default.getCombinedNodeFlags(declaration) & import_typescript3.default.NodeFlags.Const)
-      return definitelyDefined(declaration.initializer, checker, seen);
+var anthropicSink = {
+  id: "anthropic",
+  sdk: "anthropic",
+  match(call, ctx) {
+    if (!import_typescript3.default.isCallExpression(call))
+      return;
+    const chain = calleeChain(call.expression);
+    const tails = [["beta", "messages", "create"], ["beta", "messages", "stream"], ["messages", "create"], ["messages", "stream"]];
+    const tail = tails.find((candidate) => chainEndsWith(chain, candidate));
+    if (!tail || chain.includes("threads"))
+      return;
+    const receiver = receiverOf(call.expression, tail.length);
+    const origin = valueOrigin(receiver, ctx.checker);
+    const request = call.arguments[0];
+    if (origin && !ANTHROPIC_MODULE.test(origin.module))
+      return;
+    if (!origin) {
+      const object = objectLiteralOf(request, ctx.checker);
+      const receiverName = receiver.getText();
+      if (!object || !hasProperty(object, "model") || !hasProperty(object, "messages"))
+        return;
+      if (!/anthropic|claude|client|llm|openrouter/i.test(receiverName) && !hasProperty(object, "max_tokens"))
+        return;
+    }
+    return {
+      api: `anthropic.${tail.join(".")}`,
+      provider: "anthropic",
+      roles: requestRoles(request, { model: "model", system: "system", messages: "messages", tools: "tools" }, ctx)
+    };
   }
-  return false;
-}
-
-// src/harness-extract/messages.ts
-var ROLE_LITERALS = {
-  system: "system",
-  developer: "system",
-  user: "user",
-  human: "user",
-  assistant: "assistant",
-  ai: "assistant",
-  model: "assistant",
-  tool: "tool",
-  function: "tool"
 };
-var CONSTRUCTOR_ROLE = [
-  [/(?:^|\.)System(?:Message|MessagePromptTemplate)\b/, "system"],
-  [/(?:^|\.)(?:Human|User)(?:Message|MessagePromptTemplate)\b/, "user"],
-  [/(?:^|\.)(?:AI|Ai|Assistant)(?:Message|MessagePromptTemplate)\b/, "assistant"],
-  [/(?:^|\.)(?:Tool|Function)Message\b/, "tool"]
-];
-var PASS_THROUGH = new Set(["ref", "lookup", "param", "call", "oneOf"]);
-var STRINGY = new Set(["literal", "template", "concat", "arrayJoin"]);
-var MAX_CONTAINERS = 16;
-function singleLiteral(tree) {
-  if (!tree)
+var OPENAI_MODEL_ONLY_TAILS = [["embeddings", "create"], ["audio", "speech", "create"], ["audio", "transcriptions", "create"], ["audio", "translations", "create"], ["images", "generate"], ["images", "edit"]];
+function openaiModelOnly(call, chain, ctx) {
+  const tail = OPENAI_MODEL_ONLY_TAILS.find((candidate) => chainEndsWith(chain, candidate));
+  if (!tail)
     return;
-  if (tree.kind === "literal")
-    return tree.text;
-  if (PASS_THROUGH.has(tree.kind)) {
-    const flow = valueChildren(tree);
-    if (flow.length === 1)
-      return singleLiteral(flow[0]);
-  }
-  return;
+  const origin = valueOrigin(receiverOf(call.expression, tail.length), ctx.checker);
+  const object = objectLiteralOf(call.arguments[0], ctx.checker);
+  if (origin ? !OPENAI_MODULE.test(origin.module) : !object || !hasProperty(object, "model"))
+    return;
+  return { api: `openai.${tail.join(".")}`, provider: "openai", roles: requestRoles(call.arguments[0], { model: "model" }, ctx) };
 }
-function elementRole(element, depth = 0) {
-  if (depth > 6 || element.key === "...")
-    return "unknown";
-  if (element.kind === "object") {
-    const missing = { ...element, kind: "external", children: undefined, resolution: "unresolved" };
-    const text = singleLiteral(selectKey(element, "role", missing));
-    return text && ROLE_LITERALS[text.toLowerCase()] || "unknown";
+var openaiSink = {
+  id: "openai",
+  sdk: "openai",
+  match(call, ctx) {
+    if (!import_typescript3.default.isCallExpression(call))
+      return;
+    const chain = calleeChain(call.expression);
+    const tails = [["chat", "completions", "create"], ["chat", "completions", "parse"], ["chat", "completions", "stream"], ["responses", "create"], ["responses", "stream"], ["responses", "parse"]];
+    const tail = tails.find((candidate) => chainEndsWith(chain, candidate));
+    if (!tail)
+      return openaiModelOnly(call, chain, ctx);
+    const receiver = receiverOf(call.expression, tail.length);
+    const origin = valueOrigin(receiver, ctx.checker);
+    if (origin && !OPENAI_MODULE.test(origin.module) && !(tail[0] === "chat" && !ANTHROPIC_MODULE.test(origin.module)))
+      return;
+    const request = call.arguments[0];
+    if (!origin && tail[0] === "responses") {
+      const object = objectLiteralOf(request, ctx.checker);
+      if (!object || !hasProperty(object, "model") || !(hasProperty(object, "input") || hasProperty(object, "instructions")))
+        return;
+    }
+    return {
+      api: `openai.${tail.join(".")}`,
+      provider: !origin || OPENAI_MODULE.test(origin.module) ? "openai" : OPENAI_COMPATIBLE_MODULE.test(origin.module) ? providerName(origin.module).replace(/-sdk$|_cloud_sdk$|-ai$/, "") : providerName(origin.module),
+      roles: requestRoles(request, { model: "model", messages: "messages", input: "messages", instructions: "instructions", tools: "tools", functions: "tools" }, ctx)
+    };
   }
-  if (element.kind === "array") {
-    const text = singleLiteral(element.children?.[0]);
-    return text && ROLE_LITERALS[text.toLowerCase()] || "unknown";
+};
+var aiSdkSink = {
+  id: "ai-sdk",
+  sdk: "ai-sdk",
+  match(call, ctx) {
+    const callee = unwrap(call.expression);
+    const nameNode = import_typescript3.default.isPropertyAccessExpression(callee) ? callee.name : import_typescript3.default.isIdentifier(callee) ? callee : undefined;
+    const root = rootIdentifier(callee);
+    if (!nameNode || !root)
+      return;
+    const origin = importOrigin(root, ctx.checker);
+    if (!origin || origin.module !== "ai")
+      return;
+    const name = origin.imported === "*" ? nameNode.text : origin.imported;
+    if (!import_typescript3.default.isNewExpression(call) && AI_SDK_DECIDE.has(name)) {
+      return { api: `ai.${name}`, roles: requestRoles(call.arguments[0], { model: "model", questions: "questions", criteria: "questions" }, ctx) };
+    }
+    const known = import_typescript3.default.isNewExpression(call) ? AI_SDK_AGENTS.has(name) : AI_SDK_CALLS.has(name);
+    if (!known)
+      return;
+    return {
+      api: `ai.${name}`,
+      roles: requestRoles(call.arguments?.[0], { model: "model", system: "system", instructions: "instructions", prompt: "prompt", messages: "messages", tools: "tools" }, ctx)
+    };
   }
-  if ((element.kind === "call" || element.kind === "external") && element.name) {
-    for (const [pattern, role] of CONSTRUCTOR_ROLE)
-      if (pattern.test(element.name))
-        return role;
+};
+var providerFactorySink = {
+  id: "provider-factory",
+  sdk: "provider-factory",
+  match(call, ctx) {
+    if (!import_typescript3.default.isCallExpression(call))
+      return;
+    const found = providerModelCall(call, ctx.checker);
+    if (!found)
+      return;
+    const provider = providerName(found.module);
+    return { api: `${provider}${found.method ? `.${found.method}` : ""}(model)`, provider, roles: [{ role: "model", node: found.model }] };
   }
-  if (PASS_THROUGH.has(element.kind)) {
-    const roles = new Set(valueChildren(element).map((child) => elementRole(child, depth + 1)));
-    return roles.size === 1 ? [...roles][0] : "unknown";
+};
+var WORKERS_AI_MODEL = /^@(?:cf|hf)\/[\w.-]+\/[\w.:-]+$/;
+function isWorkersAiBinding(callee, checker) {
+  const target = unwrap(callee);
+  if (!import_typescript3.default.isPropertyAccessExpression(target))
+    return false;
+  const receiver = unwrap(target.expression);
+  const declaration = import_typescript3.default.isIdentifier(receiver) || import_typescript3.default.isPropertyAccessExpression(receiver) ? valueDeclaration(resolvedSymbol(import_typescript3.default.isIdentifier(receiver) ? receiver : receiver.name, checker)) : undefined;
+  const type = declaration && (import_typescript3.default.isParameter(declaration) || import_typescript3.default.isVariableDeclaration(declaration) || import_typescript3.default.isPropertyDeclaration(declaration) || import_typescript3.default.isPropertySignature(declaration)) ? declaration.type : undefined;
+  return Boolean(type && import_typescript3.default.isTypeReferenceNode(type) && type.typeName.getText() === "Ai");
+}
+var workersAiSink = {
+  id: "workers-ai",
+  sdk: "workers-ai",
+  match(call, ctx) {
+    if (!import_typescript3.default.isCallExpression(call))
+      return;
+    const chain = calleeChain(call.expression);
+    if (!chain || chain[chain.length - 1] !== "run" || call.arguments.length === 0)
+      return;
+    const [model, input] = call.arguments;
+    if (!chainEndsWith(chain, ["AI", "run"]) && !isWorkersAiBinding(call.expression, ctx.checker) && !ctx.urlTexts(model).some((text) => WORKERS_AI_MODEL.test(text)))
+      return;
+    return {
+      api: "workers-ai.AI.run",
+      provider: "workers-ai",
+      roles: [{ role: "model", node: model }, ...requestRoles(input, { messages: "messages", prompt: "prompt", tools: "tools" }, ctx)]
+    };
   }
-  return "unknown";
+};
+var REQUEST_KEYS = { model: "model", model_id: "model", system: "system", messages: "messages", input: "messages", instructions: "instructions", prompt: "prompt", tools: "tools" };
+var OPAQUE_BODY_KEYS = { model: "model", system: "system", messages: "messages", tools: "tools" };
+var FETCH_LIKE = /fetch|request|post/i;
+var NON_MODEL_PATH = /\/models\/?(?:\?|$|`)|\/generation\b|\/credits\b|\/auth\/|\/keys?\b|\/embeddings\b|\/files\b/;
+function bodyHasModel(init, checker) {
+  const body = init ? propertyValue(init, "body") : undefined;
+  let payload = body ? unwrap(body) : undefined;
+  if (payload && import_typescript3.default.isCallExpression(payload) && payload.arguments[0])
+    payload = payload.arguments[0];
+  const object = objectLiteralOf(payload, checker);
+  return Boolean(object && hasProperty(object, "model"));
 }
-function containersOf(tree, containers, others, depth = 0) {
-  if (containers.length >= MAX_CONTAINERS)
-    return;
-  if (tree.kind === "array" || tree.kind === "assembled" && tree.text !== "string") {
-    containers.push(tree);
-    return;
+function urlTemplate(expression, checker, depth = 0) {
+  const expr = unwrap(expression);
+  if (import_typescript3.default.isTemplateExpression(expr))
+    return expr;
+  if (depth < 3 && import_typescript3.default.isIdentifier(expr)) {
+    const declaration = valueDeclaration(resolvedSymbol(expr, checker));
+    if (declaration && import_typescript3.default.isVariableDeclaration(declaration) && declaration.initializer)
+      return urlTemplate(declaration.initializer, checker, depth + 1);
   }
-  const flow = PASS_THROUGH.has(tree.kind) ? valueChildren(tree) : [];
-  if (flow.length > 0 && depth < 12) {
-    for (const child of flow)
-      containersOf(child, containers, others, depth + 1);
+  return;
+}
+var MODEL_SOCKET = /^wss:\/\/(?:api\.openai\.com\/v1\/realtime|[\w.-]+\.openai\.azure\.com\/openai\/realtime|generativelanguage\.googleapis\.com\/ws\/[\w.]+BidiGenerateContent|gateway\.ai\.cloudflare\.com\/)/;
+function urlModel(url, checker) {
+  const template = urlTemplate(url, checker);
+  if (!template)
     return;
+  let before = template.head.text;
+  for (const span of template.templateSpans) {
+    if (/\/models\/$/.test(before) && /^[:/?#]/.test(span.literal.text) || /[?&]model=$/.test(before) && /^(?:[&#]|$)/.test(span.literal.text))
+      return span.expression;
+    before = span.literal.text;
   }
-  others.push(tree);
+  return;
 }
-function splitMessages(tree) {
-  const containers = [];
-  const others = [];
-  containersOf(tree, containers, others);
-  if (containers.length === 0) {
-    return [{ role: STRINGY.has(tree.kind) || others.length > 0 && others.every((other) => STRINGY.has(other.kind)) ? "user" : "unknown", tree }];
+var fetchSink = {
+  id: "fetch",
+  sdk: "fetch",
+  match(call, ctx) {
+    if (!import_typescript3.default.isCallExpression(call) || call.arguments.length < 2)
+      return;
+    const callee = unwrap(call.expression);
+    const calleeText = import_typescript3.default.isCallExpression(callee) ? callee.expression.getText() : callee.getText();
+    if (!FETCH_LIKE.test(calleeText))
+      return;
+    if (import_typescript3.default.isIdentifier(callee) && callee.text === "fetch" && resolvedFunction(callee, ctx.checker))
+      return;
+    const second = unwrap(call.arguments[1]);
+    if (import_typescript3.default.isArrowFunction(second) || import_typescript3.default.isFunctionExpression(second))
+      return;
+    const first = unwrap(call.arguments[0]);
+    if ((import_typescript3.default.isStringLiteral(first) || import_typescript3.default.isNoSubstitutionTemplateLiteral(first)) && !MODEL_HOST.test(first.text) && !MODEL_PATH.test(first.text) && !SPEECH_ENDPOINT.test(first.text))
+      return;
+    const urls = ctx.urlTexts(call.arguments[0]);
+    const initArg = call.arguments[1];
+    const init = objectLiteralOf(initArg, ctx.checker);
+    const url = urls.find((candidate) => SPEECH_ENDPOINT.test(candidate) || !NON_MODEL_PATH.test(candidate) && (MODEL_HOST.test(candidate) || MODEL_PATH.test(candidate) && (/^https?:\/\//.test(candidate) || bodyHasModel(init, ctx.checker))));
+    if (!url)
+      return;
+    const roles = [];
+    if (init) {
+      const body = propertyValue(init, "body");
+      let payload = body ? unwrap(body) : undefined;
+      if (payload && import_typescript3.default.isCallExpression(payload) && calleeChain(payload.expression)?.join(".") === "JSON.stringify")
+        payload = payload.arguments[0];
+      if (payload)
+        roles.push(...requestRoles(payload, REQUEST_KEYS, ctx));
+    } else {
+      for (const [key, role] of Object.entries(OPAQUE_BODY_KEYS))
+        roles.push({ role, node: initArg, key: `body.${key}` });
+    }
+    const modelInUrl = urlModel(call.arguments[0], ctx.checker);
+    if (modelInUrl && !roles.some((role) => role.role === "model"))
+      roles.unshift({ role: "model", node: modelInUrl });
+    if (modelInUrl) {
+      const index = roles.findIndex((role) => role.role === "model" && role.key?.startsWith("body."));
+      if (index >= 0)
+        roles[index] = { role: "model", node: modelInUrl };
+    }
+    return {
+      api: "fetch",
+      provider: /elevenlabs/.test(url) ? "elevenlabs" : /anthropic/.test(url) ? "anthropic" : /openrouter/.test(url) ? "openrouter" : /openai/.test(url) ? "openai" : /generativelanguage/.test(url) ? "google" : undefined,
+      roles
+    };
   }
-  const out = [];
-  for (const container of containers) {
-    (container.children ?? []).forEach((element, index) => {
-      out.push({ role: elementRole(element), tree: element, message: { arrayId: container.id, index } });
-    });
+};
+var AGENT_ENTRY_METHODS = new Set(["run", "runTurn", "executeRun", "chat", "saveMessages", "sendMessage", "submitMessage", "prompt", "runAgentTool"]);
+var AGENT_BASES = new Set(["Think", "Agent", "AIChatAgent"]);
+var ENTRY_FIELDS = ["message", "context", "brief"];
+var STUB_GETTERS = new Set(["get", "getByName", "getAgentByName", "getServerByName", "routeAgentRequest", "getStub"]);
+function classOfDeclaration(declaration) {
+  if (!declaration)
+    return;
+  if (import_typescript3.default.isClassDeclaration(declaration) || import_typescript3.default.isClassExpression(declaration))
+    return declaration;
+  return;
+}
+function classesInType(type, checker, out = []) {
+  if (!type || out.length > 4)
+    return out;
+  if (import_typescript3.default.isTypeReferenceNode(type)) {
+    const name = import_typescript3.default.isQualifiedName(type.typeName) ? type.typeName.right : type.typeName;
+    const cls = classOfDeclaration(valueDeclaration(resolvedSymbol(name, checker)));
+    if (cls)
+      out.push(cls);
+    for (const argument of type.typeArguments ?? [])
+      classesInType(argument, checker, out);
+  } else if (import_typescript3.default.isUnionTypeNode(type) || import_typescript3.default.isIntersectionTypeNode(type)) {
+    for (const member of type.types)
+      classesInType(member, checker, out);
   }
-  for (const other of others)
-    out.push({ role: STRINGY.has(other.kind) ? "user" : "unknown", tree: other });
   return out;
 }
-
-// src/harness-extract/program.ts
-var import_typescript4 = __toESM(require_typescript(), 1);
-import { createHash } from "node:crypto";
-import { readdirSync, statSync } from "node:fs";
-import { dirname, join, relative as relative2, resolve } from "node:path";
-var SKIPPED_DIRS2 = new Set(["node_modules", "dist", "build", "out", "vendor", "coverage", "graphify-out", "__pycache__"]);
-var CODE_FILE = /\.(?:[cm]?[jt]sx?)$/i;
-var SVELTE_FILE = /\.svelte$/i;
-var SCRIPT_BLOCK = /(<script\b[^>]*>)([\s\S]*?)<\/script\s*>/gi;
-function svelteScriptText(text) {
-  const out = text.replace(/[^\n]/g, " ").split("");
-  for (const match of text.matchAll(SCRIPT_BLOCK)) {
-    const start = (match.index ?? 0) + match[1].length;
-    for (let index = 0;index < match[2].length; index += 1)
-      out[start + index] = match[2][index];
+function receiverClasses(expression, checker, depth = 0) {
+  const expr = unwrap(expression);
+  if (depth > 4)
+    return [];
+  if (expr.kind === import_typescript3.default.SyntaxKind.ThisKeyword) {
+    for (let current = expr.parent;current; current = current.parent) {
+      if (import_typescript3.default.isClassDeclaration(current) || import_typescript3.default.isClassExpression(current))
+        return [current];
+    }
+    return [];
   }
-  return out.join("");
-}
-var DECLARATION_FILE = /\.d\.[cm]?ts$/i;
-var TEST_RUNNER_FILE = /(?:^|\/)__tests__\/|\.(?:test|spec)\.[cm]?[jt]sx?$/i;
-var TEST_PATH = /(?:^|\/)(?:test|tests|__tests__|test-fixtures|fixtures?|__fixtures__|__mocks__|e2e)\/|\.(?:test|spec)\.[cm]?[jt]sx?$/i;
-var EVAL_PATH = /(?:^|\/)evals?\/|\.evals?\.[cm]?[jt]sx?$/i;
-var MAX_FILE_BYTES = 1024 * 1024;
-var DEFAULT_MAX_FILES = 20000;
-function isTestPath(rel) {
-  return TEST_PATH.test(rel);
-}
-function isEvalPath(rel) {
-  return EVAL_PATH.test(rel);
-}
-function walkRepository(rootDir, maxFiles, includeTestRunnerFiles) {
-  const files = [];
-  const configs = [];
-  let truncated = false;
-  const walk = (abs, rel) => {
-    let entries;
-    try {
-      entries = readdirSync(abs, { withFileTypes: true });
-    } catch {
-      return;
+  if (import_typescript3.default.isNewExpression(expr)) {
+    const cls = classOfDeclaration(valueDeclaration(resolvedSymbol(import_typescript3.default.isPropertyAccessExpression(expr.expression) ? expr.expression.name : expr.expression, checker)));
+    return cls ? [cls] : [];
+  }
+  if (import_typescript3.default.isCallExpression(expr)) {
+    const callee = unwrap(expr.expression);
+    const name = import_typescript3.default.isPropertyAccessExpression(callee) ? callee.name.text : import_typescript3.default.isIdentifier(callee) ? callee.text : "";
+    if (name === "get" && import_typescript3.default.isPropertyAccessExpression(callee) && import_typescript3.default.isPropertyAccessExpression(callee.expression) && callee.expression.name.text === "dynamicAgents" && expr.arguments[0]) {
+      const target = classOfDeclaration(valueDeclaration(resolvedSymbol(expr.arguments[0], checker)));
+      if (target)
+        return [target];
     }
-    entries.sort((a, b) => a.name.localeCompare(b.name));
-    for (const entry of entries) {
-      if (files.length >= maxFiles) {
-        truncated = true;
-        return;
+    if (!STUB_GETTERS.has(name)) {
+      const fn = resolvedFunction(callee, checker);
+      return fn ? returnExpressions(fn).flatMap((value) => receiverClasses(value, checker, depth + 1)) : [];
+    }
+    const fromTypeArgs = (expr.typeArguments ?? []).flatMap((argument) => classesInType(argument, checker));
+    if (fromTypeArgs.length > 0)
+      return fromTypeArgs;
+    const namespace = import_typescript3.default.isPropertyAccessExpression(callee) && name !== "getAgentByName" && name !== "getServerByName" ? callee.expression : expr.arguments[0];
+    return namespace ? receiverClasses(namespace, checker, depth + 1) : [];
+  }
+  const nameNode = import_typescript3.default.isPropertyAccessExpression(expr) ? expr.name : import_typescript3.default.isIdentifier(expr) ? expr : undefined;
+  if (!nameNode)
+    return [];
+  const declaration = valueDeclaration(resolvedSymbol(nameNode, checker));
+  if (!declaration)
+    return [];
+  if (import_typescript3.default.isVariableDeclaration(declaration) || import_typescript3.default.isParameter(declaration) || import_typescript3.default.isPropertyDeclaration(declaration) || import_typescript3.default.isPropertySignature(declaration)) {
+    const declared = classesInType(declaration.type, checker);
+    if (declared.length > 0)
+      return declared;
+    if ("initializer" in declaration && declaration.initializer)
+      return receiverClasses(declaration.initializer, checker, depth + 1);
+  }
+  return [];
+}
+function firstParamType(declaration, checker) {
+  if (!declaration)
+    return;
+  let parameters;
+  if (import_typescript3.default.isMethodSignature(declaration) || import_typescript3.default.isMethodDeclaration(declaration))
+    parameters = declaration.parameters;
+  else if ((import_typescript3.default.isPropertySignature(declaration) || import_typescript3.default.isPropertyDeclaration(declaration)) && declaration.type && import_typescript3.default.isFunctionTypeNode(declaration.type))
+    parameters = declaration.type.parameters;
+  const type = parameters?.[0]?.type;
+  if (!type || !import_typescript3.default.isTypeReferenceNode(type))
+    return;
+  const name = import_typescript3.default.isQualifiedName(type.typeName) ? type.typeName.right : type.typeName;
+  return valueDeclarationOrType(resolvedSymbol(name, checker));
+}
+function valueDeclarationOrType(symbol) {
+  return symbol?.declarations?.[0];
+}
+function structuralAgent(receiver, method, ctx) {
+  let declaration;
+  try {
+    declaration = ctx.checker.getTypeAtLocation(receiver).getProperty(method)?.declarations?.[0];
+  } catch {
+    return;
+  }
+  declaration ??= declaredMethod(receiver, method, ctx.checker);
+  if (!declaration)
+    return;
+  const owner = declaration.parent;
+  if (owner && (import_typescript3.default.isClassDeclaration(owner) || import_typescript3.default.isClassExpression(owner))) {
+    const base = ctx.frameworkBase(owner).base;
+    return base && AGENT_BASES.has(base) ? owner : undefined;
+  }
+  const wanted = firstParamType(declaration, ctx.checker);
+  if (!wanted)
+    return;
+  return ctx.agentClasses().find((cls) => cls.members.some((member) => import_typescript3.default.isMethodDeclaration(member) && propertyNameText(member.name) === method && firstParamType(member, ctx.checker) === wanted));
+}
+var agentEntrySink = {
+  id: "agent-entry",
+  sdk: "agent-entry",
+  match(call, ctx) {
+    if (!import_typescript3.default.isCallExpression(call) || call.arguments.length === 0)
+      return;
+    const callee = unwrap(call.expression);
+    if (!import_typescript3.default.isPropertyAccessExpression(callee) || !AGENT_ENTRY_METHODS.has(callee.name.text))
+      return;
+    const method = callee.name.text;
+    const cls = receiverClasses(callee.expression, ctx.checker).find((candidate) => {
+      const base = ctx.frameworkBase(candidate).base;
+      return base !== undefined && AGENT_BASES.has(base);
+    });
+    const seam = method === "runAgentTool" && !cls && hasMethod(callee.expression, method, ctx) ? callee.expression : undefined;
+    const target = cls ?? structuralAgent(callee.expression, method, ctx);
+    if (!target && !seam)
+      return;
+    const argument = method === "runAgentTool" ? call.arguments[1] : call.arguments[0];
+    if (!argument || import_typescript3.default.isSpreadElement(argument))
+      return;
+    const roles = [];
+    if (method === "runAgentTool") {
+      const object = objectLiteralOf(argument, ctx.checker);
+      const input = object ? propertyValue(object, "input") : undefined;
+      roles.push(input ? { role: "user", node: input } : { role: "user", node: argument, key: "input" });
+    } else if (method === "runTurn") {
+      const object = objectLiteralOf(argument, ctx.checker);
+      const input = object ? propertyValue(object, "input") : undefined;
+      roles.push(input ? { role: "messages", node: input } : { role: "messages", node: argument, key: "input" });
+    } else if (method === "saveMessages") {
+      roles.push({ role: "messages", node: argument });
+    } else {
+      const object = objectLiteralOf(argument, ctx.checker);
+      const fields = object ? ENTRY_FIELDS.filter((field) => propertyValue(object, field)) : [];
+      if (object && unwrap(argument) === object && fields.length > 0) {
+        for (const field of fields)
+          roles.push({ role: "user", node: propertyValue(object, field) });
+      } else {
+        roles.push({ role: "user", node: argument });
       }
-      const childRel = rel ? `${rel}/${entry.name}` : entry.name;
-      const childAbs = join(abs, entry.name);
-      if (entry.isDirectory()) {
-        if (!entry.name.startsWith(".") && !SKIPPED_DIRS2.has(entry.name))
-          walk(childAbs, childRel);
-      } else if (entry.isFile()) {
-        if (entry.name === "tsconfig.json")
-          configs.push(childAbs);
-        else if (SVELTE_FILE.test(entry.name)) {
-          try {
-            if (statSync(childAbs).size <= MAX_FILE_BYTES)
-              files.push(svelteVirtualName(childAbs));
-          } catch {
-            continue;
-          }
-        } else if (CODE_FILE.test(entry.name) && !DECLARATION_FILE.test(entry.name) && !/\.min\.[cm]?js$/i.test(entry.name) && (includeTestRunnerFiles || !TEST_RUNNER_FILE.test(childRel))) {
-          try {
-            if (statSync(childAbs).size > MAX_FILE_BYTES)
-              continue;
-          } catch {
-            continue;
-          }
-          files.push(childAbs);
-        }
+    }
+    return { api: `${(target && className(target)) ?? "agent"}.${method}`, roles };
+  }
+};
+function declaredMethod(receiver, method, checker) {
+  const root = unwrap(receiver);
+  if (!import_typescript3.default.isIdentifier(root))
+    return;
+  let annotation;
+  try {
+    const declaration = checker.getSymbolAtLocation(root)?.valueDeclaration;
+    if (declaration && (import_typescript3.default.isParameter(declaration) || import_typescript3.default.isVariableDeclaration(declaration) || import_typescript3.default.isPropertySignature(declaration) || import_typescript3.default.isPropertyDeclaration(declaration)))
+      annotation = declaration.type;
+  } catch {
+    return;
+  }
+  const seen = new Set;
+  const search = (type, depth) => {
+    if (!type || depth > 4 || seen.has(type))
+      return;
+    seen.add(type);
+    if (import_typescript3.default.isIntersectionTypeNode(type) || import_typescript3.default.isUnionTypeNode(type)) {
+      for (const member of type.types) {
+        const found = search(member, depth + 1);
+        if (found)
+          return found;
       }
+      return;
     }
+    if (import_typescript3.default.isParenthesizedTypeNode(type))
+      return search(type.type, depth + 1);
+    const members = import_typescript3.default.isTypeLiteralNode(type) ? type.members : undefined;
+    if (members)
+      return members.find((member) => (import_typescript3.default.isMethodSignature(member) || import_typescript3.default.isPropertySignature(member)) && propertyNameText(member.name) === method);
+    if (!import_typescript3.default.isTypeReferenceNode(type))
+      return;
+    return fromName(type.typeName, depth);
   };
-  walk(rootDir, "");
-  return { files, configs, truncated };
-}
-function sourceFingerprint(rootDir, options = {}) {
-  const walked = walkRepository(resolve(rootDir), options.maxFiles ?? DEFAULT_MAX_FILES, options.includeTestRunnerFiles ?? false);
-  const hash = createHash("sha1");
-  const inputs = new Set([...walked.configs, ...walked.files.map((file) => file.endsWith(SVELTE_VIRTUAL_SUFFIX) ? file.slice(0, -SVELTE_VIRTUAL_SUFFIX.length) : file)]);
-  for (const config of walked.configs) {
-    const host = { ...import_typescript4.default.sys, onUnRecoverableConfigFileDiagnostic: () => {}, readFile: (file) => {
-      inputs.add(file);
-      return import_typescript4.default.sys.readFile(file);
-    } };
-    import_typescript4.default.getParsedCommandLineOfConfigFile(config, {}, host);
-  }
-  const metadata = (directory) => {
-    let entries;
+  const fromName = (name, depth) => {
+    let symbol;
     try {
-      entries = readdirSync(directory, { withFileTypes: true });
+      symbol = checker.getSymbolAtLocation(name);
+      if (symbol && symbol.flags & import_typescript3.default.SymbolFlags.Alias)
+        symbol = checker.getAliasedSymbol(symbol);
     } catch {
       return;
     }
-    for (const entry of entries) {
-      if (entry.isDirectory() && !entry.name.startsWith(".") && !SKIPPED_DIRS2.has(entry.name))
-        metadata(join(directory, entry.name));
-      else if (entry.isFile() && (entry.name === "package.json" || /^wrangler(?:\.[\w.-]+)?\.(?:json|jsonc|toml)$/.test(entry.name)))
-        inputs.add(join(directory, entry.name));
+    for (const declaration of symbol?.declarations ?? []) {
+      if (seen.has(declaration))
+        continue;
+      seen.add(declaration);
+      if (import_typescript3.default.isInterfaceDeclaration(declaration)) {
+        const own = declaration.members.find((member) => (import_typescript3.default.isMethodSignature(member) || import_typescript3.default.isPropertySignature(member)) && propertyNameText(member.name) === method);
+        if (own)
+          return own;
+        for (const clause of declaration.heritageClauses ?? []) {
+          for (const base of clause.types) {
+            const found = fromName(base.expression, depth + 1);
+            if (found)
+              return found;
+          }
+        }
+      }
+      if (import_typescript3.default.isTypeAliasDeclaration(declaration)) {
+        const found = search(declaration.type, depth + 1);
+        if (found)
+          return found;
+      }
     }
+    return;
   };
-  metadata(resolve(rootDir));
-  for (const file of [...inputs].sort()) {
-    const text = import_typescript4.default.sys.readFile(file);
-    hash.update(`${file}\x00${text ?? "missing"}
-`);
+  return search(annotation, 0);
+}
+function hasMethod(receiver, method, ctx) {
+  try {
+    return Boolean(ctx.checker.getTypeAtLocation(receiver).getProperty(method));
+  } catch {
+    return false;
   }
-  return hash.digest("hex");
 }
-function extractorOptions(base) {
-  const options = {
-    ...base,
-    noEmit: true,
-    skipLibCheck: true,
-    noLib: true,
-    types: [],
-    noResolve: false,
-    allowJs: true,
-    checkJs: false,
-    resolveJsonModule: false,
-    declaration: false,
-    composite: false,
-    incremental: false,
-    tsBuildInfoFile: undefined,
-    plugins: undefined
-  };
-  if (options.moduleResolution === undefined) {
-    options.module = import_typescript4.default.ModuleKind.ESNext;
-    options.moduleResolution = import_typescript4.default.ModuleResolutionKind.Bundler;
+var CHAT_HOOK_MODULE = /^(?:@ai-sdk\/(?:react|svelte|vue|angular|solid)|ai\/(?:react|svelte|vue)|agents\/(?:ai-)?react|@cloudflare\/(?:think|ai-chat|agents)\/react)$/;
+var CHAT_HOOKS = new Set(["useChat", "useAgentChat", "Chat", "useCompletion"]);
+var CHAT_SEND = new Set(["sendMessage", "append", "submitMessage", "complete"]);
+function fromChatHook(expression, checker, depth = 0) {
+  if (!expression || depth > 3)
+    return false;
+  const expr = unwrap(expression);
+  if (import_typescript3.default.isCallExpression(expr) || import_typescript3.default.isNewExpression(expr)) {
+    const root = rootIdentifier(expr.expression);
+    const origin = root ? importOrigin(root, checker) : undefined;
+    return Boolean(origin && CHAT_HOOK_MODULE.test(origin.module) && CHAT_HOOKS.has(origin.imported === "*" || origin.imported === "default" ? import_typescript3.default.isPropertyAccessExpression(expr.expression) ? expr.expression.name.text : "" : origin.imported));
   }
-  options.allowImportingTsExtensions = true;
-  return options;
+  const nameNode = import_typescript3.default.isIdentifier(expr) ? expr : import_typescript3.default.isPropertyAccessExpression(expr) ? expr.name : undefined;
+  const declaration = nameNode ? valueDeclaration(resolvedSymbol(nameNode, checker)) : undefined;
+  if (!declaration)
+    return false;
+  if (import_typescript3.default.isBindingElement(declaration)) {
+    const holder = declaration.parent.parent;
+    return import_typescript3.default.isVariableDeclaration(holder) && fromChatHook(holder.initializer, checker, depth + 1);
+  }
+  if (import_typescript3.default.isVariableDeclaration(declaration))
+    return fromChatHook(declaration.initializer, checker, depth + 1);
+  return false;
 }
-var FALLBACK_OPTIONS = extractorOptions({
-  target: import_typescript4.default.ScriptTarget.ES2022,
-  jsx: import_typescript4.default.JsxEmit.Preserve,
-  esModuleInterop: true
-});
-function sharedHost(options, cache) {
-  const host = import_typescript4.default.createCompilerHost(options, true);
-  const moduleCache = import_typescript4.default.createModuleResolutionCache(host.getCurrentDirectory(), (name) => name, options);
-  host.getSourceFile = (fileName, languageVersionOrOptions) => {
-    const version = typeof languageVersionOrOptions === "object" ? languageVersionOrOptions.languageVersion : languageVersionOrOptions;
-    const key = `${version}:${fileName}`;
-    if (cache.has(key))
-      return cache.get(key);
-    let source;
-    const svelte = fileName.endsWith(SVELTE_VIRTUAL_SUFFIX);
-    const raw = import_typescript4.default.sys.readFile(svelte ? fileName.slice(0, -SVELTE_VIRTUAL_SUFFIX.length) : fileName);
-    const text = svelte && raw !== undefined ? svelteScriptText(raw) : raw;
-    if (text !== undefined && text.length <= MAX_FILE_BYTES) {
-      source = import_typescript4.default.createSourceFile(fileName, text, languageVersionOrOptions, true, svelte ? import_typescript4.default.ScriptKind.TS : undefined);
-    }
-    cache.set(key, source);
-    return source;
-  };
-  host.resolveModuleNameLiterals = (literals, containingFile, redirected, compilerOptions) => literals.map((literal) => {
-    const resolved = import_typescript4.default.resolveModuleName(literal.text, containingFile, compilerOptions, host, moduleCache, redirected).resolvedModule;
-    if (!resolved || resolved.isExternalLibraryImport || /[\\/]node_modules[\\/]/.test(resolved.resolvedFileName) || DECLARATION_FILE.test(resolved.resolvedFileName) || !CODE_FILE.test(resolved.resolvedFileName)) {
-      return { resolvedModule: undefined };
-    }
-    return { resolvedModule: resolved };
-  });
-  const fileExists = host.fileExists.bind(host);
-  host.fileExists = (fileName) => fileName.endsWith(SVELTE_VIRTUAL_SUFFIX) ? fileExists(fileName.slice(0, -SVELTE_VIRTUAL_SUFFIX.length)) : fileExists(fileName);
-  host.writeFile = () => {};
-  return host;
-}
-var NO_INPUTS_FOUND = 18003;
-function parseConfig(configPath, warnings, rootDir) {
-  const rel = relative2(rootDir, configPath).split("\\").join("/");
-  const read = import_typescript4.default.readConfigFile(configPath, import_typescript4.default.sys.readFile);
-  if (read.error || !read.config || typeof read.config !== "object") {
-    warnings.push(`tsconfig ${rel}: unreadable, its files fall back to the default program`);
-    return;
-  }
-  const raw = read.config;
-  const parsed = import_typescript4.default.parseJsonConfigFileContent(read.config, import_typescript4.default.sys, dirname(configPath), undefined, configPath);
-  const errors = parsed.errors.filter((error) => error.code !== NO_INPUTS_FOUND);
-  if (errors.length > 0) {
-    const messages = errors.slice(0, 3).map((error) => import_typescript4.default.flattenDiagnosticMessageText(error.messageText, " "));
-    warnings.push(`tsconfig ${rel}: ${messages.join("; ")}${errors.length > 3 ? ` (+${errors.length - 3} more)` : ""}; extraction continues with the options that parsed`);
-  }
-  const explicit = raw.include !== undefined || raw.files !== undefined || parsed.raw && (parsed.raw.include !== undefined || parsed.raw.files !== undefined);
-  return { options: parsed.options, fileNames: explicit ? parsed.fileNames.map((name) => resolve(name)) : undefined };
-}
-function isUnder(file, dir) {
-  const rel = relative2(dir, file);
-  return rel !== "" && !rel.startsWith("..") && !rel.startsWith("/");
-}
-function buildPrograms(rootDir, options = {}) {
-  const root = resolve(rootDir);
-  const maxFiles = options.maxFiles ?? DEFAULT_MAX_FILES;
-  const warnings = [];
-  const walked = walkRepository(root, maxFiles, options.includeTestRunnerFiles ?? false);
-  if (walked.truncated)
-    warnings.push(`file cap reached: only the first ${maxFiles} code files are scanned`);
-  const known = new Set(walked.files);
-  const configDirs = walked.configs.map((path) => dirname(path));
-  const assigned = new Set;
-  const cache = new Map;
-  const entries = [];
-  const owner = new Map;
-  const create = (rootNames, owned, compilerOptions, configPath) => {
-    const host = sharedHost(compilerOptions, cache);
-    let program;
-    try {
-      program = import_typescript4.default.createProgram({ rootNames, options: compilerOptions, host });
-    } catch (error) {
-      warnings.push(`program ${configPath ?? "(fallback)"}: ${error.message}`);
-      return;
-    }
-    let checker;
-    const entry = {
-      program,
-      configPath,
-      owned,
-      checker: () => checker ??= program.getTypeChecker()
-    };
-    entries.push(entry);
-    for (const file of owned)
-      owner.set(file, entry);
-  };
-  const configs = [...walked.configs].sort((a, b) => b.split(/[\\/]/).length - a.split(/[\\/]/).length || a.localeCompare(b));
-  for (const configPath of configs) {
-    const parsed = parseConfig(configPath, warnings, root);
-    if (!parsed)
-      continue;
-    const dir = dirname(configPath);
-    const nested = configDirs.filter((other) => other !== dir && isUnder(other, dir));
-    const underDir = (file) => isUnder(file, dir) && !nested.some((other) => isUnder(file, other));
-    const included = parsed.fileNames ? [...parsed.fileNames.filter((file) => known.has(file)), ...walked.files.filter((file) => file.endsWith(SVELTE_VIRTUAL_SUFFIX) && underDir(file))] : walked.files.filter(underDir);
-    const owned = included.filter((file) => !assigned.has(file));
-    if (owned.length === 0)
-      continue;
-    for (const file of owned)
-      assigned.add(file);
-    create(included, owned, extractorOptions(parsed.options), relative2(root, configPath).split("\\").join("/"));
-  }
-  const rest = walked.files.filter((file) => !assigned.has(file));
-  if (rest.length > 0)
-    create(rest, rest, FALLBACK_OPTIONS);
-  return { rootDir: root, entries, owner, files: assigned.size + rest.length, warnings };
-}
-
-// src/harness-extract/sinks.ts
-var import_typescript5 = __toESM(require_typescript(), 1);
-var URL_MODEL_KEY = "?model";
-var ANTHROPIC_MODULE = /^@anthropic-ai\//;
-var OPENAI_MODULE = /^openai(?:\/|$)/;
-var OPENAI_COMPATIBLE_MODULE = /^(?:groq-sdk|together-ai|@cerebras\/cerebras_cloud_sdk|fireworks-ai|portkey-ai|@portkey-ai\/|@azure\/openai|deepseek|@helicone\/|cohere-ai)/;
-var AI_SDK_CALLS = new Set(["generateText", "streamText", "generateObject", "streamObject"]);
-var AI_SDK_DECIDE = new Set(["experimental_decide", "decide", "experimental_evaluate", "evaluate"]);
-var AI_SDK_AGENTS = new Set(["Agent", "Experimental_Agent", "ToolLoopAgent"]);
-var PROVIDER_MODULE = /^(?:@ai-sdk\/(?!react$|ui-utils$|rsc$|provider$|provider-utils$|svelte$|vue$|solid$|angular$|valibot$)[\w-]+|@openrouter\/ai-sdk-provider|workers-ai-provider|ollama-ai-provider(?:-v2)?|@requesty\/ai-sdk|@portkey-ai\/vercel-provider|@mistralai\/ai-sdk)$/;
-var MODEL_HOST = /^https?:\/\/(?:openrouter\.ai|api\.openai\.com|api\.anthropic\.com|generativelanguage\.googleapis\.com|api\.groq\.com|api\.together\.(?:xyz|ai)|api\.mistral\.ai|api\.deepseek\.com|api\.fireworks\.ai|api\.x\.ai|api\.perplexity\.ai|gateway\.ai\.cloudflare\.com)\//;
-var SPEECH_ENDPOINT = /^https?:\/\/api\.elevenlabs\.io\/v\d+\/(?:text-to-speech|speech-to-text|speech-to-speech|text-to-dialogue|sound-generation)\b/;
-var MODEL_PATH = /\/chat\/completions\b|\/v1\/messages\b|\/v1\/responses\b|:generateContent\b|:streamGenerateContent\b/;
-var FRAMEWORK_MODULE = /^(?:agents(?:\/.*)?|@cloudflare\/think|@cloudflare\/ai-chat|@cloudflare\/agents|cloudflare:workers|cloudflare:workflows)$/;
-var FRAMEWORK_BASES = new Set(["Think", "Agent", "AIChatAgent", "McpAgent", "DurableObject", "WorkflowEntrypoint", "AgentWorkflow"]);
-var HOOK_BASES = new Set(["Think", "Agent", "AIChatAgent", "McpAgent"]);
-var HOOK_METHODS = {
-  getModel: "model",
-  getTools: "tools",
-  getSystemPrompt: "system",
-  configureContext: "system",
-  getInstructions: "system",
-  instructions: "system",
-  system: "system",
-  systemPrompt: "system",
-  buildSystemPrompt: "system",
-  formatAgentToolInput: "messages"
-};
-var HOOK_PROPERTIES = { model: "model", systemPrompt: "system", instructions: "system", system: "system" };
-var TURN_HOOKS = new Set(["beforeTurn", "beforeStep", "prepareStep"]);
-var TURN_CONFIG_KEYS = { model: "model", system: "system", tools: "tools", messages: "messages" };
-function providerName(module) {
-  if (module === "ai" || module === "@ai-sdk/gateway")
-    return "ai-gateway";
-  if (module === "@openrouter/ai-sdk-provider")
-    return "openrouter";
-  if (module === "workers-ai-provider")
-    return "workers-ai";
-  if (module.startsWith("ollama-ai-provider"))
-    return "ollama";
-  const scoped = /^@[\w-]+\/(?:ai-sdk-)?([\w-]+)$/.exec(module);
-  return scoped ? scoped[1] : module;
-}
-function requestRoles(argument, keys, ctx) {
-  if (!argument)
-    return [];
-  const object = objectLiteralOf(argument, ctx.checker);
-  const roles = [];
-  if (object && unwrap(argument) === object) {
-    for (const [key, role] of Object.entries(keys)) {
-      const value = propertyValue(object, key);
-      if (value && !spreadAfter(object, key))
-        roles.push({ role, node: value });
-      else if ((value || !hasProperty(object, key)) && object.properties.some((property) => import_typescript5.default.isSpreadAssignment(property))) {
-        roles.push({ role, node: argument, key });
-      }
-    }
-    return dedupeRoles(roles);
-  }
-  for (const [key, role] of Object.entries(keys)) {
-    if (!object || hasProperty(object, key) || object.properties.some((property) => import_typescript5.default.isSpreadAssignment(property))) {
-      roles.push({ role, node: argument, key });
-    }
-  }
-  return dedupeRoles(roles);
-}
-function spreadAfter(object, key) {
-  let last = -1;
-  object.properties.forEach((property, index) => {
-    if (!import_typescript5.default.isSpreadAssignment(property) && property.name && propertyNameText(property.name) === key)
-      last = index;
-  });
-  return object.properties.some((property, index) => index > last && import_typescript5.default.isSpreadAssignment(property));
-}
-function dedupeRoles(roles) {
-  const seen = new Set;
-  return roles.filter((role) => {
-    if (seen.has(role.role))
-      return false;
-    seen.add(role.role);
-    return true;
-  });
-}
-function typeOrigin(type, checker) {
-  if (!type)
-    return;
-  if (import_typescript5.default.isUnionTypeNode(type) || import_typescript5.default.isIntersectionTypeNode(type)) {
-    for (const member of type.types) {
-      const origin = typeOrigin(member, checker);
-      if (origin)
-        return origin;
-    }
-    return;
-  }
-  if (import_typescript5.default.isTypeReferenceNode(type)) {
-    let name = type.typeName;
-    while (import_typescript5.default.isQualifiedName(name))
-      name = name.left;
-    return importOrigin(name, checker);
-  }
-  return;
-}
-function valueOrigin(expression, checker, depth = 0, seen = new Set) {
-  const expr = unwrap(expression);
-  if (depth > 6 || seen.has(expr))
-    return;
-  seen.add(expr);
-  if (import_typescript5.default.isNewExpression(expr) || import_typescript5.default.isCallExpression(expr)) {
-    const root = rootIdentifier(expr.expression);
-    const origin = root ? importOrigin(root, checker) : undefined;
-    if (origin)
-      return origin;
-    const fn = resolvedFunction(expr.expression, checker);
-    if (fn) {
-      const declared = typeOrigin(fn.type, checker);
-      if (declared)
-        return declared;
-      for (const ret of returnExpressions(fn)) {
-        const found = valueOrigin(ret, checker, depth + 1, seen);
-        if (found)
-          return found;
-      }
-    }
-    return;
-  }
-  let declaration;
-  if (import_typescript5.default.isIdentifier(expr)) {
-    const origin = importOrigin(expr, checker);
-    if (origin)
-      return origin;
-    declaration = valueDeclaration(resolvedSymbol(expr, checker));
-  } else if (import_typescript5.default.isPropertyAccessExpression(expr)) {
-    declaration = valueDeclaration(resolvedSymbol(expr.name, checker));
-  }
-  if (!declaration)
-    return;
-  if (import_typescript5.default.isVariableDeclaration(declaration) || import_typescript5.default.isPropertyDeclaration(declaration) || import_typescript5.default.isParameter(declaration) || import_typescript5.default.isPropertySignature(declaration) || import_typescript5.default.isPropertyAssignment(declaration)) {
-    const declared = "type" in declaration ? typeOrigin(declaration.type, checker) : undefined;
-    if (declared)
-      return declared;
-    const initializer = "initializer" in declaration ? declaration.initializer : undefined;
-    if (initializer)
-      return valueOrigin(initializer, checker, depth + 1, seen);
-    if (import_typescript5.default.isPropertyDeclaration(declaration)) {
-      const key = propertyNameText(declaration.name);
-      let found;
-      const visit = (node) => {
-        if (found)
-          return;
-        if (import_typescript5.default.isBinaryExpression(node) && node.operatorToken.kind === import_typescript5.default.SyntaxKind.EqualsToken && import_typescript5.default.isPropertyAccessExpression(node.left) && node.left.expression.kind === import_typescript5.default.SyntaxKind.ThisKeyword && node.left.name.text === key) {
-          found = valueOrigin(node.right, checker, depth + 1, seen);
-        }
-        import_typescript5.default.forEachChild(node, visit);
-      };
-      import_typescript5.default.forEachChild(declaration.parent, visit);
-      return found;
-    }
-  }
-  return;
-}
-function providerInstance(expression, checker, depth = 0) {
-  const expr = unwrap(expression);
-  if (depth > 6)
-    return;
-  if (import_typescript5.default.isIdentifier(expr)) {
-    const origin = importOrigin(expr, checker);
-    if (origin) {
-      if (origin.module === "ai" && origin.imported === "gateway")
-        return "ai";
-      return PROVIDER_MODULE.test(origin.module) && !/^create/.test(origin.imported) && origin.imported !== "*" ? origin.module : undefined;
-    }
-    const declaration = valueDeclaration(resolvedSymbol(expr, checker));
-    if (declaration && (import_typescript5.default.isVariableDeclaration(declaration) || import_typescript5.default.isPropertyDeclaration(declaration)) && declaration.initializer) {
-      const initializer = declaration.initializer;
-      return memoized(declaration, () => providerInstance(initializer, checker, depth + 1));
-    }
-    return;
-  }
-  if (import_typescript5.default.isPropertyAccessExpression(expr)) {
-    const declaration = valueDeclaration(resolvedSymbol(expr.name, checker));
-    if (declaration && (import_typescript5.default.isPropertyDeclaration(declaration) || import_typescript5.default.isPropertyAssignment(declaration) || import_typescript5.default.isVariableDeclaration(declaration)) && declaration.initializer) {
-      const initializer = declaration.initializer;
-      return memoized(declaration, () => providerInstance(initializer, checker, depth + 1));
-    }
-    return;
-  }
-  if (import_typescript5.default.isCallExpression(expr)) {
-    const root = rootIdentifier(expr.expression);
-    const origin = root ? importOrigin(root, checker) : undefined;
-    if (origin) {
-      if (PROVIDER_MODULE.test(origin.module) && /^create/.test(origin.imported))
-        return origin.module;
-      if (origin.module === "ai" && (origin.imported === "customProvider" || origin.imported === "createGateway"))
-        return "ai";
-      return;
-    }
-    const fn = resolvedFunction(expr.expression, checker);
-    if (fn) {
-      return memoized(fn, () => {
-        for (const ret of returnExpressions(fn)) {
-          const found = providerInstance(ret, checker, depth + 1);
-          if (found)
-            return found;
-        }
-        return;
-      });
-    }
-  }
-  return;
-}
-var providerMemo = new WeakMap;
-function memoized(node, compute) {
-  if (providerMemo.has(node))
-    return providerMemo.get(node) ?? undefined;
-  providerMemo.set(node, null);
-  const value = compute();
-  providerMemo.set(node, value ?? null);
-  return value;
-}
-var MODEL_METHOD = /model|chat|completion|responses|messages|image|embedding|speech|transcription/i;
-function providerModelCall(call, checker) {
-  const model = call.arguments[0];
-  if (!model || import_typescript5.default.isSpreadElement(model) || import_typescript5.default.isObjectLiteralExpression(unwrap(model)))
-    return;
-  const callee = unwrap(call.expression);
-  if (import_typescript5.default.isIdentifier(callee)) {
-    const module = providerInstance(callee, checker);
-    return module ? { module, model } : undefined;
-  }
-  if (import_typescript5.default.isPropertyAccessExpression(callee) && MODEL_METHOD.test(callee.name.text)) {
-    const module = providerInstance(callee.expression, checker);
-    return module ? { module, method: callee.name.text, model } : undefined;
-  }
-  return;
-}
-function chainEndsWith(chain, tail) {
-  if (!chain || chain.length <= tail.length)
+function looksLikeUiMessage(argument) {
+  const object = unwrap(argument);
+  if (!import_typescript3.default.isObjectLiteralExpression(object))
     return false;
-  return tail.every((part, index) => chain[chain.length - tail.length + index] === part);
-}
-function receiverOf(callee, tailLength) {
-  let current = unwrap(callee);
-  for (let index = 0;index < tailLength && import_typescript5.default.isPropertyAccessExpression(current); index += 1)
-    current = unwrap(current.expression);
-  return current;
+  const parts = propertyValue(object, "parts");
+  if (parts) {
+    const array = unwrap(parts);
+    return import_typescript3.default.isArrayLiteralExpression(array) && array.elements.some((element) => {
+      const part = unwrap(element);
+      if (!import_typescript3.default.isObjectLiteralExpression(part))
+        return false;
+      const type = propertyValue(part, "type");
+      return Boolean(type && import_typescript3.default.isStringLiteralLike(unwrap(type)) && unwrap(type).text === "text");
+    });
+  }
+  if (propertyValue(object, "text") && object.properties.length <= 3)
+    return true;
+  const role = propertyValue(object, "role");
+  return Boolean(role && import_typescript3.default.isStringLiteralLike(unwrap(role)) && unwrap(role).text === "user" && (propertyValue(object, "content") || propertyValue(object, "parts")));
 }
-var anthropicSink = {
-  id: "anthropic",
-  sdk: "anthropic",
+var clientChatSink = {
+  id: "client-chat",
+  sdk: "client-chat",
   match(call, ctx) {
-    if (!import_typescript5.default.isCallExpression(call))
-      return;
-    const chain = calleeChain(call.expression);
-    const tails = [["beta", "messages", "create"], ["beta", "messages", "stream"], ["messages", "create"], ["messages", "stream"]];
-    const tail = tails.find((candidate) => chainEndsWith(chain, candidate));
-    if (!tail || chain.includes("threads"))
+    if (!import_typescript3.default.isCallExpression(call) || call.arguments.length === 0)
       return;
-    const receiver = receiverOf(call.expression, tail.length);
-    const origin = valueOrigin(receiver, ctx.checker);
-    const request = call.arguments[0];
-    if (origin && !ANTHROPIC_MODULE.test(origin.module))
+    const callee = unwrap(call.expression);
+    const binding = import_typescript3.default.isIdentifier(callee) ? valueDeclaration(resolvedSymbol(callee, ctx.checker)) : undefined;
+    const bound = binding && import_typescript3.default.isBindingElement(binding) && binding.propertyName ? propertyNameText(binding.propertyName) : undefined;
+    const name = bound ?? (import_typescript3.default.isIdentifier(callee) ? callee.text : import_typescript3.default.isPropertyAccessExpression(callee) ? callee.name.text : undefined);
+    if (!name || !CHAT_SEND.has(name))
       return;
-    if (!origin) {
-      const object = objectLiteralOf(request, ctx.checker);
-      const receiverName = receiver.getText();
-      if (!object || !hasProperty(object, "model") || !hasProperty(object, "messages"))
-        return;
-      if (!/anthropic|claude|client|llm|openrouter/i.test(receiverName) && !hasProperty(object, "max_tokens"))
-        return;
-    }
-    return {
-      api: `anthropic.${tail.join(".")}`,
-      provider: "anthropic",
-      roles: requestRoles(request, { model: "model", system: "system", messages: "messages", tools: "tools" }, ctx)
-    };
-  }
-};
-var OPENAI_MODEL_ONLY_TAILS = [["embeddings", "create"], ["audio", "speech", "create"], ["audio", "transcriptions", "create"], ["audio", "translations", "create"], ["images", "generate"], ["images", "edit"]];
-function openaiModelOnly(call, chain, ctx) {
-  const tail = OPENAI_MODEL_ONLY_TAILS.find((candidate) => chainEndsWith(chain, candidate));
-  if (!tail)
-    return;
-  const origin = valueOrigin(receiverOf(call.expression, tail.length), ctx.checker);
-  const object = objectLiteralOf(call.arguments[0], ctx.checker);
-  if (origin ? !OPENAI_MODULE.test(origin.module) : !object || !hasProperty(object, "model"))
-    return;
-  return { api: `openai.${tail.join(".")}`, provider: "openai", roles: requestRoles(call.arguments[0], { model: "model" }, ctx) };
-}
-var openaiSink = {
-  id: "openai",
-  sdk: "openai",
-  match(call, ctx) {
-    if (!import_typescript5.default.isCallExpression(call))
+    const argument = call.arguments[0];
+    if (import_typescript3.default.isSpreadElement(argument))
       return;
-    const chain = calleeChain(call.expression);
-    const tails = [["chat", "completions", "create"], ["chat", "completions", "parse"], ["chat", "completions", "stream"], ["responses", "create"], ["responses", "stream"], ["responses", "parse"]];
-    const tail = tails.find((candidate) => chainEndsWith(chain, candidate));
-    if (!tail)
-      return openaiModelOnly(call, chain, ctx);
-    const receiver = receiverOf(call.expression, tail.length);
-    const origin = valueOrigin(receiver, ctx.checker);
-    if (origin && !OPENAI_MODULE.test(origin.module) && !(tail[0] === "chat" && !ANTHROPIC_MODULE.test(origin.module)))
+    const hooked = import_typescript3.default.isIdentifier(callee) ? fromChatHook(callee, ctx.checker) : fromChatHook(callee.expression, ctx.checker);
+    if (!hooked && !((name === "sendMessage" || name === "append") && looksLikeUiMessage(argument)))
       return;
-    const request = call.arguments[0];
-    if (!origin && tail[0] === "responses") {
-      const object = objectLiteralOf(request, ctx.checker);
-      if (!object || !hasProperty(object, "model") || !(hasProperty(object, "input") || hasProperty(object, "instructions")))
-        return;
-    }
-    return {
-      api: `openai.${tail.join(".")}`,
-      provider: !origin || OPENAI_MODULE.test(origin.module) ? "openai" : OPENAI_COMPATIBLE_MODULE.test(origin.module) ? providerName(origin.module).replace(/-sdk$|_cloud_sdk$|-ai$/, "") : providerName(origin.module),
-      roles: requestRoles(request, { model: "model", messages: "messages", input: "messages", instructions: "instructions", tools: "tools", functions: "tools" }, ctx)
-    };
+    return { api: `chat.${name}`, roles: [{ role: "user", node: argument }] };
   }
 };
-var aiSdkSink = {
-  id: "ai-sdk",
-  sdk: "ai-sdk",
+var websocketSink = {
+  id: "websocket",
+  sdk: "websocket",
   match(call, ctx) {
-    const callee = unwrap(call.expression);
-    const nameNode = import_typescript5.default.isPropertyAccessExpression(callee) ? callee.name : import_typescript5.default.isIdentifier(callee) ? callee : undefined;
-    const root = rootIdentifier(callee);
-    if (!nameNode || !root)
+    if (!import_typescript3.default.isNewExpression(call) || !call.arguments?.length)
       return;
-    const origin = importOrigin(root, ctx.checker);
-    if (!origin || origin.module !== "ai")
+    const callee = unwrap(call.expression);
+    if (!import_typescript3.default.isIdentifier(callee) || callee.text !== "WebSocket")
       return;
-    const name = origin.imported === "*" ? nameNode.text : origin.imported;
-    if (!import_typescript5.default.isNewExpression(call) && AI_SDK_DECIDE.has(name)) {
-      return { api: `ai.${name}`, roles: requestRoles(call.arguments[0], { model: "model", questions: "questions", criteria: "questions" }, ctx) };
-    }
-    const known = import_typescript5.default.isNewExpression(call) ? AI_SDK_AGENTS.has(name) : AI_SDK_CALLS.has(name);
-    if (!known)
+    const url = ctx.urlTexts(call.arguments[0]).find((candidate) => MODEL_SOCKET.test(candidate));
+    if (!url)
       return;
+    const modelInUrl = urlModel(call.arguments[0], ctx.checker);
+    const roles = modelInUrl ? [{ role: "model", node: modelInUrl }] : /[?&]model=/.test(url) ? [{ role: "model", node: call.arguments[0], key: URL_MODEL_KEY }] : [];
     return {
-      api: `ai.${name}`,
-      roles: requestRoles(call.arguments?.[0], { model: "model", system: "system", instructions: "instructions", prompt: "prompt", messages: "messages", tools: "tools" }, ctx)
+      api: "websocket",
+      provider: /openai/.test(url) ? "openai" : /generativelanguage/.test(url) ? "google" : undefined,
+      roles
     };
   }
 };
-var providerFactorySink = {
-  id: "provider-factory",
-  sdk: "provider-factory",
-  match(call, ctx) {
-    if (!import_typescript5.default.isCallExpression(call))
+function frameworkName(identifier, checker, member) {
+  if (!identifier)
+    return;
+  const origin = importOrigin(identifier, checker);
+  if (origin) {
+    const name = origin.imported === "*" || origin.imported === "default" ? member ?? identifier.text : origin.imported;
+    return FRAMEWORK_MODULE.test(origin.module) && FRAMEWORK_BASES.has(name) ? { base: name, module: origin.module } : undefined;
+  }
+  return;
+}
+function frameworkBaseOf(cls, checker, memo, depth = 0) {
+  const cached = memo.get(cls);
+  if (cached)
+    return cached;
+  const self = className(cls) ?? "(anonymous)";
+  const result = { chain: [self] };
+  memo.set(cls, result);
+  const heritage = cls.heritageClauses?.find((clause) => clause.token === import_typescript3.default.SyntaxKind.ExtendsKeyword)?.types[0];
+  if (!heritage || depth > 8)
+    return result;
+  const resolveExpression = (expression) => {
+    const expr = unwrap(expression);
+    if (import_typescript3.default.isCallExpression(expr)) {
+      for (const argument of expr.arguments) {
+        const found = resolveExpression(argument);
+        if (found?.base)
+          return found;
+      }
       return;
-    const found = providerModelCall(call, ctx.checker);
-    if (!found)
+    }
+    const identifier = import_typescript3.default.isIdentifier(expr) ? expr : import_typescript3.default.isPropertyAccessExpression(expr) ? rootIdentifier(expr) : undefined;
+    const member = import_typescript3.default.isPropertyAccessExpression(expr) ? expr.name.text : undefined;
+    const direct = frameworkName(identifier, checker, member);
+    if (direct)
+      return { ...direct, chain: [direct.base] };
+    const declaration = valueDeclaration(resolvedSymbol(import_typescript3.default.isPropertyAccessExpression(expr) ? expr.name : expr, checker));
+    if (!declaration)
       return;
-    const provider = providerName(found.module);
-    return { api: `${provider}${found.method ? `.${found.method}` : ""}(model)`, provider, roles: [{ role: "model", node: found.model }] };
+    if (import_typescript3.default.isClassDeclaration(declaration) || import_typescript3.default.isClassExpression(declaration))
+      return frameworkBaseOf(declaration, checker, memo, depth + 1);
+    const holder = import_typescript3.default.isBindingElement(declaration) ? declaration.parent.parent : declaration;
+    const name = import_typescript3.default.isBindingElement(declaration) ? propertyNameText(declaration.propertyName ?? declaration.name) : undefined;
+    if (import_typescript3.default.isVariableDeclaration(holder) && holder.initializer) {
+      const init = unwrap(holder.initializer);
+      if (import_typescript3.default.isClassExpression(init))
+        return frameworkBaseOf(init, checker, memo, depth + 1);
+      if (import_typescript3.default.isCallExpression(init)) {
+        for (const argument of init.arguments) {
+          const arg = unwrap(argument);
+          if (!import_typescript3.default.isIdentifier(arg))
+            continue;
+          const found = frameworkName(arg, checker, name);
+          if (found)
+            return { ...found, chain: [found.base] };
+          const nested = resolveExpression(arg);
+          if (nested?.base)
+            return nested;
+        }
+      }
+      if (import_typescript3.default.isIdentifier(init) || import_typescript3.default.isPropertyAccessExpression(init))
+        return resolveExpression(init);
+    }
+    return;
+  };
+  const parent = resolveExpression(heritage.expression);
+  if (parent) {
+    result.base = parent.base;
+    result.module = parent.module;
+    result.chain = [self, ...parent.chain];
+  } else {
+    result.chain = [self, heritage.expression.getText()];
   }
-};
-var WORKERS_AI_MODEL = /^@(?:cf|hf)\/[\w.-]+\/[\w.:-]+$/;
-function isWorkersAiBinding(callee, checker) {
-  const target = unwrap(callee);
-  if (!import_typescript5.default.isPropertyAccessExpression(target))
+  return result;
+}
+function returnedField(expr, key, checker, seen = new Set, depth = 0) {
+  expr = unwrap(expr);
+  if (depth > 8 || seen.has(expr))
     return false;
-  const receiver = unwrap(target.expression);
-  const declaration = import_typescript5.default.isIdentifier(receiver) || import_typescript5.default.isPropertyAccessExpression(receiver) ? valueDeclaration(resolvedSymbol(import_typescript5.default.isIdentifier(receiver) ? receiver : receiver.name, checker)) : undefined;
-  const type = declaration && (import_typescript5.default.isParameter(declaration) || import_typescript5.default.isVariableDeclaration(declaration) || import_typescript5.default.isPropertyDeclaration(declaration) || import_typescript5.default.isPropertySignature(declaration)) ? declaration.type : undefined;
-  return Boolean(type && import_typescript5.default.isTypeReferenceNode(type) && type.typeName.getText() === "Ai");
+  const next = new Set(seen).add(expr);
+  const visit = (value) => returnedField(value, key, checker, next, depth + 1);
+  if (import_typescript3.default.isObjectLiteralExpression(expr)) {
+    return hasProperty(expr, key) || expr.properties.some((property) => import_typescript3.default.isSpreadAssignment(property) && visit(property.expression));
+  }
+  if (import_typescript3.default.isConditionalExpression(expr))
+    return visit(expr.whenTrue) || visit(expr.whenFalse);
+  if (import_typescript3.default.isBinaryExpression(expr) && [import_typescript3.default.SyntaxKind.BarBarToken, import_typescript3.default.SyntaxKind.AmpersandAmpersandToken, import_typescript3.default.SyntaxKind.QuestionQuestionToken].includes(expr.operatorToken.kind)) {
+    return visit(expr.left) || visit(expr.right);
+  }
+  if (import_typescript3.default.isCallExpression(expr)) {
+    const fn = resolvedFunction(expr.expression, checker);
+    return !!fn && returnExpressions(fn).some(visit);
+  }
+  if (import_typescript3.default.isIdentifier(expr) || import_typescript3.default.isPropertyAccessExpression(expr)) {
+    const declaration = valueDeclaration(resolvedSymbol(expr, checker));
+    if (declaration && (import_typescript3.default.isVariableDeclaration(declaration) || import_typescript3.default.isPropertyDeclaration(declaration) || import_typescript3.default.isPropertyAssignment(declaration)) && declaration.initializer) {
+      return visit(declaration.initializer);
+    }
+  }
+  return false;
 }
-var workersAiSink = {
-  id: "workers-ai",
-  sdk: "workers-ai",
+function hookSink(memo) {
+  return {
+    id: "think-hook",
+    sdk: "think-hook",
+    match(cls, ctx) {
+      const info = frameworkBaseOf(cls, ctx.checker, memo);
+      if (!info.base || !HOOK_BASES.has(info.base))
+        return [];
+      const roles = [];
+      for (const member of cls.members) {
+        const name = propertyNameText(member.name);
+        if (!name || import_typescript3.default.getCombinedModifierFlags(member) & import_typescript3.default.ModifierFlags.Static)
+          continue;
+        if ((import_typescript3.default.isMethodDeclaration(member) || import_typescript3.default.isGetAccessorDeclaration(member)) && HOOK_METHODS[name] && member.body) {
+          roles.push({ role: HOOK_METHODS[name], node: member, values: returnExpressions(member) });
+        } else if (import_typescript3.default.isMethodDeclaration(member) && TURN_HOOKS.has(name) && member.body) {
+          const returns = returnExpressions(member);
+          for (const [key, role] of Object.entries(TURN_CONFIG_KEYS)) {
+            if (returns.some((ret) => returnedField(ret, key, ctx.checker))) {
+              roles.push({ role, node: member, values: returns, key });
+            }
+          }
+        } else if (import_typescript3.default.isPropertyDeclaration(member) && HOOK_PROPERTIES[name] && member.initializer) {
+          roles.push({ role: HOOK_PROPERTIES[name], node: member.initializer });
+        }
+      }
+      if (roles.length === 0)
+        return [];
+      return [{ api: `${info.base === "Think" ? "think" : "agents"}.hook`, roles, anchor: cls.name ?? cls }];
+    }
+  };
+}
+function createFrameworkMemo() {
+  return new Map;
+}
+var HOSTED_MODEL_SDKS = [
+  { module: /^@fal-ai\/(?:client|serverless-client)$/, methods: new Set(["run", "subscribe", "stream"]), provider: "fal" },
+  { module: /^replicate$/, methods: new Set(["run", "stream"]), provider: "replicate" }
+];
+var hostedModelSink = {
+  id: "hosted-model",
+  sdk: "hosted-model",
   match(call, ctx) {
-    if (!import_typescript5.default.isCallExpression(call))
+    if (!import_typescript3.default.isCallExpression(call) || call.arguments.length === 0)
       return;
-    const chain = calleeChain(call.expression);
-    if (!chain || chain[chain.length - 1] !== "run" || call.arguments.length === 0)
+    const callee = unwrap(call.expression);
+    if (!import_typescript3.default.isPropertyAccessExpression(callee))
       return;
-    const [model, input] = call.arguments;
-    if (!chainEndsWith(chain, ["AI", "run"]) && !isWorkersAiBinding(call.expression, ctx.checker) && !ctx.urlTexts(model).some((text) => WORKERS_AI_MODEL.test(text)))
+    const origin = valueOrigin(callee.expression, ctx.checker);
+    const sdk = origin && HOSTED_MODEL_SDKS.find((candidate) => candidate.module.test(origin.module) && candidate.methods.has(callee.name.text));
+    if (!sdk)
       return;
+    const [model, options] = call.arguments;
+    const input = options ? objectLiteralOf(options, ctx.checker) : undefined;
+    const inner = input ? propertyValue(input, "input") : undefined;
     return {
-      api: "workers-ai.AI.run",
-      provider: "workers-ai",
-      roles: [{ role: "model", node: model }, ...requestRoles(input, { messages: "messages", prompt: "prompt", tools: "tools" }, ctx)]
+      api: `${sdk.provider}.${callee.name.text}`,
+      provider: sdk.provider,
+      roles: [{ role: "model", node: model }, ...inner ? requestRoles(inner, { prompt: "prompt" }, ctx) : []]
     };
   }
 };
-var REQUEST_KEYS = { model: "model", model_id: "model", system: "system", messages: "messages", input: "messages", instructions: "instructions", prompt: "prompt", tools: "tools" };
-var OPAQUE_BODY_KEYS = { model: "model", system: "system", messages: "messages", tools: "tools" };
-var FETCH_LIKE = /fetch|request|post/i;
-var NON_MODEL_PATH = /\/models\/?(?:\?|$|`)|\/generation\b|\/credits\b|\/auth\/|\/keys?\b|\/embeddings\b|\/files\b/;
-function bodyHasModel(init, checker) {
-  const body = init ? propertyValue(init, "body") : undefined;
-  let payload = body ? unwrap(body) : undefined;
-  if (payload && import_typescript5.default.isCallExpression(payload) && payload.arguments[0])
-    payload = payload.arguments[0];
-  const object = objectLiteralOf(payload, checker);
-  return Boolean(object && hasProperty(object, "model"));
-}
-function urlTemplate(expression, checker, depth = 0) {
-  const expr = unwrap(expression);
-  if (import_typescript5.default.isTemplateExpression(expr))
-    return expr;
-  if (depth < 3 && import_typescript5.default.isIdentifier(expr)) {
-    const declaration = valueDeclaration(resolvedSymbol(expr, checker));
-    if (declaration && import_typescript5.default.isVariableDeclaration(declaration) && declaration.initializer)
-      return urlTemplate(declaration.initializer, checker, depth + 1);
+var REALTIME_SEND = /send|emit|transmit|dispatch/i;
+var realtimeEventSink = {
+  id: "realtime-event",
+  sdk: "realtime",
+  match(call, ctx) {
+    if (!import_typescript3.default.isCallExpression(call) || call.arguments.length !== 1)
+      return;
+    const callee = import_typescript3.default.isPropertyAccessExpression(call.expression) ? call.expression.name : call.expression;
+    if (!import_typescript3.default.isIdentifier(callee) || !REALTIME_SEND.test(callee.text))
+      return;
+    let sent = unwrap(call.arguments[0]);
+    if (import_typescript3.default.isCallExpression(sent) && sent.expression.getText() === "JSON.stringify" && sent.arguments[0])
+      sent = unwrap(sent.arguments[0]);
+    const argument = objectLiteralOf(sent, ctx.checker);
+    if (!argument)
+      return;
+    const type = propertyValue(argument, "type");
+    const kind = type && (import_typescript3.default.isStringLiteral(type) || import_typescript3.default.isNoSubstitutionTemplateLiteral(type)) ? type.text : undefined;
+    if (kind === "session.update") {
+      const session = propertyValue(argument, "session");
+      const object = session ? objectLiteralOf(session, ctx.checker) : undefined;
+      const instructions = object ? propertyValue(object, "instructions") : undefined;
+      return instructions ? { api: "realtime.session.update", provider: "openai", roles: [{ role: "system", node: instructions }] } : undefined;
+    }
+    if (kind === "conversation.item.create") {
+      const item = propertyValue(argument, "item");
+      const object = item ? objectLiteralOf(item, ctx.checker) : undefined;
+      const role = object ? propertyValue(object, "role") : undefined;
+      const roleText = role && import_typescript3.default.isStringLiteral(role) ? role.text : undefined;
+      const content = object ? propertyValue(object, "content") : undefined;
+      if (!content || roleText !== "system" && roleText !== "user")
+        return;
+      return { api: "realtime.conversation.item.create", provider: "openai", roles: [{ role: roleText === "system" ? "system" : "messages", node: content }] };
+    }
+    return;
   }
-  return;
+};
+function effectiveField(object, key) {
+  let last = -1;
+  object.properties.forEach((property, index) => {
+    if (!import_typescript3.default.isSpreadAssignment(property) && propertyNameText(property.name) === key)
+      last = index;
+  });
+  const fields = [];
+  const value = last >= 0 ? propertyValue(object, key) : undefined;
+  if (value)
+    fields.push({ node: value });
+  object.properties.forEach((property, index) => {
+    if (index > last && import_typescript3.default.isSpreadAssignment(property))
+      fields.push({ node: property.expression, key });
+  });
+  return fields;
 }
-var MODEL_SOCKET = /^wss:\/\/(?:api\.openai\.com\/v1\/realtime|[\w.-]+\.openai\.azure\.com\/openai\/realtime|generativelanguage\.googleapis\.com\/ws\/[\w.]+BidiGenerateContent|gateway\.ai\.cloudflare\.com\/)/;
-function urlModel(url, checker) {
-  const template = urlTemplate(url, checker);
-  if (!template)
+var WRITTEN_SYMBOLS = new WeakMap;
+function writtenSymbols(file, checker) {
+  let written = WRITTEN_SYMBOLS.get(file);
+  if (written)
+    return written;
+  const found = new Set;
+  const add = (node) => {
+    const root = rootIdentifier(node);
+    const symbol = root ? resolvedSymbol(root, checker) : undefined;
+    if (symbol)
+      found.add(symbol);
+  };
+  const visit = (node) => {
+    if (import_typescript3.default.isBinaryExpression(node) && node.operatorToken.kind >= import_typescript3.default.SyntaxKind.FirstAssignment && node.operatorToken.kind <= import_typescript3.default.SyntaxKind.LastAssignment)
+      add(node.left);
+    else if (import_typescript3.default.isDeleteExpression(node))
+      add(node.expression);
+    else if ((import_typescript3.default.isPrefixUnaryExpression(node) || import_typescript3.default.isPostfixUnaryExpression(node)) && (node.operator === import_typescript3.default.SyntaxKind.PlusPlusToken || node.operator === import_typescript3.default.SyntaxKind.MinusMinusToken))
+      add(node.operand);
+    else if (import_typescript3.default.isCallExpression(node) && node.arguments.length > 0) {
+      const callee = unwrap(node.expression);
+      if (import_typescript3.default.isPropertyAccessExpression(callee) && callee.name.text === "assign")
+        add(node.arguments[0]);
+    }
+    import_typescript3.default.forEachChild(node, visit);
+  };
+  visit(file);
+  written = found;
+  WRITTEN_SYMBOLS.set(file, written);
+  return written;
+}
+function gatewayRequestLiteral(argument, checker) {
+  const value = unwrap(argument);
+  if (import_typescript3.default.isObjectLiteralExpression(value))
+    return value;
+  if (!import_typescript3.default.isIdentifier(value))
     return;
-  let before = template.head.text;
-  for (const span of template.templateSpans) {
-    if (/\/models\/$/.test(before) && /^[:/?#]/.test(span.literal.text) || /[?&]model=$/.test(before) && /^(?:[&#]|$)/.test(span.literal.text))
-      return span.expression;
-    before = span.literal.text;
-  }
-  return;
+  const symbol = resolvedSymbol(value, checker);
+  const declaration = valueDeclaration(symbol);
+  if (!symbol || !declaration || !import_typescript3.default.isVariableDeclaration(declaration) || !declaration.initializer)
+    return;
+  if (!(import_typescript3.default.getCombinedNodeFlags(declaration) & import_typescript3.default.NodeFlags.Const))
+    return;
+  const literal = unwrap(declaration.initializer);
+  if (!import_typescript3.default.isObjectLiteralExpression(literal))
+    return;
+  return writtenSymbols(declaration.getSourceFile(), checker).has(symbol) ? undefined : literal;
 }
-var fetchSink = {
-  id: "fetch",
-  sdk: "fetch",
+var GATEWAY_METHODS = new Set(["call", "stream"]);
+var GATEWAY_BODY_KEYS = { system: "system", messages: "messages", prompt: "prompt", model: "model", tools: "tools" };
+var modelGatewaySink = {
+  id: "model-gateway",
+  sdk: "model-gateway",
   match(call, ctx) {
-    if (!import_typescript5.default.isCallExpression(call) || call.arguments.length < 2)
+    if (!import_typescript3.default.isCallExpression(call) || call.arguments.length !== 1)
       return;
     const callee = unwrap(call.expression);
-    const calleeText = import_typescript5.default.isCallExpression(callee) ? callee.expression.getText() : callee.getText();
-    if (!FETCH_LIKE.test(calleeText))
+    if (!import_typescript3.default.isPropertyAccessExpression(callee) || !GATEWAY_METHODS.has(callee.name.text))
       return;
-    if (import_typescript5.default.isIdentifier(callee) && callee.text === "fetch" && resolvedFunction(callee, ctx.checker))
-      return;
-    const second = unwrap(call.arguments[1]);
-    if (import_typescript5.default.isArrowFunction(second) || import_typescript5.default.isFunctionExpression(second))
-      return;
-    const first = unwrap(call.arguments[0]);
-    if ((import_typescript5.default.isStringLiteral(first) || import_typescript5.default.isNoSubstitutionTemplateLiteral(first)) && !MODEL_HOST.test(first.text) && !MODEL_PATH.test(first.text) && !SPEECH_ENDPOINT.test(first.text))
+    const receiver = unwrap(callee.expression);
+    if (!import_typescript3.default.isPropertyAccessExpression(receiver) || receiver.name.text !== "models")
       return;
-    const urls = ctx.urlTexts(call.arguments[0]);
-    const initArg = call.arguments[1];
-    const init = objectLiteralOf(initArg, ctx.checker);
-    const url = urls.find((candidate) => SPEECH_ENDPOINT.test(candidate) || !NON_MODEL_PATH.test(candidate) && (MODEL_HOST.test(candidate) || MODEL_PATH.test(candidate) && (/^https?:\/\//.test(candidate) || bodyHasModel(init, ctx.checker))));
-    if (!url)
+    const request = gatewayRequestLiteral(call.arguments[0], ctx.checker);
+    if (!request || !propertyValue(request, "kind"))
       return;
     const roles = [];
-    if (init) {
-      const body = propertyValue(init, "body");
-      let payload = body ? unwrap(body) : undefined;
-      if (payload && import_typescript5.default.isCallExpression(payload) && calleeChain(payload.expression)?.join(".") === "JSON.stringify")
-        payload = payload.arguments[0];
-      if (payload)
-        roles.push(...requestRoles(payload, REQUEST_KEYS, ctx));
-    } else {
-      for (const [key, role] of Object.entries(OPAQUE_BODY_KEYS))
-        roles.push({ role, node: initArg, key: `body.${key}` });
+    for (const body of effectiveField(request, "body")) {
+      for (const [key, role] of Object.entries(GATEWAY_BODY_KEYS)) {
+        if (body.key) {
+          roles.push({ role, node: body.node, key: `${body.key}.${key}` });
+          continue;
+        }
+        const literal = unwrap(body.node);
+        if (!import_typescript3.default.isObjectLiteralExpression(literal)) {
+          roles.push({ role, node: body.node, key });
+          continue;
+        }
+        for (const field of effectiveField(literal, key))
+          roles.push({ role, ...field });
+      }
+    }
+    for (const field of effectiveField(request, "prompt"))
+      roles.push({ role: "prompt", ...field });
+    return roles.length > 0 ? { api: `models.${callee.name.text}`, roles } : undefined;
+  }
+};
+var CALL_SINKS = [modelGatewaySink, realtimeEventSink, anthropicSink, openaiSink, aiSdkSink, workersAiSink, fetchSink, websocketSink, providerFactorySink, agentEntrySink, clientChatSink, hostedModelSink];
+function registerCallSink(recognizer) {
+  CALL_SINKS.push(recognizer);
+}
+function classSinks(memo) {
+  return [hookSink(memo), ...EXTRA_CLASS_SINKS];
+}
+var EXTRA_CLASS_SINKS = [];
+function registerClassSink(recognizer) {
+  EXTRA_CLASS_SINKS.push(recognizer);
+}
+
+// src/harness-extract/calls.ts
+class CallIndex {
+  program;
+  checker;
+  byName;
+  aliases = new Map;
+  members = new Map;
+  checkingDefaults = new Set;
+  constructor(program, checker) {
+    this.program = program;
+    this.checker = checker;
+  }
+  build() {
+    const byName = new Map;
+    for (const source of this.program.getSourceFiles()) {
+      if (source.isDeclarationFile || /[\\/]node_modules[\\/]/.test(source.fileName))
+        continue;
+      const imported = importAliases(source);
+      const visit = (node) => {
+        if ((import_typescript4.default.isParameter(node) || import_typescript4.default.isVariableDeclaration(node)) && node.initializer && import_typescript4.default.isIdentifier(node.name)) {
+          let init = unwrap(node.initializer);
+          if (import_typescript4.default.isBinaryExpression(init) && (init.operatorToken.kind === import_typescript4.default.SyntaxKind.QuestionQuestionToken || init.operatorToken.kind === import_typescript4.default.SyntaxKind.BarBarToken))
+            init = unwrap(init.right);
+          if (import_typescript4.default.isIdentifier(init)) {
+            const entry = { declaration: node, target: init };
+            const list = this.aliases.get(init.text);
+            if (list)
+              list.push(entry);
+            else
+              this.aliases.set(init.text, [entry]);
+          }
+        }
+        if ((import_typescript4.default.isPropertyAssignment(node) || import_typescript4.default.isShorthandPropertyAssignment(node)) && import_typescript4.default.isObjectLiteralExpression(node.parent)) {
+          const value = import_typescript4.default.isShorthandPropertyAssignment(node) ? node.name : unwrap(node.initializer);
+          const property = import_typescript4.default.isIdentifier(node.name) || import_typescript4.default.isStringLiteral(node.name) ? node.name.text : undefined;
+          if (property && import_typescript4.default.isIdentifier(value)) {
+            const entry = { property, literal: node.parent, target: value };
+            const list = this.members.get(value.text);
+            if (list)
+              list.push(entry);
+            else
+              this.members.set(value.text, [entry]);
+          }
+        }
+        if (import_typescript4.default.isCallExpression(node)) {
+          const callee = unwrap(node.expression);
+          const name = import_typescript4.default.isIdentifier(callee) ? callee.text : import_typescript4.default.isPropertyAccessExpression(callee) ? callee.name.text : undefined;
+          if (name) {
+            const original = import_typescript4.default.isIdentifier(callee) ? imported.get(name) : undefined;
+            for (const key of original && original !== name ? [name, original] : [name]) {
+              const list = byName.get(key);
+              if (list)
+                list.push(node);
+              else
+                byName.set(key, [node]);
+            }
+          }
+        }
+        import_typescript4.default.forEachChild(node, visit);
+      };
+      visit(source);
+    }
+    return byName;
+  }
+  callersOf(fn, name, limit, within) {
+    const all = this.allCallersOf(fn, name, within ? Number.MAX_SAFE_INTEGER : limit);
+    if (!within)
+      return all;
+    return all.filter((call) => within.getSourceFile(call.getSourceFile().fileName) === call.getSourceFile()).slice(0, limit);
+  }
+  allCallersOf(fn, name, limit) {
+    this.byName ??= this.build();
+    const signatures = contextualSignatures(fn, name, this.checker);
+    const out = this.direct(name, limit, (declaration, call) => declares(declaration, fn) || signatures.has(declaration) && contextualReceiverMatches(call, fn, this.checker));
+    if (isDefaultExport(fn) && name !== "default" && out.length < limit)
+      out.push(...this.direct("default", limit - out.length, (declaration) => declares(declaration, fn), new Set(out)));
+    for (const alias of this.aliases.get(name) ?? []) {
+      if (out.length >= limit)
+        break;
+      const symbol = resolvedSymbol(alias.target, this.checker);
+      if (!symbol?.declarations?.some((declaration) => declares(declaration, fn)))
+        continue;
+      if (!this.defaultCanApply(alias.declaration))
+        continue;
+      const aliasName = alias.declaration.name.text;
+      out.push(...this.direct(aliasName, limit - out.length, (declaration) => declaration === alias.declaration));
     }
-    const modelInUrl = urlModel(call.arguments[0], ctx.checker);
-    if (modelInUrl && !roles.some((role) => role.role === "model"))
-      roles.unshift({ role: "model", node: modelInUrl });
-    if (modelInUrl) {
-      const index = roles.findIndex((role) => role.role === "model" && role.key?.startsWith("body."));
-      if (index >= 0)
-        roles[index] = { role: "model", node: modelInUrl };
+    for (const member of this.members.get(name) ?? []) {
+      if (out.length >= limit)
+        break;
+      const symbol = resolvedSymbol(member.target, this.checker);
+      if (!symbol?.declarations?.some((declaration) => declares(declaration, fn)))
+        continue;
+      for (const param of this.holders(member.literal)) {
+        out.push(...this.memberCalls(param, member.property, limit - out.length));
+      }
     }
-    return {
-      api: "fetch",
-      provider: /elevenlabs/.test(url) ? "elevenlabs" : /anthropic/.test(url) ? "anthropic" : /openrouter/.test(url) ? "openrouter" : /openai/.test(url) ? "openai" : /generativelanguage/.test(url) ? "google" : undefined,
-      roles
-    };
-  }
-};
-var AGENT_ENTRY_METHODS = new Set(["run", "executeRun", "chat", "saveMessages", "sendMessage", "submitMessage", "prompt", "runAgentTool"]);
-var AGENT_BASES = new Set(["Think", "Agent", "AIChatAgent"]);
-var ENTRY_FIELDS = ["message", "context", "brief"];
-var STUB_GETTERS = new Set(["get", "getByName", "getAgentByName", "getServerByName", "routeAgentRequest", "getStub"]);
-function classOfDeclaration(declaration) {
-  if (!declaration)
-    return;
-  if (import_typescript5.default.isClassDeclaration(declaration) || import_typescript5.default.isClassExpression(declaration))
-    return declaration;
-  return;
-}
-function classesInType(type, checker, out = []) {
-  if (!type || out.length > 4)
     return out;
-  if (import_typescript5.default.isTypeReferenceNode(type)) {
-    const name = import_typescript5.default.isQualifiedName(type.typeName) ? type.typeName.right : type.typeName;
-    const cls = classOfDeclaration(valueDeclaration(resolvedSymbol(name, checker)));
-    if (cls)
-      out.push(cls);
-    for (const argument of type.typeArguments ?? [])
-      classesInType(argument, checker, out);
-  } else if (import_typescript5.default.isUnionTypeNode(type) || import_typescript5.default.isIntersectionTypeNode(type)) {
-    for (const member of type.types)
-      classesInType(member, checker, out);
   }
-  return out;
-}
-function receiverClasses(expression, checker, depth = 0) {
-  const expr = unwrap(expression);
-  if (depth > 4)
-    return [];
-  if (expr.kind === import_typescript5.default.SyntaxKind.ThisKeyword) {
-    for (let current = expr.parent;current; current = current.parent) {
-      if (import_typescript5.default.isClassDeclaration(current) || import_typescript5.default.isClassExpression(current))
-        return [current];
+  holders(literal) {
+    let node = literal;
+    while (node.parent && (import_typescript4.default.isParenthesizedExpression(node.parent) || import_typescript4.default.isAsExpression(node.parent) || import_typescript4.default.isSatisfiesExpression(node.parent)))
+      node = node.parent;
+    const parent = node.parent;
+    const out = [];
+    if (parent && import_typescript4.default.isCallExpression(parent)) {
+      const index = parent.arguments.indexOf(node);
+      const fn = index >= 0 ? resolvedFunction(parent.expression, this.checker) : undefined;
+      if (fn && fn.parameters[index])
+        out.push(fn.parameters[index]);
+    } else if (parent && import_typescript4.default.isParameter(parent) && parent.initializer === node) {
+      out.push(parent);
+    } else if (parent && import_typescript4.default.isVariableDeclaration(parent) && parent.initializer === node && import_typescript4.default.isIdentifier(parent.name)) {
+      for (const alias of this.aliases.get(parent.name.text) ?? []) {
+        if (import_typescript4.default.isParameter(alias.declaration) && valueDeclaration(resolvedSymbol(alias.target, this.checker)) === parent)
+          out.push(alias.declaration);
+      }
     }
-    return [];
+    return out;
   }
-  if (import_typescript5.default.isNewExpression(expr)) {
-    const cls = classOfDeclaration(valueDeclaration(resolvedSymbol(import_typescript5.default.isPropertyAccessExpression(expr.expression) ? expr.expression.name : expr.expression, checker)));
-    return cls ? [cls] : [];
+  memberCalls(param, property, limit) {
+    const out = [];
+    for (const call of this.byName.get(property) ?? []) {
+      if (out.length >= limit)
+        break;
+      const callee = unwrap(call.expression);
+      if (import_typescript4.default.isPropertyAccessExpression(callee)) {
+        const receiver = unwrap(callee.expression);
+        if (import_typescript4.default.isIdentifier(receiver) && valueDeclaration(resolvedSymbol(receiver, this.checker)) === param)
+          out.push(call);
+      } else if (import_typescript4.default.isIdentifier(callee)) {
+        const declaration = valueDeclaration(resolvedSymbol(callee, this.checker));
+        if (!declaration || !import_typescript4.default.isBindingElement(declaration))
+          continue;
+        const holder = declaration.parent.parent;
+        const init = import_typescript4.default.isVariableDeclaration(holder) && holder.initializer ? unwrap(holder.initializer) : undefined;
+        if (holder === param || init && import_typescript4.default.isIdentifier(init) && valueDeclaration(resolvedSymbol(init, this.checker)) === param)
+          out.push(call);
+      }
+    }
+    return out;
   }
-  if (import_typescript5.default.isCallExpression(expr)) {
-    const callee = unwrap(expr.expression);
-    const name = import_typescript5.default.isPropertyAccessExpression(callee) ? callee.name.text : import_typescript5.default.isIdentifier(callee) ? callee.text : "";
-    if (!STUB_GETTERS.has(name))
-      return [];
-    const fromTypeArgs = (expr.typeArguments ?? []).flatMap((argument) => classesInType(argument, checker));
-    if (fromTypeArgs.length > 0)
-      return fromTypeArgs;
-    const namespace = import_typescript5.default.isPropertyAccessExpression(callee) && name !== "getAgentByName" && name !== "getServerByName" ? callee.expression : expr.arguments[0];
-    return namespace ? receiverClasses(namespace, checker, depth + 1) : [];
+  defaultCanApply(declaration) {
+    if (!import_typescript4.default.isParameter(declaration) || this.checkingDefaults.has(declaration))
+      return true;
+    const init = declaration.initializer ? unwrap(declaration.initializer) : undefined;
+    if (!init || !import_typescript4.default.isIdentifier(init))
+      return true;
+    const fn = declaration.parent;
+    const name = isFunctionLike(fn) ? functionName(fn) : undefined;
+    if (!name || !isFunctionLike(fn))
+      return true;
+    const index = fn.parameters.indexOf(declaration);
+    this.checkingDefaults.add(declaration);
+    try {
+      const callers = this.callersOf(fn, name, 20);
+      if (callers.length === 0 || callers.length >= 20)
+        return true;
+      return callers.some((call) => {
+        if (call.arguments.slice(0, index + 1).some((argument2) => import_typescript4.default.isSpreadElement(argument2)))
+          return true;
+        const argument = call.arguments[index];
+        if (!argument)
+          return true;
+        const inner = unwrap(argument);
+        if (import_typescript4.default.isIdentifier(inner) && inner.text === "undefined" || import_typescript4.default.isVoidExpression(inner))
+          return true;
+        const passed = import_typescript4.default.isIdentifier(inner) ? valueDeclaration(resolvedSymbol(inner, this.checker)) : undefined;
+        if (passed && declaration.initializer && declares(passed, resolvedFunction(declaration.initializer, this.checker) ?? fn))
+          return true;
+        return !definitelyDefined(inner, this.checker);
+      });
+    } finally {
+      this.checkingDefaults.delete(declaration);
+    }
   }
-  const nameNode = import_typescript5.default.isPropertyAccessExpression(expr) ? expr.name : import_typescript5.default.isIdentifier(expr) ? expr : undefined;
-  if (!nameNode)
-    return [];
-  const declaration = valueDeclaration(resolvedSymbol(nameNode, checker));
-  if (!declaration)
-    return [];
-  if (import_typescript5.default.isVariableDeclaration(declaration) || import_typescript5.default.isParameter(declaration) || import_typescript5.default.isPropertyDeclaration(declaration) || import_typescript5.default.isPropertySignature(declaration)) {
-    const declared = classesInType(declaration.type, checker);
-    if (declared.length > 0)
-      return declared;
-    if ("initializer" in declaration && declaration.initializer)
-      return receiverClasses(declaration.initializer, checker, depth + 1);
+  direct(name, limit, matches, found) {
+    const candidates = this.byName.get(name) ?? [];
+    const out = [];
+    let checked = 0;
+    for (const call of candidates) {
+      if (found?.has(call))
+        continue;
+      if (out.length >= limit || checked >= limit * 20)
+        break;
+      checked += 1;
+      const callee = unwrap(call.expression);
+      const nameNode = import_typescript4.default.isPropertyAccessExpression(callee) ? callee.name : callee;
+      const symbol = resolvedSymbol(nameNode, this.checker);
+      const members = import_typescript4.default.isPropertyAccessExpression(callee) ? receiverClasses(callee.expression, this.checker).flatMap((cls) => cls.members.filter((member) => member.name?.getText() === name)) : [];
+      if (symbol?.declarations?.some((declaration) => matches(declaration, call)) || members.some((declaration) => matches(declaration, call)))
+        out.push(call);
+    }
+    return out;
   }
-  return [];
-}
-function firstParamType(declaration, checker) {
-  if (!declaration)
-    return;
-  let parameters;
-  if (import_typescript5.default.isMethodSignature(declaration) || import_typescript5.default.isMethodDeclaration(declaration))
-    parameters = declaration.parameters;
-  else if ((import_typescript5.default.isPropertySignature(declaration) || import_typescript5.default.isPropertyDeclaration(declaration)) && declaration.type && import_typescript5.default.isFunctionTypeNode(declaration.type))
-    parameters = declaration.type.parameters;
-  const type = parameters?.[0]?.type;
-  if (!type || !import_typescript5.default.isTypeReferenceNode(type))
-    return;
-  const name = import_typescript5.default.isQualifiedName(type.typeName) ? type.typeName.right : type.typeName;
-  return valueDeclarationOrType(resolvedSymbol(name, checker));
-}
-function valueDeclarationOrType(symbol) {
-  return symbol?.declarations?.[0];
 }
-function structuralAgent(receiver, method, ctx) {
-  let declaration;
-  try {
-    declaration = ctx.checker.getTypeAtLocation(receiver).getProperty(method)?.declarations?.[0];
-  } catch {
-    return;
+
+class RepoCallIndex {
+  entries;
+  indexes = new Map;
+  owned = new Map;
+  constructor(entries) {
+    this.entries = entries;
   }
-  declaration ??= declaredMethod(receiver, method, ctx.checker);
-  if (!declaration)
-    return;
-  const owner = declaration.parent;
-  if (owner && (import_typescript5.default.isClassDeclaration(owner) || import_typescript5.default.isClassExpression(owner))) {
-    const base = ctx.frameworkBase(owner).base;
-    return base && AGENT_BASES.has(base) ? owner : undefined;
+  indexFor(entry) {
+    let index = this.indexes.get(entry);
+    if (!index) {
+      index = new CallIndex(entry.program, entry.checker());
+      this.indexes.set(entry, index);
+    }
+    return index;
+  }
+  indexedCallersOf(fn, name, limit, within) {
+    const out = [];
+    const seen = new Set;
+    const fnFile = fn.getSourceFile().fileName;
+    for (const entry of this.entries) {
+      if (out.length >= limit)
+        break;
+      if (!entry.program.getSourceFile(fnFile))
+        continue;
+      let owned = this.owned.get(entry);
+      if (!owned) {
+        owned = new Set(entry.owned);
+        this.owned.set(entry, owned);
+      }
+      for (const call of this.indexFor(entry).callersOf(fn, name, Number.MAX_SAFE_INTEGER)) {
+        const source = call.getSourceFile();
+        if (!owned.has(source.fileName))
+          continue;
+        const key = `${source.fileName}:${call.pos}`;
+        if (seen.has(key))
+          continue;
+        if (within && within.getSourceFile(source.fileName) !== source)
+          continue;
+        seen.add(key);
+        out.push({ call, entry });
+        if (out.length >= limit)
+          break;
+      }
+    }
+    return out;
+  }
+  callersOf(fn, name, limit, within) {
+    const own = within ? this.entries.find((entry) => entry.program === within) : undefined;
+    if (own)
+      return this.indexFor(own).callersOf(fn, name, limit);
+    return this.indexedCallersOf(fn, name, limit, within).map((indexed) => indexed.call);
   }
-  const wanted = firstParamType(declaration, ctx.checker);
-  if (!wanted)
-    return;
-  return ctx.agentClasses().find((cls) => cls.members.some((member) => import_typescript5.default.isMethodDeclaration(member) && propertyNameText(member.name) === method && firstParamType(member, ctx.checker) === wanted));
 }
-var agentEntrySink = {
-  id: "agent-entry",
-  sdk: "agent-entry",
-  match(call, ctx) {
-    if (!import_typescript5.default.isCallExpression(call) || call.arguments.length === 0)
-      return;
-    const callee = unwrap(call.expression);
-    if (!import_typescript5.default.isPropertyAccessExpression(callee) || !AGENT_ENTRY_METHODS.has(callee.name.text))
-      return;
-    const method = callee.name.text;
-    const cls = receiverClasses(callee.expression, ctx.checker).find((candidate) => {
-      const base = ctx.frameworkBase(candidate).base;
-      return base !== undefined && AGENT_BASES.has(base);
-    });
-    const seam = method === "runAgentTool" && !cls && hasMethod(callee.expression, method, ctx) ? callee.expression : undefined;
-    const target = cls ?? structuralAgent(callee.expression, method, ctx);
-    if (!target && !seam)
-      return;
-    const argument = method === "runAgentTool" ? call.arguments[1] : call.arguments[0];
-    if (!argument || import_typescript5.default.isSpreadElement(argument))
-      return;
-    const roles = [];
-    if (method === "runAgentTool") {
-      const object = objectLiteralOf(argument, ctx.checker);
-      const input = object ? propertyValue(object, "input") : undefined;
-      roles.push(input ? { role: "user", node: input } : { role: "user", node: argument, key: "input" });
-    } else if (method === "saveMessages") {
-      roles.push({ role: "messages", node: argument });
-    } else {
-      const object = objectLiteralOf(argument, ctx.checker);
-      const fields = object ? ENTRY_FIELDS.filter((field) => propertyValue(object, field)) : [];
-      if (object && unwrap(argument) === object && fields.length > 0) {
-        for (const field of fields)
-          roles.push({ role: "user", node: propertyValue(object, field) });
-      } else {
-        roles.push({ role: "user", node: argument });
+function importAliases(source) {
+  const aliases = new Map;
+  for (const statement of source.statements) {
+    const clause = import_typescript4.default.isImportDeclaration(statement) ? statement.importClause : undefined;
+    if (!clause || clause.isTypeOnly)
+      continue;
+    if (clause.name)
+      aliases.set(clause.name.text, "default");
+    if (clause.namedBindings && import_typescript4.default.isNamedImports(clause.namedBindings)) {
+      for (const element of clause.namedBindings.elements) {
+        if (element.propertyName)
+          aliases.set(element.name.text, element.propertyName.text);
       }
     }
-    return { api: `${(target && className(target)) ?? "agent"}.${method}`, roles };
   }
-};
-function declaredMethod(receiver, method, checker) {
-  const root = unwrap(receiver);
-  if (!import_typescript5.default.isIdentifier(root))
-    return;
-  let annotation;
-  try {
-    const declaration = checker.getSymbolAtLocation(root)?.valueDeclaration;
-    if (declaration && (import_typescript5.default.isParameter(declaration) || import_typescript5.default.isVariableDeclaration(declaration) || import_typescript5.default.isPropertySignature(declaration) || import_typescript5.default.isPropertyDeclaration(declaration)))
-      annotation = declaration.type;
-  } catch {
-    return;
+  return aliases;
+}
+function isDefaultExport(fn) {
+  const holder = import_typescript4.default.isVariableDeclaration(fn.parent) ? fn.parent : fn;
+  if (import_typescript4.default.canHaveModifiers(holder) && import_typescript4.default.getModifiers(holder)?.some((modifier) => modifier.kind === import_typescript4.default.SyntaxKind.DefaultKeyword))
+    return true;
+  if (import_typescript4.default.isExportAssignment(fn.parent))
+    return true;
+  const name = functionName(fn);
+  return Boolean(name && fn.getSourceFile().statements.some((statement) => import_typescript4.default.isExportAssignment(statement) && !statement.isExportEquals && import_typescript4.default.isIdentifier(statement.expression) && statement.expression.text === name));
+}
+function sameNode(a, b) {
+  return a === b || a.kind === b.kind && a.pos === b.pos && a.end === b.end && a.getSourceFile().fileName === b.getSourceFile().fileName;
+}
+function declares(declaration, fn) {
+  if (sameNode(declaration, fn))
+    return true;
+  if ((import_typescript4.default.isVariableDeclaration(declaration) || import_typescript4.default.isPropertyAssignment(declaration) || import_typescript4.default.isPropertyDeclaration(declaration)) && declaration.initializer && sameNode(unwrap(declaration.initializer), fn))
+    return true;
+  if (import_typescript4.default.isExportAssignment(declaration) && sameNode(unwrap(declaration.expression), fn))
+    return true;
+  return false;
+}
+function definitelyDefined(expression, checker, seen = new Set) {
+  const node = unwrap(expression);
+  if (seen.has(node))
+    return false;
+  seen.add(node);
+  if (import_typescript4.default.isStringLiteralLike(node) || import_typescript4.default.isNumericLiteral(node) || import_typescript4.default.isObjectLiteralExpression(node) || import_typescript4.default.isArrayLiteralExpression(node) || import_typescript4.default.isArrowFunction(node) || import_typescript4.default.isFunctionExpression(node) || node.kind === import_typescript4.default.SyntaxKind.NullKeyword || node.kind === import_typescript4.default.SyntaxKind.TrueKeyword || node.kind === import_typescript4.default.SyntaxKind.FalseKeyword)
+    return true;
+  if (import_typescript4.default.isIdentifier(node)) {
+    const declaration = valueDeclaration(resolvedSymbol(node, checker));
+    if (declaration && (import_typescript4.default.isFunctionDeclaration(declaration) || import_typescript4.default.isClassDeclaration(declaration)))
+      return true;
+    if (declaration && import_typescript4.default.isVariableDeclaration(declaration) && declaration.initializer && import_typescript4.default.getCombinedNodeFlags(declaration) & import_typescript4.default.NodeFlags.Const)
+      return definitelyDefined(declaration.initializer, checker, seen);
   }
+  return false;
+}
+function contextualSignatures(fn, name, checker) {
+  const member = import_typescript4.default.isArrowFunction(fn) || import_typescript4.default.isFunctionExpression(fn) ? fn.parent : fn;
+  if (!(import_typescript4.default.isMethodDeclaration(member) || import_typescript4.default.isPropertyAssignment(member)) || !import_typescript4.default.isObjectLiteralExpression(member.parent))
+    return new Set;
+  const property = checker.getContextualType(member.parent)?.getProperty(name);
+  return new Set((property?.declarations ?? []).filter((declaration) => import_typescript4.default.isMethodSignature(declaration) || import_typescript4.default.isPropertySignature(declaration)));
+}
+function contextualReceiverMatches(call, fn, checker) {
+  const member = import_typescript4.default.isArrowFunction(fn) || import_typescript4.default.isFunctionExpression(fn) ? fn.parent : fn;
+  const callee = unwrap(call.expression);
+  if (!import_typescript4.default.isPropertyAccessExpression(callee))
+    return true;
   const seen = new Set;
-  const search = (type, depth) => {
-    if (!type || depth > 4 || seen.has(type))
-      return;
-    seen.add(type);
-    if (import_typescript5.default.isIntersectionTypeNode(type) || import_typescript5.default.isUnionTypeNode(type)) {
-      for (const member of type.types) {
-        const found = search(member, depth + 1);
-        if (found)
-          return found;
-      }
-      return;
-    }
-    if (import_typescript5.default.isParenthesizedTypeNode(type))
-      return search(type.type, depth + 1);
-    const members = import_typescript5.default.isTypeLiteralNode(type) ? type.members : undefined;
-    if (members)
-      return members.find((member) => (import_typescript5.default.isMethodSignature(member) || import_typescript5.default.isPropertySignature(member)) && propertyNameText(member.name) === method);
-    if (!import_typescript5.default.isTypeReferenceNode(type))
+  const objectOf = (expression) => {
+    const node = unwrap(expression);
+    if (seen.has(node))
       return;
-    return fromName(type.typeName, depth);
+    seen.add(node);
+    if (import_typescript4.default.isObjectLiteralExpression(node))
+      return node;
+    const declaration = valueDeclaration(resolvedSymbol(import_typescript4.default.isPropertyAccessExpression(node) ? node.name : node, checker));
+    if (declaration && (import_typescript4.default.isVariableDeclaration(declaration) || import_typescript4.default.isPropertyAssignment(declaration)) && declaration.initializer)
+      return objectOf(declaration.initializer);
+    return;
   };
-  const fromName = (name, depth) => {
-    let symbol;
-    try {
-      symbol = checker.getSymbolAtLocation(name);
-      if (symbol && symbol.flags & import_typescript5.default.SymbolFlags.Alias)
-        symbol = checker.getAliasedSymbol(symbol);
-    } catch {
-      return;
-    }
-    for (const declaration of symbol?.declarations ?? []) {
-      if (seen.has(declaration))
-        continue;
-      seen.add(declaration);
-      if (import_typescript5.default.isInterfaceDeclaration(declaration)) {
-        const own = declaration.members.find((member) => (import_typescript5.default.isMethodSignature(member) || import_typescript5.default.isPropertySignature(member)) && propertyNameText(member.name) === method);
-        if (own)
-          return own;
-        for (const clause of declaration.heritageClauses ?? []) {
-          for (const base of clause.types) {
-            const found = fromName(base.expression, depth + 1);
-            if (found)
-              return found;
-          }
-        }
-      }
-      if (import_typescript5.default.isTypeAliasDeclaration(declaration)) {
-        const found = search(declaration.type, depth + 1);
-        if (found)
-          return found;
+  const object = objectOf(callee.expression);
+  if (!object || object === member.parent)
+    return true;
+  const origin = (literal, visited = new Set) => {
+    if (visited.has(literal))
+      return;
+    const next = new Set(visited).add(literal);
+    for (const property of [...literal.properties].reverse()) {
+      if (import_typescript4.default.isSpreadAssignment(property)) {
+        const spread = objectOf(property.expression);
+        if (!spread)
+          return;
+        const inherited = origin(spread, next);
+        if (inherited !== null)
+          return inherited;
+      } else if (property.name?.getText().replace(/^['"]|['"]$/g, "") === callee.name.text) {
+        return property;
       }
     }
-    return;
+    return null;
   };
-  return search(annotation, 0);
+  const implementation = origin(object);
+  return implementation === undefined || implementation === member;
 }
-function hasMethod(receiver, method, ctx) {
-  try {
-    return Boolean(ctx.checker.getTypeAtLocation(receiver).getProperty(method));
-  } catch {
-    return false;
+
+// src/harness-extract/messages.ts
+var ROLE_LITERALS = {
+  system: "system",
+  developer: "system",
+  user: "user",
+  human: "user",
+  assistant: "assistant",
+  ai: "assistant",
+  model: "assistant",
+  tool: "tool",
+  function: "tool"
+};
+var CONSTRUCTOR_ROLE = [
+  [/(?:^|\.)System(?:Message|MessagePromptTemplate)\b/, "system"],
+  [/(?:^|\.)(?:Human|User)(?:Message|MessagePromptTemplate)\b/, "user"],
+  [/(?:^|\.)(?:AI|Ai|Assistant)(?:Message|MessagePromptTemplate)\b/, "assistant"],
+  [/(?:^|\.)(?:Tool|Function)Message\b/, "tool"]
+];
+var PASS_THROUGH = new Set(["ref", "lookup", "param", "call", "oneOf"]);
+var STRINGY = new Set(["literal", "template", "concat", "arrayJoin"]);
+var MAX_CONTAINERS = 16;
+function singleLiteral(tree) {
+  if (!tree)
+    return;
+  if (tree.kind === "literal")
+    return tree.text;
+  if (PASS_THROUGH.has(tree.kind)) {
+    const flow = valueChildren(tree);
+    if (flow.length === 1)
+      return singleLiteral(flow[0]);
   }
+  return;
 }
-var CHAT_HOOK_MODULE = /^(?:@ai-sdk\/(?:react|svelte|vue|angular|solid)|ai\/(?:react|svelte|vue)|agents\/(?:ai-)?react|@cloudflare\/(?:think|ai-chat|agents)\/react)$/;
-var CHAT_HOOKS = new Set(["useChat", "useAgentChat", "Chat", "useCompletion"]);
-var CHAT_SEND = new Set(["sendMessage", "append", "submitMessage", "complete"]);
-function fromChatHook(expression, checker, depth = 0) {
-  if (!expression || depth > 3)
-    return false;
-  const expr = unwrap(expression);
-  if (import_typescript5.default.isCallExpression(expr) || import_typescript5.default.isNewExpression(expr)) {
-    const root = rootIdentifier(expr.expression);
-    const origin = root ? importOrigin(root, checker) : undefined;
-    return Boolean(origin && CHAT_HOOK_MODULE.test(origin.module) && CHAT_HOOKS.has(origin.imported === "*" || origin.imported === "default" ? import_typescript5.default.isPropertyAccessExpression(expr.expression) ? expr.expression.name.text : "" : origin.imported));
+function elementRole(element, depth = 0) {
+  if (depth > 6 || element.key === "...")
+    return "unknown";
+  if (element.kind === "object") {
+    const missing = { ...element, kind: "external", children: undefined, resolution: "unresolved" };
+    const text = singleLiteral(selectKey(element, "role", missing));
+    return text && ROLE_LITERALS[text.toLowerCase()] || "unknown";
   }
-  const nameNode = import_typescript5.default.isIdentifier(expr) ? expr : import_typescript5.default.isPropertyAccessExpression(expr) ? expr.name : undefined;
-  const declaration = nameNode ? valueDeclaration(resolvedSymbol(nameNode, checker)) : undefined;
-  if (!declaration)
-    return false;
-  if (import_typescript5.default.isBindingElement(declaration)) {
-    const holder = declaration.parent.parent;
-    return import_typescript5.default.isVariableDeclaration(holder) && fromChatHook(holder.initializer, checker, depth + 1);
+  if (element.kind === "array") {
+    const text = singleLiteral(element.children?.[0]);
+    return text && ROLE_LITERALS[text.toLowerCase()] || "unknown";
   }
-  if (import_typescript5.default.isVariableDeclaration(declaration))
-    return fromChatHook(declaration.initializer, checker, depth + 1);
-  return false;
+  if ((element.kind === "call" || element.kind === "external") && element.name) {
+    for (const [pattern, role] of CONSTRUCTOR_ROLE)
+      if (pattern.test(element.name))
+        return role;
+  }
+  if (PASS_THROUGH.has(element.kind)) {
+    const roles = new Set(valueChildren(element).map((child) => elementRole(child, depth + 1)));
+    return roles.size === 1 ? [...roles][0] : "unknown";
+  }
+  return "unknown";
 }
-function looksLikeUiMessage(argument) {
-  const object = unwrap(argument);
-  if (!import_typescript5.default.isObjectLiteralExpression(object))
-    return false;
-  const parts = propertyValue(object, "parts");
-  if (parts) {
-    const array = unwrap(parts);
-    return import_typescript5.default.isArrayLiteralExpression(array) && array.elements.some((element) => {
-      const part = unwrap(element);
-      if (!import_typescript5.default.isObjectLiteralExpression(part))
-        return false;
-      const type = propertyValue(part, "type");
-      return Boolean(type && import_typescript5.default.isStringLiteralLike(unwrap(type)) && unwrap(type).text === "text");
-    });
+function containersOf(tree, containers, others, depth = 0) {
+  if (containers.length >= MAX_CONTAINERS)
+    return;
+  if (tree.kind === "array" || tree.kind === "assembled" && tree.text !== "string") {
+    containers.push(tree);
+    return;
   }
-  if (propertyValue(object, "text") && object.properties.length <= 3)
-    return true;
-  const role = propertyValue(object, "role");
-  return Boolean(role && import_typescript5.default.isStringLiteralLike(unwrap(role)) && unwrap(role).text === "user" && (propertyValue(object, "content") || propertyValue(object, "parts")));
+  const flow = PASS_THROUGH.has(tree.kind) ? valueChildren(tree) : [];
+  if (flow.length > 0 && depth < 12) {
+    for (const child of flow)
+      containersOf(child, containers, others, depth + 1);
+    return;
+  }
+  others.push(tree);
 }
-var clientChatSink = {
-  id: "client-chat",
-  sdk: "client-chat",
-  match(call, ctx) {
-    if (!import_typescript5.default.isCallExpression(call) || call.arguments.length === 0)
-      return;
-    const callee = unwrap(call.expression);
-    const binding = import_typescript5.default.isIdentifier(callee) ? valueDeclaration(resolvedSymbol(callee, ctx.checker)) : undefined;
-    const bound = binding && import_typescript5.default.isBindingElement(binding) && binding.propertyName ? propertyNameText(binding.propertyName) : undefined;
-    const name = bound ?? (import_typescript5.default.isIdentifier(callee) ? callee.text : import_typescript5.default.isPropertyAccessExpression(callee) ? callee.name.text : undefined);
-    if (!name || !CHAT_SEND.has(name))
-      return;
-    const argument = call.arguments[0];
-    if (import_typescript5.default.isSpreadElement(argument))
-      return;
-    const hooked = import_typescript5.default.isIdentifier(callee) ? fromChatHook(callee, ctx.checker) : fromChatHook(callee.expression, ctx.checker);
-    if (!hooked && !((name === "sendMessage" || name === "append") && looksLikeUiMessage(argument)))
-      return;
-    return { api: `chat.${name}`, roles: [{ role: "user", node: argument }] };
+function splitMessages(tree) {
+  const containers = [];
+  const others = [];
+  containersOf(tree, containers, others);
+  if (containers.length === 0) {
+    return [{ role: STRINGY.has(tree.kind) || others.length > 0 && others.every((other) => STRINGY.has(other.kind)) ? "user" : "unknown", tree }];
   }
-};
-var websocketSink = {
-  id: "websocket",
-  sdk: "websocket",
-  match(call, ctx) {
-    if (!import_typescript5.default.isNewExpression(call) || !call.arguments?.length)
-      return;
-    const callee = unwrap(call.expression);
-    if (!import_typescript5.default.isIdentifier(callee) || callee.text !== "WebSocket")
-      return;
-    const url = ctx.urlTexts(call.arguments[0]).find((candidate) => MODEL_SOCKET.test(candidate));
-    if (!url)
-      return;
-    const modelInUrl = urlModel(call.arguments[0], ctx.checker);
-    const roles = modelInUrl ? [{ role: "model", node: modelInUrl }] : /[?&]model=/.test(url) ? [{ role: "model", node: call.arguments[0], key: URL_MODEL_KEY }] : [];
-    return {
-      api: "websocket",
-      provider: /openai/.test(url) ? "openai" : /generativelanguage/.test(url) ? "google" : undefined,
-      roles
-    };
+  const out = [];
+  for (const container of containers) {
+    (container.children ?? []).forEach((element, index) => {
+      out.push({ role: elementRole(element), tree: element, message: { arrayId: container.id, index } });
+    });
   }
-};
-function frameworkName(identifier, checker, member) {
-  if (!identifier)
-    return;
-  const origin = importOrigin(identifier, checker);
-  if (origin) {
-    const name = origin.imported === "*" || origin.imported === "default" ? member ?? identifier.text : origin.imported;
-    return FRAMEWORK_MODULE.test(origin.module) && FRAMEWORK_BASES.has(name) ? { base: name, module: origin.module } : undefined;
+  for (const other of others)
+    out.push({ role: STRINGY.has(other.kind) ? "user" : "unknown", tree: other });
+  return out;
+}
+
+// src/harness-extract/program.ts
+var import_typescript5 = __toESM(require_typescript(), 1);
+import { createHash } from "node:crypto";
+import { readdirSync, statSync } from "node:fs";
+import { dirname, join, relative as relative2, resolve } from "node:path";
+var SKIPPED_DIRS2 = new Set(["node_modules", "dist", "build", "out", "vendor", "coverage", "graphify-out", "__pycache__"]);
+var CODE_FILE = /\.(?:[cm]?[jt]sx?)$/i;
+var SVELTE_FILE = /\.svelte$/i;
+var SCRIPT_BLOCK = /(<script\b[^>]*>)([\s\S]*?)<\/script\s*>/gi;
+function svelteScriptText(text) {
+  const out = text.replace(/[^\n]/g, " ").split("");
+  for (const match of text.matchAll(SCRIPT_BLOCK)) {
+    const start = (match.index ?? 0) + match[1].length;
+    for (let index = 0;index < match[2].length; index += 1)
+      out[start + index] = match[2][index];
   }
-  return;
+  return out.join("");
 }
-function frameworkBaseOf(cls, checker, memo, depth = 0) {
-  const cached = memo.get(cls);
-  if (cached)
-    return cached;
-  const self = className(cls) ?? "(anonymous)";
-  const result = { chain: [self] };
-  memo.set(cls, result);
-  const heritage = cls.heritageClauses?.find((clause) => clause.token === import_typescript5.default.SyntaxKind.ExtendsKeyword)?.types[0];
-  if (!heritage || depth > 8)
-    return result;
-  const resolveExpression = (expression) => {
-    const expr = unwrap(expression);
-    if (import_typescript5.default.isCallExpression(expr)) {
-      for (const argument of expr.arguments) {
-        const found = resolveExpression(argument);
-        if (found?.base)
-          return found;
-      }
+var DECLARATION_FILE = /\.d\.[cm]?ts$/i;
+var TEST_RUNNER_FILE = /(?:^|\/)__tests__\/|\.(?:test|spec)\.[cm]?[jt]sx?$/i;
+var TEST_PATH = /(?:^|\/)(?:test|tests|__tests__|test-fixtures|fixtures?|__fixtures__|__mocks__|e2e)\/|\.(?:test|spec)\.[cm]?[jt]sx?$/i;
+var EVAL_PATH = /(?:^|\/)evals?\/|\.evals?\.[cm]?[jt]sx?$/i;
+var MAX_FILE_BYTES = 1024 * 1024;
+var DEFAULT_MAX_FILES = 20000;
+function isTestPath(rel) {
+  return TEST_PATH.test(rel);
+}
+function isEvalPath(rel) {
+  return EVAL_PATH.test(rel);
+}
+function walkRepository(rootDir, maxFiles, includeTestRunnerFiles) {
+  const files = [];
+  const configs = [];
+  let truncated = false;
+  const walk = (abs, rel) => {
+    let entries;
+    try {
+      entries = readdirSync(abs, { withFileTypes: true });
+    } catch {
       return;
     }
-    const identifier = import_typescript5.default.isIdentifier(expr) ? expr : import_typescript5.default.isPropertyAccessExpression(expr) ? rootIdentifier(expr) : undefined;
-    const member = import_typescript5.default.isPropertyAccessExpression(expr) ? expr.name.text : undefined;
-    const direct = frameworkName(identifier, checker, member);
-    if (direct)
-      return { ...direct, chain: [direct.base] };
-    const declaration = valueDeclaration(resolvedSymbol(import_typescript5.default.isPropertyAccessExpression(expr) ? expr.name : expr, checker));
-    if (!declaration)
-      return;
-    if (import_typescript5.default.isClassDeclaration(declaration) || import_typescript5.default.isClassExpression(declaration))
-      return frameworkBaseOf(declaration, checker, memo, depth + 1);
-    const holder = import_typescript5.default.isBindingElement(declaration) ? declaration.parent.parent : declaration;
-    const name = import_typescript5.default.isBindingElement(declaration) ? propertyNameText(declaration.propertyName ?? declaration.name) : undefined;
-    if (import_typescript5.default.isVariableDeclaration(holder) && holder.initializer) {
-      const init = unwrap(holder.initializer);
-      if (import_typescript5.default.isClassExpression(init))
-        return frameworkBaseOf(init, checker, memo, depth + 1);
-      if (import_typescript5.default.isCallExpression(init)) {
-        for (const argument of init.arguments) {
-          const arg = unwrap(argument);
-          if (!import_typescript5.default.isIdentifier(arg))
-            continue;
-          const found = frameworkName(arg, checker, name);
-          if (found)
-            return { ...found, chain: [found.base] };
-          const nested = resolveExpression(arg);
-          if (nested?.base)
-            return nested;
-        }
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      if (files.length >= maxFiles) {
+        truncated = true;
+        return;
       }
-      if (import_typescript5.default.isIdentifier(init) || import_typescript5.default.isPropertyAccessExpression(init))
-        return resolveExpression(init);
-    }
-    return;
-  };
-  const parent = resolveExpression(heritage.expression);
-  if (parent) {
-    result.base = parent.base;
-    result.module = parent.module;
-    result.chain = [self, ...parent.chain];
-  } else {
-    result.chain = [self, heritage.expression.getText()];
-  }
-  return result;
-}
-function hookSink(memo) {
-  return {
-    id: "think-hook",
-    sdk: "think-hook",
-    match(cls, ctx) {
-      const info = frameworkBaseOf(cls, ctx.checker, memo);
-      if (!info.base || !HOOK_BASES.has(info.base))
-        return [];
-      const roles = [];
-      for (const member of cls.members) {
-        const name = propertyNameText(member.name);
-        if (!name || import_typescript5.default.getCombinedModifierFlags(member) & import_typescript5.default.ModifierFlags.Static)
-          continue;
-        if ((import_typescript5.default.isMethodDeclaration(member) || import_typescript5.default.isGetAccessorDeclaration(member)) && HOOK_METHODS[name] && member.body) {
-          roles.push({ role: HOOK_METHODS[name], node: member, values: returnExpressions(member) });
-        } else if (import_typescript5.default.isMethodDeclaration(member) && TURN_HOOKS.has(name) && member.body) {
-          const returns = returnExpressions(member);
-          for (const [key, role] of Object.entries(TURN_CONFIG_KEYS)) {
-            if (returns.some((ret) => {
-              const value = objectLiteralOf(ret, ctx.checker);
-              return value !== undefined && hasProperty(value, key);
-            })) {
-              roles.push({ role, node: member, values: returns, key });
-            }
+      const childRel = rel ? `${rel}/${entry.name}` : entry.name;
+      const childAbs = join(abs, entry.name);
+      if (entry.isDirectory()) {
+        if (!entry.name.startsWith(".") && !SKIPPED_DIRS2.has(entry.name))
+          walk(childAbs, childRel);
+      } else if (entry.isFile()) {
+        if (entry.name === "tsconfig.json")
+          configs.push(childAbs);
+        else if (SVELTE_FILE.test(entry.name)) {
+          try {
+            if (statSync(childAbs).size <= MAX_FILE_BYTES)
+              files.push(svelteVirtualName(childAbs));
+          } catch {
+            continue;
           }
-        } else if (import_typescript5.default.isPropertyDeclaration(member) && HOOK_PROPERTIES[name] && member.initializer) {
-          roles.push({ role: HOOK_PROPERTIES[name], node: member.initializer });
+        } else if (CODE_FILE.test(entry.name) && !DECLARATION_FILE.test(entry.name) && !/\.min\.[cm]?js$/i.test(entry.name) && (includeTestRunnerFiles || !TEST_RUNNER_FILE.test(childRel))) {
+          try {
+            if (statSync(childAbs).size > MAX_FILE_BYTES)
+              continue;
+          } catch {
+            continue;
+          }
+          files.push(childAbs);
         }
       }
-      if (roles.length === 0)
-        return [];
-      return [{ api: `${info.base === "Think" ? "think" : "agents"}.hook`, roles, anchor: cls.name ?? cls }];
     }
   };
+  walk(rootDir, "");
+  return { files, configs, truncated };
 }
-function createFrameworkMemo() {
-  return new Map;
-}
-var HOSTED_MODEL_SDKS = [
-  { module: /^@fal-ai\/(?:client|serverless-client)$/, methods: new Set(["run", "subscribe", "stream"]), provider: "fal" },
-  { module: /^replicate$/, methods: new Set(["run", "stream"]), provider: "replicate" }
-];
-var hostedModelSink = {
-  id: "hosted-model",
-  sdk: "hosted-model",
-  match(call, ctx) {
-    if (!import_typescript5.default.isCallExpression(call) || call.arguments.length === 0)
-      return;
-    const callee = unwrap(call.expression);
-    if (!import_typescript5.default.isPropertyAccessExpression(callee))
-      return;
-    const origin = valueOrigin(callee.expression, ctx.checker);
-    const sdk = origin && HOSTED_MODEL_SDKS.find((candidate) => candidate.module.test(origin.module) && candidate.methods.has(callee.name.text));
-    if (!sdk)
-      return;
-    const [model, options] = call.arguments;
-    const input = options ? objectLiteralOf(options, ctx.checker) : undefined;
-    const inner = input ? propertyValue(input, "input") : undefined;
-    return {
-      api: `${sdk.provider}.${callee.name.text}`,
-      provider: sdk.provider,
-      roles: [{ role: "model", node: model }, ...inner ? requestRoles(inner, { prompt: "prompt" }, ctx) : []]
-    };
+function sourceFingerprint(rootDir, options = {}) {
+  const walked = walkRepository(resolve(rootDir), options.maxFiles ?? DEFAULT_MAX_FILES, options.includeTestRunnerFiles ?? false);
+  const hash = createHash("sha1");
+  const inputs = new Set([...walked.configs, ...walked.files.map((file) => file.endsWith(SVELTE_VIRTUAL_SUFFIX) ? file.slice(0, -SVELTE_VIRTUAL_SUFFIX.length) : file)]);
+  for (const config of walked.configs) {
+    const host = { ...import_typescript5.default.sys, onUnRecoverableConfigFileDiagnostic: () => {}, readFile: (file) => {
+      inputs.add(file);
+      return import_typescript5.default.sys.readFile(file);
+    } };
+    import_typescript5.default.getParsedCommandLineOfConfigFile(config, {}, host);
   }
-};
-var REALTIME_SEND = /send|emit|transmit|dispatch/i;
-var realtimeEventSink = {
-  id: "realtime-event",
-  sdk: "realtime",
-  match(call, ctx) {
-    if (!import_typescript5.default.isCallExpression(call) || call.arguments.length !== 1)
-      return;
-    const callee = import_typescript5.default.isPropertyAccessExpression(call.expression) ? call.expression.name : call.expression;
-    if (!import_typescript5.default.isIdentifier(callee) || !REALTIME_SEND.test(callee.text))
-      return;
-    let sent = unwrap(call.arguments[0]);
-    if (import_typescript5.default.isCallExpression(sent) && sent.expression.getText() === "JSON.stringify" && sent.arguments[0])
-      sent = unwrap(sent.arguments[0]);
-    const argument = objectLiteralOf(sent, ctx.checker);
-    if (!argument)
+  const metadata = (directory) => {
+    let entries;
+    try {
+      entries = readdirSync(directory, { withFileTypes: true });
+    } catch {
       return;
-    const type = propertyValue(argument, "type");
-    const kind = type && (import_typescript5.default.isStringLiteral(type) || import_typescript5.default.isNoSubstitutionTemplateLiteral(type)) ? type.text : undefined;
-    if (kind === "session.update") {
-      const session = propertyValue(argument, "session");
-      const object = session ? objectLiteralOf(session, ctx.checker) : undefined;
-      const instructions = object ? propertyValue(object, "instructions") : undefined;
-      return instructions ? { api: "realtime.session.update", provider: "openai", roles: [{ role: "system", node: instructions }] } : undefined;
     }
-    if (kind === "conversation.item.create") {
-      const item = propertyValue(argument, "item");
-      const object = item ? objectLiteralOf(item, ctx.checker) : undefined;
-      const role = object ? propertyValue(object, "role") : undefined;
-      const roleText = role && import_typescript5.default.isStringLiteral(role) ? role.text : undefined;
-      const content = object ? propertyValue(object, "content") : undefined;
-      if (!content || roleText !== "system" && roleText !== "user")
-        return;
-      return { api: "realtime.conversation.item.create", provider: "openai", roles: [{ role: roleText === "system" ? "system" : "messages", node: content }] };
+    for (const entry of entries) {
+      if (entry.isDirectory() && !entry.name.startsWith(".") && !SKIPPED_DIRS2.has(entry.name))
+        metadata(join(directory, entry.name));
+      else if (entry.isFile() && (entry.name === "package.json" || /^wrangler(?:\.[\w.-]+)?\.(?:json|jsonc|toml)$/.test(entry.name)))
+        inputs.add(join(directory, entry.name));
     }
-    return;
+  };
+  metadata(resolve(rootDir));
+  for (const file of [...inputs].sort()) {
+    const text = import_typescript5.default.sys.readFile(file);
+    hash.update(`${file}\x00${text ?? "missing"}
+`);
   }
-};
-function effectiveField(object, key) {
-  let last = -1;
-  object.properties.forEach((property, index) => {
-    if (!import_typescript5.default.isSpreadAssignment(property) && propertyNameText(property.name) === key)
-      last = index;
-  });
-  const fields = [];
-  const value = last >= 0 ? propertyValue(object, key) : undefined;
-  if (value)
-    fields.push({ node: value });
-  object.properties.forEach((property, index) => {
-    if (index > last && import_typescript5.default.isSpreadAssignment(property))
-      fields.push({ node: property.expression, key });
-  });
-  return fields;
+  return hash.digest("hex");
 }
-var WRITTEN_SYMBOLS = new WeakMap;
-function writtenSymbols(file, checker) {
-  let written = WRITTEN_SYMBOLS.get(file);
-  if (written)
-    return written;
-  const found = new Set;
-  const add = (node) => {
-    const root = rootIdentifier(node);
-    const symbol = root ? resolvedSymbol(root, checker) : undefined;
-    if (symbol)
-      found.add(symbol);
+function extractorOptions(base) {
+  const options = {
+    ...base,
+    noEmit: true,
+    skipLibCheck: true,
+    noLib: true,
+    types: [],
+    noResolve: false,
+    allowJs: true,
+    checkJs: false,
+    resolveJsonModule: false,
+    declaration: false,
+    composite: false,
+    incremental: false,
+    tsBuildInfoFile: undefined,
+    plugins: undefined
   };
-  const visit = (node) => {
-    if (import_typescript5.default.isBinaryExpression(node) && node.operatorToken.kind >= import_typescript5.default.SyntaxKind.FirstAssignment && node.operatorToken.kind <= import_typescript5.default.SyntaxKind.LastAssignment)
-      add(node.left);
-    else if (import_typescript5.default.isDeleteExpression(node))
-      add(node.expression);
-    else if ((import_typescript5.default.isPrefixUnaryExpression(node) || import_typescript5.default.isPostfixUnaryExpression(node)) && (node.operator === import_typescript5.default.SyntaxKind.PlusPlusToken || node.operator === import_typescript5.default.SyntaxKind.MinusMinusToken))
-      add(node.operand);
-    else if (import_typescript5.default.isCallExpression(node) && node.arguments.length > 0) {
-      const callee = unwrap(node.expression);
-      if (import_typescript5.default.isPropertyAccessExpression(callee) && callee.name.text === "assign")
-        add(node.arguments[0]);
+  if (options.moduleResolution === undefined) {
+    options.module = import_typescript5.default.ModuleKind.ESNext;
+    options.moduleResolution = import_typescript5.default.ModuleResolutionKind.Bundler;
+  }
+  options.allowImportingTsExtensions = true;
+  return options;
+}
+var FALLBACK_OPTIONS = extractorOptions({
+  target: import_typescript5.default.ScriptTarget.ES2022,
+  jsx: import_typescript5.default.JsxEmit.Preserve,
+  esModuleInterop: true
+});
+function sharedHost(options, cache) {
+  const host = import_typescript5.default.createCompilerHost(options, true);
+  const moduleCache = import_typescript5.default.createModuleResolutionCache(host.getCurrentDirectory(), (name) => name, options);
+  host.getSourceFile = (fileName, languageVersionOrOptions) => {
+    const version = typeof languageVersionOrOptions === "object" ? languageVersionOrOptions.languageVersion : languageVersionOrOptions;
+    const key = `${version}:${fileName}`;
+    if (cache.has(key))
+      return cache.get(key);
+    let source;
+    const svelte = fileName.endsWith(SVELTE_VIRTUAL_SUFFIX);
+    const raw = import_typescript5.default.sys.readFile(svelte ? fileName.slice(0, -SVELTE_VIRTUAL_SUFFIX.length) : fileName);
+    const text = svelte && raw !== undefined ? svelteScriptText(raw) : raw;
+    if (text !== undefined && text.length <= MAX_FILE_BYTES) {
+      source = import_typescript5.default.createSourceFile(fileName, text, languageVersionOrOptions, true, svelte ? import_typescript5.default.ScriptKind.TS : undefined);
     }
-    import_typescript5.default.forEachChild(node, visit);
+    cache.set(key, source);
+    return source;
   };
-  visit(file);
-  written = found;
-  WRITTEN_SYMBOLS.set(file, written);
-  return written;
+  host.resolveModuleNameLiterals = (literals, containingFile, redirected, compilerOptions) => literals.map((literal) => {
+    const resolved = import_typescript5.default.resolveModuleName(literal.text, containingFile, compilerOptions, host, moduleCache, redirected).resolvedModule;
+    if (!resolved || resolved.isExternalLibraryImport || /[\\/]node_modules[\\/]/.test(resolved.resolvedFileName) || DECLARATION_FILE.test(resolved.resolvedFileName) || !CODE_FILE.test(resolved.resolvedFileName)) {
+      return { resolvedModule: undefined };
+    }
+    return { resolvedModule: resolved };
+  });
+  const fileExists = host.fileExists.bind(host);
+  host.fileExists = (fileName) => fileName.endsWith(SVELTE_VIRTUAL_SUFFIX) ? fileExists(fileName.slice(0, -SVELTE_VIRTUAL_SUFFIX.length)) : fileExists(fileName);
+  host.writeFile = () => {};
+  return host;
 }
-function gatewayRequestLiteral(argument, checker) {
-  const value = unwrap(argument);
-  if (import_typescript5.default.isObjectLiteralExpression(value))
-    return value;
-  if (!import_typescript5.default.isIdentifier(value))
-    return;
-  const symbol = resolvedSymbol(value, checker);
-  const declaration = valueDeclaration(symbol);
-  if (!symbol || !declaration || !import_typescript5.default.isVariableDeclaration(declaration) || !declaration.initializer)
-    return;
-  if (!(import_typescript5.default.getCombinedNodeFlags(declaration) & import_typescript5.default.NodeFlags.Const))
-    return;
-  const literal = unwrap(declaration.initializer);
-  if (!import_typescript5.default.isObjectLiteralExpression(literal))
+var NO_INPUTS_FOUND = 18003;
+function parseConfig(configPath, warnings, rootDir) {
+  const rel = relative2(rootDir, configPath).split("\\").join("/");
+  const read = import_typescript5.default.readConfigFile(configPath, import_typescript5.default.sys.readFile);
+  if (read.error || !read.config || typeof read.config !== "object") {
+    warnings.push(`tsconfig ${rel}: unreadable, its files fall back to the default program`);
     return;
-  return writtenSymbols(declaration.getSourceFile(), checker).has(symbol) ? undefined : literal;
+  }
+  const raw = read.config;
+  const parsed = import_typescript5.default.parseJsonConfigFileContent(read.config, import_typescript5.default.sys, dirname(configPath), undefined, configPath);
+  const errors = parsed.errors.filter((error) => error.code !== NO_INPUTS_FOUND);
+  if (errors.length > 0) {
+    const messages = errors.slice(0, 3).map((error) => import_typescript5.default.flattenDiagnosticMessageText(error.messageText, " "));
+    warnings.push(`tsconfig ${rel}: ${messages.join("; ")}${errors.length > 3 ? ` (+${errors.length - 3} more)` : ""}; extraction continues with the options that parsed`);
+  }
+  const explicit = raw.include !== undefined || raw.files !== undefined || parsed.raw && (parsed.raw.include !== undefined || parsed.raw.files !== undefined);
+  return { options: parsed.options, fileNames: explicit ? parsed.fileNames.map((name) => resolve(name)) : undefined };
 }
-var GATEWAY_METHODS = new Set(["call", "stream"]);
-var GATEWAY_BODY_KEYS = { system: "system", messages: "messages", prompt: "prompt", model: "model", tools: "tools" };
-var modelGatewaySink = {
-  id: "model-gateway",
-  sdk: "model-gateway",
-  match(call, ctx) {
-    if (!import_typescript5.default.isCallExpression(call) || call.arguments.length !== 1)
-      return;
-    const callee = unwrap(call.expression);
-    if (!import_typescript5.default.isPropertyAccessExpression(callee) || !GATEWAY_METHODS.has(callee.name.text))
-      return;
-    const receiver = unwrap(callee.expression);
-    if (!import_typescript5.default.isPropertyAccessExpression(receiver) || receiver.name.text !== "models")
-      return;
-    const request = gatewayRequestLiteral(call.arguments[0], ctx.checker);
-    if (!request || !propertyValue(request, "kind"))
+function isUnder(file, dir) {
+  const rel = relative2(dir, file);
+  return rel !== "" && !rel.startsWith("..") && !rel.startsWith("/");
+}
+function buildPrograms(rootDir, options = {}) {
+  const root = resolve(rootDir);
+  const maxFiles = options.maxFiles ?? DEFAULT_MAX_FILES;
+  const warnings = [];
+  const walked = walkRepository(root, maxFiles, options.includeTestRunnerFiles ?? false);
+  if (walked.truncated)
+    warnings.push(`file cap reached: only the first ${maxFiles} code files are scanned`);
+  const known = new Set(walked.files);
+  const configDirs = walked.configs.map((path) => dirname(path));
+  const assigned = new Set;
+  const cache = new Map;
+  const entries = [];
+  const owner = new Map;
+  const create = (rootNames, owned, compilerOptions, configPath) => {
+    const host = sharedHost(compilerOptions, cache);
+    let program;
+    try {
+      program = import_typescript5.default.createProgram({ rootNames, options: compilerOptions, host });
+    } catch (error) {
+      warnings.push(`program ${configPath ?? "(fallback)"}: ${error.message}`);
       return;
-    const roles = [];
-    for (const body of effectiveField(request, "body")) {
-      for (const [key, role] of Object.entries(GATEWAY_BODY_KEYS)) {
-        if (body.key) {
-          roles.push({ role, node: body.node, key: `${body.key}.${key}` });
-          continue;
-        }
-        const literal = unwrap(body.node);
-        if (!import_typescript5.default.isObjectLiteralExpression(literal)) {
-          roles.push({ role, node: body.node, key });
-          continue;
-        }
-        for (const field of effectiveField(literal, key))
-          roles.push({ role, ...field });
-      }
     }
-    for (const field of effectiveField(request, "prompt"))
-      roles.push({ role: "prompt", ...field });
-    return roles.length > 0 ? { api: `models.${callee.name.text}`, roles } : undefined;
+    let checker;
+    const entry = {
+      program,
+      configPath,
+      owned,
+      checker: () => checker ??= program.getTypeChecker()
+    };
+    entries.push(entry);
+    for (const file of owned)
+      owner.set(file, entry);
+  };
+  const configs = [...walked.configs].sort((a, b) => b.split(/[\\/]/).length - a.split(/[\\/]/).length || a.localeCompare(b));
+  for (const configPath of configs) {
+    const parsed = parseConfig(configPath, warnings, root);
+    if (!parsed)
+      continue;
+    const dir = dirname(configPath);
+    const nested = configDirs.filter((other) => other !== dir && isUnder(other, dir));
+    const underDir = (file) => isUnder(file, dir) && !nested.some((other) => isUnder(file, other));
+    const included = parsed.fileNames ? [...parsed.fileNames.filter((file) => known.has(file)), ...walked.files.filter((file) => file.endsWith(SVELTE_VIRTUAL_SUFFIX) && underDir(file))] : walked.files.filter(underDir);
+    const owned = included.filter((file) => !assigned.has(file));
+    if (owned.length === 0)
+      continue;
+    for (const file of owned)
+      assigned.add(file);
+    create(included, owned, extractorOptions(parsed.options), relative2(root, configPath).split("\\").join("/"));
   }
-};
-var CALL_SINKS = [modelGatewaySink, realtimeEventSink, anthropicSink, openaiSink, aiSdkSink, workersAiSink, fetchSink, websocketSink, providerFactorySink, agentEntrySink, clientChatSink, hostedModelSink];
-function registerCallSink(recognizer) {
-  CALL_SINKS.push(recognizer);
-}
-function classSinks(memo) {
-  return [hookSink(memo), ...EXTRA_CLASS_SINKS];
-}
-var EXTRA_CLASS_SINKS = [];
-function registerClassSink(recognizer) {
-  EXTRA_CLASS_SINKS.push(recognizer);
+  const rest = walked.files.filter((file) => !assigned.has(file));
+  if (rest.length > 0)
+    create(rest, rest, FALLBACK_OPTIONS);
+  return { rootDir: root, entries, owner, files: assigned.size + rest.length, warnings };
 }
 
 // src/harness-extract/emit-models.ts
@@ -17638,9 +17723,10 @@ function promoteEvalSuites(files, confidence2, naming) {
 var import_typescript8 = __toESM(require_typescript(), 1);
 import { dirname as dirname7, relative as relative8, resolve as resolvePath } from "node:path";
 var DEFAULT_MAX_DEPTH = 24;
-var DEFAULT_MAX_PARAM_LEVELS = 3;
+var DEFAULT_MAX_PARAM_LEVELS = 8;
 var PROMPT_FIELDS = new Set([
   "content",
+  "parts",
   "text",
   "system",
   "prompt",
@@ -18020,6 +18106,18 @@ class PromptResolver {
       return;
     }
     if (import_typescript8.default.isArrayLiteralExpression(expr)) {
+      if (/^\d+$/.test(walk.project[0] ?? "")) {
+        const [index, ...rest] = walk.project;
+        const selected = Number(index);
+        if (expr.elements.slice(0, selected + 1).some(import_typescript8.default.isSpreadElement)) {
+          this.markUnresolved(expr, "dynamic-key", walk);
+          return;
+        }
+        const element = expr.elements[selected];
+        if (element)
+          this.value(element, owner, { ...walk, project: rest });
+        return;
+      }
       for (const element of expr.elements) {
         this.value(import_typescript8.default.isSpreadElement(element) ? element.expression : element, owner, walk);
       }
@@ -18077,6 +18175,48 @@ class PromptResolver {
       }
       return;
     }
+    if (walk.messageParts) {
+      const field = (expression, key, seen = new Set) => {
+        const node = unwrap2(expression);
+        if (seen.has(node))
+          return { known: false };
+        const next = new Set(seen).add(node);
+        if (import_typescript8.default.isIdentifier(node)) {
+          const declaration = this.declarationsOf(node).find((entry) => import_typescript8.default.isVariableDeclaration(entry) && entry.initializer);
+          return declaration && import_typescript8.default.isVariableDeclaration(declaration) && declaration.initializer ? field(declaration.initializer, key, next) : { known: false };
+        }
+        if (!import_typescript8.default.isObjectLiteralExpression(node))
+          return { known: false };
+        for (const property of [...node.properties].reverse()) {
+          if (import_typescript8.default.isSpreadAssignment(property)) {
+            const spread = field(property.expression, key, next);
+            if (spread.value || !spread.known)
+              return spread;
+          } else if (propertyName(property) === key) {
+            return { known: true, value: import_typescript8.default.isPropertyAssignment(property) ? property.initializer : import_typescript8.default.isShorthandPropertyAssignment(property) ? property.name : undefined };
+          }
+        }
+        return { known: true };
+      };
+      const literalString = (expression, seen = new Set) => {
+        if (!expression || seen.has(expression))
+          return;
+        const node = unwrap2(expression);
+        if (import_typescript8.default.isStringLiteralLike(node))
+          return node.text;
+        if (!import_typescript8.default.isIdentifier(node))
+          return;
+        const declaration = this.declarationsOf(node).find((entry) => import_typescript8.default.isVariableDeclaration(entry) && entry.initializer);
+        return declaration && import_typescript8.default.isVariableDeclaration(declaration) ? literalString(declaration.initializer, new Set(seen).add(expression)) : undefined;
+      };
+      const partType = literalString(field(object, "type").value);
+      if (partType === "text" || partType === "input_text") {
+        const text = field(object, "text").value;
+        if (text)
+          this.value(text, { node: text, kind: "message" }, { ...walk, messageParts: false, promptObject: false });
+      }
+      return;
+    }
     const role = stringField(object, "role");
     if (role && /^(?:assistant|tool|function|model)$/.test(role))
       return;
@@ -18095,7 +18235,7 @@ class PromptResolver {
         }
         continue;
       }
-      const inner = PROMPT_FIELDS.has(key) && !/^(?:content|text|messages|user|system|prompt)$/.test(key) ? { ...walk, promptObject: true } : walk;
+      const inner = key === "parts" ? { ...walk, messageParts: true, promptObject: false } : PROMPT_FIELDS.has(key) && !/^(?:content|text|messages|user|system|prompt)$/.test(key) ? { ...walk, promptObject: true } : walk;
       if (import_typescript8.default.isPropertyAssignment(property)) {
         const kind = role ? "message" : "literal";
         this.value(property.initializer, { node: property, name: role ? undefined : key, kind }, this.messageRole(inner, role));
@@ -18143,7 +18283,7 @@ class PromptResolver {
         this.declaration(declaration, access, owner, walk);
       return;
     }
-    if (walk.project.length === 0 && !PROMPT_FIELD_NAME.test(access.name.text))
+    if (walk.project.length === 0 && !PROMPT_FIELD_NAME.test(access.name.text) && !(walk.role !== "tool-result" && /^messages?$/.test(access.name.text)))
       return;
     this.value(access.expression, owner, { ...flag(walk, "projected"), project: [access.name.text, ...walk.project] });
   }
@@ -18185,7 +18325,7 @@ class PromptResolver {
     }
   }
   call(call, owner, walk) {
-    const callee = call.expression;
+    const callee = unwrap2(call.expression);
     if (import_typescript8.default.isPropertyAccessExpression(callee)) {
       const method = callee.name.text;
       if (method === "finally") {
@@ -18220,7 +18360,24 @@ class PromptResolver {
         this.value(argument, owner, walk);
       return;
     }
+    if (import_typescript8.default.isArrowFunction(callee) || import_typescript8.default.isFunctionExpression(callee)) {
+      const next = this.step(walk, callee, `immediately invoked builder at ${this.where(call)}`);
+      if (!next || walk.seen.has(callee))
+        return;
+      next.bindings = new Map(next.bindings);
+      bindParameters(callee, call.arguments, walk.bindings, next.bindings);
+      this.builderBody(callee, { node: callee, kind: "builder" }, next);
+      return;
+    }
+    if (import_typescript8.default.isPropertyAccessExpression(callee) && /^Promise\.(?:resolve|all)$/.test(callee.getText()) && call.arguments[0]) {
+      this.value(call.arguments[0], owner, walk);
+      return;
+    }
     const declarations = this.declarationsOf(import_typescript8.default.isPropertyAccessExpression(callee) ? callee.name : callee);
+    if (call.arguments.length === 0 && declarations.some((declaration) => import_typescript8.default.isParameter(declaration) || import_typescript8.default.isBindingElement(declaration) && isParameterBinding(declaration))) {
+      this.value(callee, owner, walk);
+      return;
+    }
     let functions = declarations.map(functionOf).filter((fn) => Boolean(fn));
     if (functions.length === 0 && import_typescript8.default.isPropertyAccessExpression(callee)) {
       const methods = this.methodsNamed(callee.name.text);
@@ -18279,16 +18436,110 @@ class PromptResolver {
     if (!next)
       return;
     next.seen = new Set(next.seen).add(declaration);
+    if (import_typescript8.default.isBindingElement(declaration)) {
+      const fields = [];
+      let current = declaration;
+      let root;
+      for (;; ) {
+        const pattern = current.parent;
+        if (!import_typescript8.default.isObjectBindingPattern(pattern) && !import_typescript8.default.isArrayBindingPattern(pattern))
+          break;
+        if (current.dotDotDotToken) {
+          if (!import_typescript8.default.isObjectBindingPattern(pattern) || next.project.length === 0 || pattern.elements.some((entry) => entry !== current && bindingField(entry) === next.project[0])) {
+            this.markUnresolved(at, "dynamic-key", next);
+            return;
+          }
+        } else {
+          const field = import_typescript8.default.isArrayBindingPattern(pattern) ? String(pattern.elements.indexOf(current)) : bindingField(current);
+          if (field === undefined)
+            break;
+          fields.unshift(field);
+        }
+        const holder = pattern.parent;
+        if (import_typescript8.default.isVariableDeclaration(holder)) {
+          root = holder;
+          break;
+        }
+        if (!import_typescript8.default.isBindingElement(holder))
+          break;
+        current = holder;
+      }
+      if (declaration.initializer) {
+        const checker = this.context.checkerFor(this.relative(declaration.getSourceFile().fileName));
+        let selected = root?.initializer && checker?.getTypeAtLocation(root.initializer);
+        let optional = false;
+        for (const field of fields) {
+          const property = selected?.getProperty(field);
+          optional ||= !!property && (property.flags & import_typescript8.default.SymbolFlags.Optional) !== 0 && !(root?.initializer && import_typescript8.default.isObjectLiteralExpression(unwrap2(root.initializer)));
+          selected = property && checker ? checker.getTypeOfSymbolAtLocation(property, root.initializer) : undefined;
+        }
+        let literal = root?.initializer ? unwrap2(root.initializer) : undefined;
+        for (const field of fields) {
+          if (literal && import_typescript8.default.isObjectLiteralExpression(literal)) {
+            const property = literal.properties.find((entry) => propertyName(entry) === field);
+            literal = property && import_typescript8.default.isPropertyAssignment(property) ? unwrap2(property.initializer) : property && import_typescript8.default.isShorthandPropertyAssignment(property) ? property.name : undefined;
+          } else if (literal && import_typescript8.default.isArrayLiteralExpression(literal)) {
+            const element = literal.elements[Number(field)];
+            literal = element && !import_typescript8.default.isOmittedExpression(element) && !import_typescript8.default.isSpreadElement(element) ? unwrap2(element) : undefined;
+          } else
+            literal = undefined;
+        }
+        if (literal && checker) {
+          selected = checker.getTypeAtLocation(literal);
+          optional = false;
+        }
+        const mayBeUndefined = optional || !selected || (selected.flags & (import_typescript8.default.TypeFlags.Any | import_typescript8.default.TypeFlags.Unknown | import_typescript8.default.TypeFlags.Undefined | import_typescript8.default.TypeFlags.Void)) !== 0 || selected.isUnion() && selected.types.some((type) => (type.flags & (import_typescript8.default.TypeFlags.Undefined | import_typescript8.default.TypeFlags.Void)) !== 0);
+        if (mayBeUndefined)
+          this.value(declaration.initializer, owner, next);
+      }
+      if (root?.initializer)
+        this.value(root.initializer, owner, { ...next, project: [...fields, ...next.project] });
+      else
+        this.markUnresolved(at, "param-unbound", next);
+      return;
+    }
     if (import_typescript8.default.isVariableDeclaration(declaration)) {
+      if (!owner && next.flags.includes("interpolated") && declaration.initializer) {
+        let scope = declaration.parent;
+        while (scope && !import_typescript8.default.isFunctionLike(scope))
+          scope = scope.parent;
+        const pieces = [];
+        const fragment = (node) => {
+          const value = unwrap2(node);
+          if (import_typescript8.default.isStringLiteral(value) || import_typescript8.default.isNoSubstitutionTemplateLiteral(value)) {
+            pieces.push(value.text);
+            return true;
+          }
+          if (import_typescript8.default.isTemplateExpression(value)) {
+            pieces.push(value.head.text, ...value.templateSpans.map((span) => span.literal.text));
+            return true;
+          }
+          if (import_typescript8.default.isConditionalExpression(value))
+            return fragment(value.whenTrue) && fragment(value.whenFalse);
+          return false;
+        };
+        const localFragment = fragment(declaration.initializer);
+        const instructionPieces = pieces.map((piece) => piece.replace(/\byou\b(?!['’](?:re|ve|ll|d)\b|\s+(?:are|must|should|need|will|can|may|have to)\b)/gi, ""));
+        if (scope && import_typescript8.default.isFunctionLike(scope) && contains(scope, at) && localFragment && !hasDirective(instructionPieces.join(`
+`)) && !toolResultIsPrompt(declaration, instructionPieces)) {
+          const fnName = scope.name && import_typescript8.default.isIdentifier(scope.name) ? scope.name.text : undefined;
+          owner = { node: scope, name: fnName, kind: "builder" };
+        }
+      }
       if (declaration.initializer) {
         const fn2 = unwrap2(declaration.initializer);
         if (import_typescript8.default.isArrowFunction(fn2) || import_typescript8.default.isFunctionExpression(fn2)) {
           this.builderBody(fn2, { node: declaration, name, kind: "builder" }, next);
         } else {
-          this.value(declaration.initializer, ownerFor(declaration, name, owner), next);
+          const source = unwrap2(declaration.initializer);
+          const checker = this.context.checkerFor(this.relative(source.getSourceFile().fileName));
+          const sourceType = checker?.getTypeAtLocation(source);
+          const sharesArray = sourceType && checker && (sourceType.isUnion() ? sourceType.types : [sourceType]).every((type) => checker.isArrayType(type) || checker.isTupleType(type));
+          const aliasWalk = import_typescript8.default.isIdentifier(source) && sharesArray ? { ...next, assemblyReadAt: next.assemblyReadAt ?? at } : { ...next, assemblyReadAt: undefined };
+          this.value(declaration.initializer, ownerFor(declaration, name, owner), aliasWalk);
         }
       }
-      this.assembly(declaration, ownerFor(declaration, name, owner), next);
+      this.assembly(declaration, ownerFor(declaration, name, owner), next, at);
       return;
     }
     if (import_typescript8.default.isPropertyAssignment(declaration)) {
@@ -18321,21 +18572,177 @@ class PromptResolver {
     if (fn)
       this.builderBody(fn, { node: declaration, name, kind: "builder" }, next);
   }
-  assembly(declaration, owner, walk) {
+  assembly(declaration, owner, walk, at) {
     if (!import_typescript8.default.isIdentifier(declaration.name))
       return;
-    const name = declaration.name.text;
     const scope = enclosingScope2(declaration);
     if (!scope)
       return;
-    const isThis = (identifier) => identifier.text === name && this.declarationsOf(identifier).includes(declaration);
+    const assignments = [];
+    const findRebinding = (node) => {
+      if (import_typescript8.default.isFunctionLike(node))
+        return;
+      if (import_typescript8.default.isBinaryExpression(node) && node.operatorToken.kind === import_typescript8.default.SyntaxKind.EqualsToken && import_typescript8.default.isIdentifier(node.left) && this.declarationsOf(node.left).includes(declaration))
+        assignments.push(node);
+      import_typescript8.default.forEachChild(node, findRebinding);
+    };
+    findRebinding(scope);
+    const conditional = (assignment) => {
+      for (let node = assignment.parent;node && node !== scope; node = node.parent) {
+        if (import_typescript8.default.isIfStatement(node) || import_typescript8.default.isConditionalExpression(node) || import_typescript8.default.isSwitchStatement(node) || import_typescript8.default.isIterationStatement(node, false) || import_typescript8.default.isTryStatement(node))
+          return true;
+      }
+      return false;
+    };
+    const loopAncestors = (node) => {
+      const loops = new Set;
+      for (let parent = node.parent;parent && parent !== scope; parent = parent.parent) {
+        if (import_typescript8.default.isFunctionLike(parent))
+          break;
+        if (import_typescript8.default.isIterationStatement(parent, false))
+          loops.add(parent);
+      }
+      return loops;
+    };
+    const versionsAt = (node) => {
+      const versions = new Set([declaration]);
+      const loops = loopAncestors(node);
+      for (const assignment of assignments) {
+        const loopBack = [...loopAncestors(assignment)].some((loop) => loops.has(loop));
+        if (assignment.end > node.getStart() && !loopBack)
+          continue;
+        if (!conditional(assignment))
+          versions.clear();
+        versions.add(assignment);
+      }
+      return versions;
+    };
+    const identities = (expression, seen = new Set) => {
+      const value = unwrap2(expression);
+      if (seen.has(value))
+        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));
+        if (entry === declaration)
+          return versionsAt(value);
+        if (entry && import_typescript8.default.isVariableDeclaration(entry) && entry.initializer && entry.parent.flags & import_typescript8.default.NodeFlags.Const)
+          return identities(entry.initializer, next);
+        return new Set;
+      }
+      if (import_typescript8.default.isConditionalExpression(value))
+        return new Set([...identities(value.whenTrue, next), ...identities(value.whenFalse, next)]);
+      if (import_typescript8.default.isBinaryExpression(value) && (value.operatorToken.kind === import_typescript8.default.SyntaxKind.BarBarToken || value.operatorToken.kind === import_typescript8.default.SyntaxKind.QuestionQuestionToken))
+        return new Set([...identities(value.left, next), ...identities(value.right, next)]);
+      return new Set;
+    };
+    const readVersions = new Map([...versionsAt(at)].map((version) => [version, (walk.assemblyReadAt ?? at).getStart()]));
+    for (let round = 0;round < 8; round += 1) {
+      let changed = false;
+      for (const [version] of [...readVersions]) {
+        if (!import_typescript8.default.isBinaryExpression(version))
+          continue;
+        const predecessors = new Set;
+        const visit2 = (node) => {
+          if (import_typescript8.default.isFunctionLike(node))
+            return;
+          if (import_typescript8.default.isIdentifier(node))
+            for (const identity2 of identities(node))
+              predecessors.add(identity2);
+          import_typescript8.default.forEachChild(node, visit2);
+        };
+        visit2(version.right);
+        for (const previous of predecessors) {
+          const cutoff = version.getStart();
+          if ((readVersions.get(previous) ?? -1) < cutoff) {
+            readVersions.set(previous, cutoff);
+            changed = true;
+          }
+        }
+      }
+      if (!changed)
+        break;
+    }
+    const references = (expression) => [...identities(expression)].some((version) => (readVersions.get(version) ?? -1) >= expression.getStart());
+    const invoked = (fn, seen = new Set) => {
+      if (seen.has(fn))
+        return false;
+      const next = new Set(seen).add(fn);
+      let expression = fn;
+      while (import_typescript8.default.isParenthesizedExpression(expression.parent))
+        expression = expression.parent;
+      const parentCall = expression.parent;
+      const reachableCall = (call) => {
+        if (call.getSourceFile() !== scope.getSourceFile() || !contains(scope, call))
+          return false;
+        for (let parent = call.parent;parent && parent !== scope; parent = parent.parent) {
+          if (import_typescript8.default.isFunctionLike(parent))
+            return invoked(parent, next);
+        }
+        return true;
+      };
+      if (import_typescript8.default.isCallExpression(parentCall)) {
+        if (parentCall.expression === expression)
+          return reachableCall(parentCall);
+        if (import_typescript8.default.isPropertyAccessExpression(parentCall.expression) && parentCall.arguments.some((argument) => argument === expression)) {
+          const method = parentCall.expression.name.text;
+          if (/^(?:forEach|map|flatMap|filter|reduce|reduceRight|some|every|find|findIndex)$/.test(method)) {
+            return reachableCall(parentCall);
+          }
+          if (/^(?:then|catch|finally)$/.test(method)) {
+            const completed = (value, seen2 = new Set) => {
+              if (seen2.has(value))
+                return false;
+              const visited = new Set(seen2).add(value);
+              let completion = value;
+              while (import_typescript8.default.isParenthesizedExpression(completion.parent))
+                completion = completion.parent;
+              const parent = completion.parent;
+              if (import_typescript8.default.isAwaitExpression(parent)) {
+                return parent.end <= (walk.assemblyReadAt ?? at).getStart();
+              }
+              if (import_typescript8.default.isPropertyAccessExpression(parent) && parent.expression === completion && /^(?:then|catch|finally)$/.test(parent.name.text) && import_typescript8.default.isCallExpression(parent.parent) && parent.parent.expression === parent) {
+                return completed(parent.parent, visited);
+              }
+              if (!import_typescript8.default.isVariableDeclaration(parent) || parent.initializer !== completion || !import_typescript8.default.isIdentifier(parent.name) || !(parent.parent.flags & import_typescript8.default.NodeFlags.Const))
+                return false;
+              let found = false;
+              const findCompletion = (node) => {
+                if (found || import_typescript8.default.isFunctionLike(node))
+                  return;
+                if (import_typescript8.default.isIdentifier(node) && node !== parent.name && node.getStart() > parent.end && this.declarationsOf(node).includes(parent) && completed(node, visited)) {
+                  found = true;
+                  return;
+                }
+                import_typescript8.default.forEachChild(node, findCompletion);
+              };
+              findCompletion(scope);
+              return found;
+            };
+            return completed(parentCall) && reachableCall(parentCall);
+          }
+        }
+      }
+      return this.callersOf(fn).some((call) => {
+        if (call.getSourceFile() !== scope.getSourceFile() || !contains(scope, call))
+          return false;
+        for (let parent = call.parent;parent && parent !== scope; parent = parent.parent) {
+          if (import_typescript8.default.isFunctionLike(parent))
+            return invoked(parent, next);
+        }
+        return true;
+      });
+    };
+    const isThis = (identifier) => references(identifier);
     const visit = (node) => {
-      if (import_typescript8.default.isCallExpression(node) && import_typescript8.default.isPropertyAccessExpression(node.expression) && import_typescript8.default.isIdentifier(node.expression.expression) && isThis(node.expression.expression) && /^(?:push|unshift|splice)$/.test(node.expression.name.text)) {
+      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)) {
         const args = node.expression.name.text === "splice" ? node.arguments.slice(2) : node.arguments;
         for (const argument of args)
           this.value(argument, owner, walk);
       }
-      if (import_typescript8.default.isBinaryExpression(node) && import_typescript8.default.isIdentifier(node.left) && isThis(node.left)) {
+      if (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)
@@ -18404,15 +18811,14 @@ class PromptResolver {
     const signatures = this.implementedSignatures(fn, name);
     return candidates.filter((call) => {
       const callee = import_typescript8.default.isPropertyAccessExpression(call.expression) ? call.expression.name : call.expression;
-      return this.declarationsOf(callee).some((declaration) => functionOf(declaration) === fn || declaration === fn || signatures.has(declaration));
+      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));
     });
   }
   implementedSignatures(fn, name) {
-    if (!import_typescript8.default.isMethodDeclaration(fn) || !import_typescript8.default.isObjectLiteralExpression(fn.parent))
-      return new Set;
     const checker = this.context.checkerFor(this.relative(fn.getSourceFile().fileName));
-    const property = checker?.getContextualType(fn.parent)?.getProperty(name);
-    return new Set((property?.declarations ?? []).filter(import_typescript8.default.isMethodSignature));
+    return checker ? contextualSignatures(fn, name, checker) : new Set;
   }
   sourceFiles() {
     const byName = new Map;
@@ -18923,6 +19329,7 @@ var HARNESS_FAMILY_FLAGS = [
   "analyst-model",
   "assist",
   "concern",
+  "deterministic-floor",
   "dry-run",
   "experimental",
   "from",
@@ -18937,6 +19344,7 @@ var HARNESS_FAMILY_FLAGS = [
   "path",
   "promote",
   "remote",
+  "repair",
   "report",
   "run",
   "run-id",
@@ -19222,7 +19630,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-96tgqbwb.js");
+        const { runGithubActionsAnalyze } = await import("./harness-github-actions-gt4qawvp.js");
         const result = await runGithubActionsAnalyze(rootDir, {
           writeReport: (report2) => {
             const normalized = normalizeHarnessReport(report2);
@@ -19261,7 +19669,12 @@ async function runHarnessCommand(context) {
         elapsed_ms: Date.now() - context.startedAt
       });
       writeHumanProgress(context, "Moda Analyst: inventorying local harness files...");
-      const graph = scanHarness({
+      const graph = context.flags["deterministic-floor"] === "true" ? await deterministicFloorGraph(rootDir, {
+        dryRun: context.dryRun,
+        tenantId: tenant?.tenantId,
+        tenantSource: tenant?.source,
+        pathWasExplicit: context.flags.path !== undefined
+      }) : scanHarness({
         rootDir,
         dryRun: context.dryRun,
         tenantId: tenant?.tenantId,
@@ -19316,7 +19729,7 @@ async function runHarnessCommand(context) {
     }
     case "validate-report": {
       const reportPath = resolveHarnessReportPath(rootDir, context.positionals[1] ?? context.flags.report);
-      const report = readHarnessReport(reportPath);
+      const report = context.flags.repair === "true" ? repairExternalAnalystReport(JSON.parse(readFileSync12(reportPath, "utf8")), rootDir) : readHarnessReport(reportPath);
       const validation = validateHarnessReport(report, rootDir, {
         deterministicFloor: computeDeterministicFloor(rootDir)
       });
@@ -19368,8 +19781,8 @@ async function runHarnessCommand(context) {
         }
         const { artifacts, unknowns } = deterministicGraphItems(rootDir, promote === "all" ? undefined : promote);
         tagComponentStatus({ runtimeAgents: [], artifacts }, rootDir);
-        const { extractHarnessWithContext: extractHarnessWithContext2 } = await import("./index-tze518d6.js");
-        const { enumerateHarnessComponents, mergeEnumeratedComponents } = await import("./index-psa47r72.js");
+        const { extractHarnessWithContext: extractHarnessWithContext2 } = await import("./index-xhcqg43k.js");
+        const { enumerateHarnessComponents, mergeEnumeratedComponents } = await import("./index-n43wbr24.js");
         let components = { runtimeAgents: [], artifacts: [], warnings: [] };
         if (promote === "all" || promote === "topology" || promote === "tools") {
           const { result, ctx } = extractHarnessWithContext2(rootDir);
@@ -19403,8 +19816,8 @@ async function runHarnessCommand(context) {
     }
     case "extract": {
       writeHumanProgress(context, "Harness extract: tracing model call sites (no LLM, no network)...");
-      const { extractHarnessWithContext: extractHarnessWithContext2, serializeExtractResult } = await import("./index-tze518d6.js");
-      const { enumerateHarnessComponents, mergeEnumeratedComponents } = await import("./index-psa47r72.js");
+      const { extractHarnessWithContext: extractHarnessWithContext2, serializeExtractResult } = await import("./index-xhcqg43k.js");
+      const { enumerateHarnessComponents, mergeEnumeratedComponents } = await import("./index-n43wbr24.js");
       const { result, ctx } = extractHarnessWithContext2(rootDir, { fresh: true });
       const artifacts = deterministicArtifacts(rootDir);
       tagComponentStatus({ runtimeAgents: [], artifacts }, rootDir);
@@ -20119,6 +20532,7 @@ function removeArtifacts(report, ids) {
 }
 function repairExternalAnalystReport(report, rootDir, options = {}) {
   const normalized = normalizeHarnessReport(report);
+  normalized.graph.artifacts = normalized.graph.artifacts.filter((artifact) => !(/^__(?:END|BEGIN|START)__$/i.test(artifact.id) && artifact.type === "unknown" && artifact.name === artifact.id && artifact.scope === "shared" && artifact.confidence === 0.5 && artifact.usedByAgentIds?.length === 0 && Object.keys(artifact).every((key) => ["id", "type", "name", "scope", "confidence", "usedByAgentIds"].includes(key))));
   repairCitationLines(normalized, rootDir);
   mergeDeterministicReplacement(normalized, rootDir, options);
   if (!options.concern || options.concern === "topology")
@@ -20281,6 +20695,30 @@ var CONCERN_PROMOTED_ARTIFACT_TYPES = {
   prompts: new Set(["prompt"]),
   evals: new Set(["model_config", "eval"])
 };
+async function deterministicFloorGraph(rootDir, options = {}) {
+  const { extractHarnessWithContext: extractHarnessWithContext2 } = await import("./index-xhcqg43k.js");
+  const { enumerateHarnessComponents, mergeEnumeratedComponents } = await import("./index-n43wbr24.js");
+  const { result, ctx } = extractHarnessWithContext2(rootDir);
+  const items = deterministicGraphItems(rootDir);
+  const components = mergeEnumeratedComponents(items.artifacts, enumerateHarnessComponents(result, ctx));
+  const metadata = scanHarness({ ...options, rootDir });
+  const graph = {
+    ...metadata,
+    agentFamilies: [],
+    runtimeAgents: components.runtimeAgents,
+    artifacts: components.artifacts,
+    relationships: [],
+    unknowns: items.unknowns,
+    channelAdapters: [],
+    identityNamespaces: [],
+    deployments: []
+  };
+  hydratePromptAndToolBodies(graph, rootDir);
+  tagComponentStatus(graph, rootDir);
+  deriveRelationshipsFromGraph(graph);
+  enrichScanCaptureMetadata(graph);
+  return graph;
+}
 function deterministicArtifacts(rootDir, concern) {
   return deterministicGraphItems(rootDir, concern).artifacts;
 }
@@ -29618,4 +30056,4 @@ function mergeEnumeratedComponents(artifacts, components) {
   return { runtimeAgents, artifacts: output };
 }
 
-export { startRemoteAnalyze, pollRemoteAnalyzeUntilDone, isRecoverableRemoteRun, checkPromptMapping, safePromptEvidencePath, discoverHarnessPromptSources, valueChildren, selectKey, allValues, renderings, CALL_SINKS, registerCallSink, registerClassSink, isModelId, collectModels, modelArtifacts, modelUnknowns, collectModelLiterals, agentForScope, createAgentScopeResolver, enumerateAgents, toolNamesOf, EXTRACT_SCHEMA_VERSION, enumerateWorkflows, enumerateToolCatalog, ENUMERATORS, enumerateHarnessComponents, mergeEnumeratedComponents, clearExtractCache, extractHarness, extractHarnessWithContext, scopeOf, serializeExtractResult, runEnumerators, assignAgentIds, runHarnessCommand, writeHarnessAnalyzeResult, emitWrittenArtifacts, analyzeHarnessPrompts, isToolGroupPlaceholder, deterministicOnlyArtifactTypes, repairExternalAnalystReport, deriveRelationshipsFromGraph, deterministicArtifacts, deterministicGraphItems, mergeDeterministicArtifacts, analystRefutations, describeCodingAgentEvent, analystEventProgress, isRetryableExternalAnalystFailure, sleep, summarizeInvalidAnalystReport, isDeterministicLocalAnalyst, resolveHarnessAnalyzeConcern, resolveExternalHarnessAnalystInvocation, detectAvailableCodingAgents, codingAgentDisplayName, runCodingAgent, readOnlyClaudeExtraArgs, resolveAnalystModel, renderExternalHarnessAnalystPrompt, CONCERN_CANDIDATE_KINDS, SEED_CANDIDATE_KIND_LABELS, renderAnalystCandidateLines, renderAnalystSeedLines, truncateText, scanHarness, summarizeHarness, buildSourceSnapshot, writeHumanProgress, describeSyncIdentity, describeSyncTenantLabel, findFresherHarnessReports, writeHarnessArtifacts, assertHarnessGraphSyncQuality, graphForSync, inventoryFiles, numericEnv, numericEnvAllowZero, computeDeterministicFloor, stableId, titleFromId, promptNameFromPath };
+export { startRemoteAnalyze, pollRemoteAnalyzeUntilDone, isRecoverableRemoteRun, checkPromptMapping, safePromptEvidencePath, discoverHarnessPromptSources, valueChildren, selectKey, allValues, renderings, CALL_SINKS, registerCallSink, registerClassSink, isModelId, collectModels, modelArtifacts, modelUnknowns, collectModelLiterals, agentForScope, createAgentScopeResolver, enumerateAgents, toolNamesOf, EXTRACT_SCHEMA_VERSION, enumerateWorkflows, enumerateToolCatalog, ENUMERATORS, enumerateHarnessComponents, mergeEnumeratedComponents, clearExtractCache, extractHarness, extractHarnessWithContext, scopeOf, serializeExtractResult, runEnumerators, assignAgentIds, runHarnessCommand, writeHarnessAnalyzeResult, emitWrittenArtifacts, analyzeHarnessPrompts, isToolGroupPlaceholder, deterministicOnlyArtifactTypes, repairExternalAnalystReport, deriveRelationshipsFromGraph, deterministicFloorGraph, deterministicArtifacts, deterministicGraphItems, mergeDeterministicArtifacts, analystRefutations, describeCodingAgentEvent, analystEventProgress, isRetryableExternalAnalystFailure, sleep, summarizeInvalidAnalystReport, isDeterministicLocalAnalyst, resolveHarnessAnalyzeConcern, resolveExternalHarnessAnalystInvocation, detectAvailableCodingAgents, codingAgentDisplayName, runCodingAgent, readOnlyClaudeExtraArgs, resolveAnalystModel, renderExternalHarnessAnalystPrompt, CONCERN_CANDIDATE_KINDS, SEED_CANDIDATE_KIND_LABELS, renderAnalystCandidateLines, renderAnalystSeedLines, truncateText, scanHarness, summarizeHarness, buildSourceSnapshot, writeHumanProgress, describeSyncIdentity, describeSyncTenantLabel, findFresherHarnessReports, writeHarnessArtifacts, assertHarnessGraphSyncQuality, graphForSync, inventoryFiles, numericEnv, numericEnvAllowZero, computeDeterministicFloor, stableId, titleFromId, promptNameFromPath };