@moda-ai/cli 1.55.63 → 1.55.64

package/dist/{cli-xmv0fark.js → cli-rec661n7.js}

@@ -94,6 +94,9 @@ import {
   redactDeep,
   shouldInventoryFile
 } from "./cli-9a4b1wxz.js";
+import {
+  extractHarnessWithContext
+} from "./cli-vqhaj5tv.js";
 import {
   mergeBoundRuntimeClasses,
   tagComponentStatus
@@ -121,7 +124,7 @@ import {
   writeFileSync as writeFileSync5,
   rmSync as rmSync4
 } from "node:fs";
-import { basename as basename7, delimiter, dirname as dirname7, join as join9, relative as relative6, resolve as resolve10, sep as sep5 } from "node:path";
+import { basename as basename7, delimiter, dirname as dirname7, join as join9, relative as relative7, resolve as resolve10, sep as sep5 } from "node:path";
 import { confirm, select } from "@inquirer/prompts";
 
 // src/analyst-tui.ts
@@ -15470,6 +15473,1092 @@ function promoteAll(report, rootDir) {
   return [...byId.values()];
 }
 
+// src/harness-extract/prompts/resolver.ts
+var import_typescript3 = __toESM(require_typescript(), 1);
+import { relative as relative6 } from "node:path";
+var DEFAULT_MAX_DEPTH = 24;
+var DEFAULT_MAX_PARAM_LEVELS = 3;
+var PROMPT_FIELDS = new Set([
+  "content",
+  "text",
+  "system",
+  "prompt",
+  "instructions",
+  "instruction",
+  "systemPrompt",
+  "system_prompt",
+  "systemMessage",
+  "system_message",
+  "systemInstruction",
+  "system_instruction",
+  "messages",
+  "user",
+  "question",
+  "questions",
+  "task",
+  "brief",
+  "criteria",
+  "rubric",
+  "template",
+  "backstory",
+  "goal",
+  "provider",
+  "get",
+  "render"
+]);
+var PROMPT_FIELD_NAME = /(?:prompt|instructions?|system|brief|intent|task|questions?|directive|guidance|rules?|context|section|block|persona|role|criteria|rubric|template|content|text|preamble|framing|nudge|reminder|policy)$/i;
+var TEXT_PRESERVING_METHODS = new Set([
+  "trim",
+  "trimStart",
+  "trimEnd",
+  "replace",
+  "replaceAll",
+  "concat",
+  "slice",
+  "toString",
+  "normalize",
+  "padEnd",
+  "padStart"
+]);
+var ARRAY_ASSEMBLY_METHODS = new Set(["join", "concat", "flat", "filter", "slice", "reverse", "sort", "toSorted"]);
+var CALLBACK_METHODS = new Set(["map", "flatMap", "then", "catch"]);
+var TEST_SOURCE = /(?:^|\/)(?:__tests__|__mocks__|fixtures?|test-fixtures)\/|(?:^|\/)[^/]*\.(?:test|spec)\.[^/]+$/i;
+var LOCAL_ONLY_SITE = /^(?:scripts|evals?)\//;
+function readsAsInstructions2(text) {
+  const plain = text.replace(/\{\{[^}]*\}\}/g, " x ");
+  if (/^\s*(?:SELECT|WITH|INSERT|UPDATE|DELETE|CREATE|ALTER)\b/i.test(plain))
+    return false;
+  if (/^\s*(?:https?:\/\/|\/[\w-]+\/)\S*\s*$/.test(plain))
+    return false;
+  if (/^[\s\w,.()'"=]+$/.test(plain) && (plain.match(/,/g) ?? []).length >= 3 && !/[.!?:]\s/.test(plain))
+    return false;
+  if ((plain.match(/[{};=]/g) ?? []).length > plain.length / 25)
+    return false;
+  const words = plain.match(/[A-Za-z]{2,}/g) ?? [];
+  return words.length >= 6 && /\s/.test(plain.trim());
+}
+function isDataWrapper(text) {
+  const lines = text.split(`
+`).map((line) => line.trim()).filter(Boolean);
+  if (lines.length === 0)
+    return true;
+  return lines.every((line) => (line.replace(/\{\{[^}]*\}\}/g, " ").replace(/<\/?[\w-]+>/g, " ").match(/[A-Za-z]{2,}/g) ?? []).length < 4);
+}
+var SHORT_TEXT = 300;
+var DIRECTIVE_ANYWHERE = /\b(?:you(?! were)|must|should|do not|don't|never|always|only|avoid|make sure|ensure|instead)\b/i;
+var DIRECTIVE_VERB = /(?:^|[.!?:;\n]\s*|\]\s*)(?:keep|write|reply|respond|return|answer|use|include|output|list|describe|summari[sz]e|explain|decide|pick|choose|rate|score|classify|label|extract|generate|draft|revise|rewrite|translate|tell|ask|call|check|verify|follow|format|limit|stop|continue|focus|consider|act|identify|compare|judge|review|repair|fix|plan|propose|suggest|recommend|find|search|read|treat|cite|flag|mark|rank|group|merge|drop|skip|wait|confirm)\b/i;
+function hasDirective(text) {
+  const plain = text.replace(/\{\{[^}]*\}\}/g, " ").trim();
+  return DIRECTIVE_ANYWHERE.test(plain) || DIRECTIVE_VERB.test(plain);
+}
+function isInstructionDescription(text) {
+  if (text.length >= 2000)
+    return true;
+  if (text.length < 600)
+    return false;
+  return /\b(?:you must|always|never|do not|don't|only (?:use|call)|use this (?:tool|when)|call this (?:tool|when|before|after)|before (?:calling|using)|when to use)\b/i.test(text);
+}
+function toolDefinitionSite(tool) {
+  return {
+    id: `tool:${tool.toolId}`,
+    path: tool.definition.path,
+    line: tool.definition.line,
+    col: 1,
+    callee: tool.name,
+    sdk: "tool-definition",
+    language: "ts",
+    scope: tool.scope,
+    promptArgs: [],
+    isTest: false,
+    isEval: false
+  };
+}
+function resolvePromptArguments(callSites, context, options = {}) {
+  const resolver = new PromptResolver(context, options);
+  for (const tool of options.toolDefinitions ?? []) {
+    const node = nodeOf(tool.definition, context);
+    if (node)
+      resolver.resolveTools(toolDefinitionSite(tool), node);
+  }
+  for (const site of callSites) {
+    if (!/\.[cm]?[jt]sx?$/.test(site.path))
+      continue;
+    for (const { role, arg } of site.promptArgs) {
+      const node = nodeOf(arg, context);
+      if (!node)
+        continue;
+      resolver.resolveArgument(site, role, node, arg.key ? arg.key.split(".") : []);
+    }
+    const tools = site.toolsArg ? nodeOf(site.toolsArg, context) : undefined;
+    if (tools)
+      resolver.resolveTools(site, tools);
+  }
+  return resolver.result();
+}
+
+class PromptResolver {
+  context;
+  refs = new Map;
+  unresolved = new Map;
+  maxDepth;
+  maxParamLevels;
+  keepAll;
+  callersByName = new Map;
+  aliasesByName = new Map;
+  callersIndexed = false;
+  methodIndex;
+  constructor(context, options) {
+    this.context = context;
+    this.maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH;
+    this.maxParamLevels = options.maxParamLevels ?? DEFAULT_MAX_PARAM_LEVELS;
+    this.keepAll = options.keepAll === true;
+  }
+  resolveArgument(site, role, node, project = []) {
+    const walk = { site, role, depth: 0, paramLevels: 0, bindings: new Map, hops: [], seen: new Set, project, flags: [] };
+    this.value(node, undefined, walk);
+  }
+  resolveTools(site, node) {
+    const walk = { site, role: "tool-description", depth: 0, paramLevels: 0, bindings: new Map, hops: [], seen: new Set, project: [], flags: [] };
+    this.toolDefinitions(node, walk, 0, new Set);
+  }
+  toolDefinitions(node, walk, depth, seen) {
+    if (depth > 8 || seen.has(node))
+      return;
+    seen.add(node);
+    const expr = unwrap(node);
+    if (import_typescript3.default.isArrayLiteralExpression(expr)) {
+      for (const element of expr.elements)
+        this.toolDefinitions(import_typescript3.default.isSpreadElement(element) ? element.expression : element, walk, depth + 1, seen);
+      return;
+    }
+    if (import_typescript3.default.isObjectLiteralExpression(expr)) {
+      const description = expr.properties.find((p2) => propertyName(p2) === "description");
+      const handler = expr.properties.find((p2) => /^(?:execute|handler|run|invoke|call|func)$/.test(propertyName(p2) ?? ""));
+      if (description || handler) {
+        if (description && import_typescript3.default.isPropertyAssignment(description)) {
+          this.value(description.initializer, { node: description, name: toolName(expr) ? `${toolName(expr)} description` : "description", kind: "literal" }, walk);
+        }
+        if (handler) {
+          const fn = import_typescript3.default.isPropertyAssignment(handler) ? unwrap(handler.initializer) : handler;
+          const resultWalk = { ...walk, role: "tool-result", namedOnly: true };
+          if (import_typescript3.default.isArrowFunction(fn) || import_typescript3.default.isFunctionExpression(fn) || import_typescript3.default.isMethodDeclaration(fn))
+            this.builderBody(fn, { node: fn, kind: "builder" }, resultWalk);
+          else
+            this.value(fn, undefined, resultWalk);
+        }
+        return;
+      }
+      for (const property of expr.properties) {
+        if (import_typescript3.default.isPropertyAssignment(property))
+          this.toolDefinitions(property.initializer, walk, depth + 1, seen);
+        else if (import_typescript3.default.isShorthandPropertyAssignment(property))
+          this.toolDefinitions(property.name, walk, depth + 1, seen);
+        else if (import_typescript3.default.isSpreadAssignment(property))
+          this.toolDefinitions(property.expression, walk, depth + 1, seen);
+      }
+      return;
+    }
+    if (import_typescript3.default.isIdentifier(expr) || import_typescript3.default.isPropertyAccessExpression(expr)) {
+      for (const declaration of this.declarationsOf(import_typescript3.default.isPropertyAccessExpression(expr) ? expr.name : expr)) {
+        const init = import_typescript3.default.isVariableDeclaration(declaration) || import_typescript3.default.isPropertyAssignment(declaration) || import_typescript3.default.isPropertyDeclaration(declaration) ? declaration.initializer : undefined;
+        if (init)
+          this.toolDefinitions(init, walk, depth + 1, seen);
+        const fn = functionOf(declaration);
+        if (fn?.body)
+          this.returnsOf(fn, (value) => this.toolDefinitions(value, walk, depth + 1, seen));
+      }
+      return;
+    }
+    if (import_typescript3.default.isCallExpression(expr)) {
+      const callee = import_typescript3.default.isPropertyAccessExpression(expr.expression) ? expr.expression.name : expr.expression;
+      const fns = this.declarationsOf(callee).map(functionOf).filter((fn) => fn?.body);
+      if (fns.length > 0)
+        for (const fn of fns)
+          this.returnsOf(fn, (value) => this.toolDefinitions(value, walk, depth + 1, seen));
+      for (const argument of expr.arguments)
+        this.toolDefinitions(argument, walk, depth + 1, seen);
+    }
+  }
+  returnsOf(fn, each) {
+    const body = fn.body;
+    if (!body)
+      return;
+    if (!import_typescript3.default.isBlock(body)) {
+      each(body);
+      return;
+    }
+    const visit = (node) => {
+      if (node !== fn && import_typescript3.default.isFunctionLike(node))
+        return;
+      if (import_typescript3.default.isReturnStatement(node) && node.expression)
+        each(node.expression);
+      import_typescript3.default.forEachChild(node, visit);
+    };
+    visit(body);
+  }
+  result() {
+    const firstOnLine = new Map;
+    for (const ref of this.refs.values()) {
+      const line = `${ref.path}:${ref.line}`;
+      firstOnLine.set(line, Math.min(firstOnLine.get(line) ?? Infinity, ref.start));
+    }
+    const refs = [...this.refs.values()].map(({ pieces, start, ...ref }) => {
+      const later = start > firstOnLine.get(`${ref.path}:${ref.line}`);
+      const column = later ? this.columnOf(ref.path, start) : undefined;
+      return {
+        ...ref,
+        ...column ? { id: `${ref.id}:${column}`, column } : {},
+        text: [...pieces.entries()].sort((a, b) => a[0] - b[0]).map(([, text]) => text).join(`
+`)
+      };
+    });
+    return {
+      refs: refs.filter((ref) => this.keepAll || readsAsInstructions2(ref.text) && !isDataWrapper(ref.text) && (ref.text.length >= SHORT_TEXT || ref.role === "questions" || ref.role === "tool-description" || hasDirective(ref.text)) && (ref.role !== "tool-description" || isInstructionDescription(ref.text))),
+      unresolved: [...this.unresolved.values()]
+    };
+  }
+  value(node, owner, walk) {
+    if (walk.depth > this.maxDepth) {
+      this.markUnresolved(node, "depth-limit", walk);
+      return;
+    }
+    const expr = unwrap(node);
+    if (walk.project.length > 0 && (import_typescript3.default.isStringLiteral(expr) || import_typescript3.default.isNoSubstitutionTemplateLiteral(expr) || import_typescript3.default.isTemplateExpression(expr) || import_typescript3.default.isBinaryExpression(expr) && expr.operatorToken.kind === import_typescript3.default.SyntaxKind.PlusToken)) {
+      return;
+    }
+    if (import_typescript3.default.isStringLiteral(expr) || import_typescript3.default.isNoSubstitutionTemplateLiteral(expr)) {
+      this.text(expr, expr.text, owner, walk);
+      return;
+    }
+    if (import_typescript3.default.isTemplateExpression(expr)) {
+      const sf = expr.getSourceFile();
+      let text = expr.head.text;
+      for (const span of expr.templateSpans) {
+        text += `{{${span.expression.getText(sf).replace(/\s+/g, " ").slice(0, 60)}}}${span.literal.text}`;
+      }
+      this.text(expr, text, owner ?? { node: expr, kind: "template" }, walk);
+      for (const span of expr.templateSpans)
+        this.value(span.expression, undefined, flag(walk, "interpolated"));
+      return;
+    }
+    if (import_typescript3.default.isBinaryExpression(expr)) {
+      if (expr.operatorToken.kind === import_typescript3.default.SyntaxKind.PlusToken) {
+        this.value(expr.left, owner, walk);
+        this.value(expr.right, owner, walk);
+      } else if (expr.operatorToken.kind === import_typescript3.default.SyntaxKind.BarBarToken || expr.operatorToken.kind === import_typescript3.default.SyntaxKind.QuestionQuestionToken) {
+        this.value(expr.left, owner, walk);
+        this.value(expr.right, owner, walk);
+      }
+      return;
+    }
+    if (import_typescript3.default.isConditionalExpression(expr)) {
+      this.value(expr.whenTrue, owner, walk);
+      this.value(expr.whenFalse, owner, walk);
+      return;
+    }
+    if (import_typescript3.default.isArrayLiteralExpression(expr)) {
+      for (const element of expr.elements) {
+        this.value(import_typescript3.default.isSpreadElement(element) ? element.expression : element, owner, walk);
+      }
+      return;
+    }
+    if (import_typescript3.default.isObjectLiteralExpression(expr)) {
+      this.objectValue(expr, walk);
+      return;
+    }
+    if (import_typescript3.default.isIdentifier(expr)) {
+      this.identifier(expr, owner, walk);
+      return;
+    }
+    if (import_typescript3.default.isPropertyAccessExpression(expr)) {
+      this.propertyAccess(expr, owner, walk);
+      return;
+    }
+    if (import_typescript3.default.isElementAccessExpression(expr)) {
+      this.elementAccess(expr, owner, walk);
+      return;
+    }
+    if (import_typescript3.default.isCallExpression(expr)) {
+      this.call(expr, owner, walk);
+      return;
+    }
+    if (import_typescript3.default.isTaggedTemplateExpression(expr)) {
+      this.value(expr.template, owner, walk);
+      return;
+    }
+    if (import_typescript3.default.isArrowFunction(expr) || import_typescript3.default.isFunctionExpression(expr)) {
+      this.builderBody(expr, { node: expr, name: owner?.name, kind: "builder" }, walk);
+    }
+  }
+  objectValue(object, walk) {
+    if (walk.project.length > 0) {
+      const [field, ...rest] = walk.project;
+      const inner = { ...walk, project: rest };
+      for (const property of object.properties) {
+        if (import_typescript3.default.isSpreadAssignment(property)) {
+          this.value(property.expression, undefined, walk);
+          continue;
+        }
+        if (propertyName(property) !== field)
+          continue;
+        if (import_typescript3.default.isPropertyAssignment(property))
+          this.value(property.initializer, { node: property, name: field, kind: "literal" }, inner);
+        else if (import_typescript3.default.isShorthandPropertyAssignment(property))
+          this.identifier(property.name, undefined, inner);
+        else if (import_typescript3.default.isMethodDeclaration(property) || import_typescript3.default.isGetAccessorDeclaration(property))
+          this.builderBody(property, { node: property, name: field, kind: "builder" }, inner);
+      }
+      return;
+    }
+    const role = stringField(object, "role");
+    if (role && /^(?:assistant|tool|function|model)$/.test(role))
+      return;
+    for (const property of object.properties) {
+      if (import_typescript3.default.isSpreadAssignment(property)) {
+        this.value(property.expression, undefined, walk);
+        continue;
+      }
+      const key = propertyName(property);
+      if (!key)
+        continue;
+      const promptField = PROMPT_FIELDS.has(key) || walk.promptObject === true;
+      if (!promptField) {
+        if (import_typescript3.default.isPropertyAssignment(property) && import_typescript3.default.isObjectLiteralExpression(unwrap(property.initializer))) {
+          this.objectValue(unwrap(property.initializer), walk);
+        }
+        continue;
+      }
+      const inner = PROMPT_FIELDS.has(key) && !/^(?:content|text|messages|user|system|prompt)$/.test(key) ? { ...walk, promptObject: true } : walk;
+      if (import_typescript3.default.isPropertyAssignment(property)) {
+        const kind = role ? "message" : "literal";
+        this.value(property.initializer, { node: property, name: role ? undefined : key, kind }, this.messageRole(inner, role));
+      } else if (import_typescript3.default.isShorthandPropertyAssignment(property)) {
+        this.identifier(property.name, undefined, inner);
+      }
+    }
+  }
+  messageRole(walk, role) {
+    if (!role || walk.role !== "messages")
+      return walk;
+    return { ...walk, role: role === "system" || role === "developer" ? "system" : "user" };
+  }
+  identifier(identifier, owner, walk) {
+    if (identifier.text === "undefined")
+      return;
+    const declarations = this.declarationsOf(identifier);
+    if (declarations.length === 0) {
+      this.markUnresolved(identifier, "external", walk);
+      return;
+    }
+    for (const declaration of declarations)
+      this.declaration(declaration, identifier, owner, walk);
+  }
+  propertyAccess(access, owner, walk) {
+    const sf = access.getSourceFile();
+    const text = access.getText(sf);
+    if (/^(?:process\.env|import\.meta\.env|Deno\.env)\b/.test(text)) {
+      this.markUnresolved(access, "env", walk);
+      return;
+    }
+    const declarations = this.declarationsOf(access.name).filter(hasValue);
+    if (walk.flags.includes("interpolated") && !PROMPT_FIELD_NAME.test(access.name.text) && declarations.length >= 3 && declarations.every((d) => import_typescript3.default.isPropertyAssignment(d) || import_typescript3.default.isShorthandPropertyAssignment(d))) {
+      return;
+    }
+    if (declarations.length > 0) {
+      for (const declaration of declarations)
+        this.declaration(declaration, access, owner, walk);
+      return;
+    }
+    if (walk.project.length === 0 && !PROMPT_FIELD_NAME.test(access.name.text))
+      return;
+    this.value(access.expression, owner, { ...flag(walk, "projected"), project: [access.name.text, ...walk.project] });
+  }
+  elementAccess(access, owner, walk) {
+    const key = unwrap(access.argumentExpression);
+    const literalKey = import_typescript3.default.isStringLiteral(key) || import_typescript3.default.isNumericLiteral(key) || import_typescript3.default.isNoSubstitutionTemplateLiteral(key) ? key.text : undefined;
+    if (literalKey !== undefined) {
+      const declarations = this.declarationsOf(access.argumentExpression);
+      if (declarations.length > 0) {
+        for (const declaration of declarations)
+          this.declaration(declaration, access, owner, walk);
+        return;
+      }
+    }
+    const table = this.objectLiteralOf(access.expression);
+    if (!table) {
+      this.value(access.expression, owner, walk);
+      return;
+    }
+    const next = this.step(literalKey ? walk : flag(walk, "dynamic-key"), access, literalKey ? `table field ${literalKey}` : "every field of a table read with a dynamic key");
+    if (!next)
+      return;
+    if (import_typescript3.default.isArrayLiteralExpression(table)) {
+      const elements = literalKey !== undefined && import_typescript3.default.isNumericLiteral(key) ? [table.elements[Number(literalKey)]].filter(Boolean) : table.elements;
+      for (const element of elements)
+        this.value(import_typescript3.default.isSpreadElement(element) ? element.expression : element, undefined, next);
+      return;
+    }
+    for (const property of table.properties) {
+      const name = propertyName(property);
+      if (literalKey !== undefined && name !== literalKey)
+        continue;
+      if (import_typescript3.default.isPropertyAssignment(property))
+        this.value(property.initializer, { node: property, name, kind: "literal" }, next);
+      else if (import_typescript3.default.isMethodDeclaration(property))
+        this.builderBody(property, { node: property, name, kind: "builder" }, next);
+      else if (import_typescript3.default.isShorthandPropertyAssignment(property))
+        this.identifier(property.name, undefined, next);
+    }
+  }
+  call(call, owner, walk) {
+    const callee = call.expression;
+    if (import_typescript3.default.isPropertyAccessExpression(callee)) {
+      const method = callee.name.text;
+      if (method === "finally") {
+        this.value(callee.expression, owner, walk);
+        return;
+      }
+      if (CALLBACK_METHODS.has(method)) {
+        const callbacks = call.arguments.map(unwrap).filter((a) => import_typescript3.default.isArrowFunction(a) || import_typescript3.default.isFunctionExpression(a));
+        for (const callback of callbacks)
+          this.builderBody(callback, owner ?? { node: callback, kind: "builder" }, walk);
+        if (callbacks.length === 0)
+          for (const argument of call.arguments)
+            this.value(argument, owner, walk);
+        if (method === "catch")
+          this.value(callee.expression, owner, walk);
+        return;
+      }
+      if (TEXT_PRESERVING_METHODS.has(method) || ARRAY_ASSEMBLY_METHODS.has(method)) {
+        this.value(callee.expression, owner, walk);
+        if (method === "concat")
+          for (const argument of call.arguments)
+            this.value(argument, owner, walk);
+        return;
+      }
+    }
+    if (walk.project.length > 0 && import_typescript3.default.isPropertyAccessExpression(callee) && callee.getText() === "JSON.stringify" && call.arguments[0]) {
+      this.value(call.arguments[0], owner, walk);
+      return;
+    }
+    if (import_typescript3.default.isIdentifier(callee) && /^(?:String|dedent|outdent|stripIndent|stripIndents|trim)$/.test(callee.text)) {
+      for (const argument of call.arguments)
+        this.value(argument, owner, walk);
+      return;
+    }
+    const declarations = this.declarationsOf(import_typescript3.default.isPropertyAccessExpression(callee) ? callee.name : callee);
+    let functions = declarations.map(functionOf).filter((fn) => Boolean(fn));
+    if (functions.length === 0 && import_typescript3.default.isPropertyAccessExpression(callee)) {
+      const methods = this.methodsNamed(callee.name.text);
+      if (methods.length === 1)
+        functions = methods;
+    }
+    functions = functions.filter((fn) => fn.body);
+    if (functions.length === 0) {
+      this.markUnresolved(call, /\b(?:fetch|read|load|get|query|select|find)\w*\s*$/i.test(callee.getText(call.getSourceFile())) ? "io" : "external", walk);
+      return;
+    }
+    for (const fn of functions) {
+      if (walk.seen.has(fn))
+        continue;
+      const name = functionName(fn);
+      const next = this.step(walk, fn, `builder ${name ?? "function"} called at ${this.where(call)}`);
+      if (!next)
+        continue;
+      next.bindings = new Map(next.bindings);
+      bindParameters(fn, call.arguments, walk.bindings, next.bindings);
+      this.builderBody(fn, { node: fn, name, kind: "builder" }, next);
+    }
+  }
+  builderBody(fn, owner, walk) {
+    const body = fn.body;
+    if (!body)
+      return;
+    const inner = { ...walk, seen: new Set(walk.seen).add(fn) };
+    if (!import_typescript3.default.isBlock(body)) {
+      this.value(body, owner, inner);
+      return;
+    }
+    const visit = (node) => {
+      if (node !== fn && import_typescript3.default.isFunctionLike(node))
+        return;
+      if (import_typescript3.default.isReturnStatement(node) && node.expression)
+        this.value(node.expression, owner, inner);
+      import_typescript3.default.forEachChild(node, visit);
+    };
+    visit(body);
+  }
+  declaration(declaration, at, owner, walk) {
+    if (walk.seen.has(declaration))
+      return;
+    if (import_typescript3.default.isParameter(declaration) || import_typescript3.default.isBindingElement(declaration) && isParameterBinding(declaration)) {
+      this.parameter(declaration, at, owner, walk);
+      return;
+    }
+    const sf = declaration.getSourceFile();
+    if (this.isExternal(sf)) {
+      this.markUnresolved(at, "external", walk);
+      return;
+    }
+    const name = declarationName(declaration);
+    const next = this.step(walk, declaration, `${name ?? "value"} defined here`);
+    if (!next)
+      return;
+    next.seen = new Set(next.seen).add(declaration);
+    if (import_typescript3.default.isVariableDeclaration(declaration)) {
+      if (declaration.initializer) {
+        const fn2 = unwrap(declaration.initializer);
+        if (import_typescript3.default.isArrowFunction(fn2) || import_typescript3.default.isFunctionExpression(fn2)) {
+          this.builderBody(fn2, { node: declaration, name, kind: "builder" }, next);
+        } else {
+          this.value(declaration.initializer, ownerFor(declaration, name, owner), next);
+        }
+      }
+      this.assembly(declaration, ownerFor(declaration, name, owner), next);
+      return;
+    }
+    if (import_typescript3.default.isPropertyAssignment(declaration)) {
+      this.value(declaration.initializer, ownerFor(declaration, name, owner), next);
+      return;
+    }
+    if (import_typescript3.default.isShorthandPropertyAssignment(declaration)) {
+      this.identifier(declaration.name, owner, next);
+      return;
+    }
+    if (import_typescript3.default.isPropertyDeclaration(declaration)) {
+      if (declaration.initializer)
+        this.value(declaration.initializer, ownerFor(declaration, name, owner), next);
+      if (name && import_typescript3.default.isClassLike(declaration.parent)) {
+        const visit = (node) => {
+          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 === name) {
+            this.value(node.right, undefined, next);
+          }
+          import_typescript3.default.forEachChild(node, visit);
+        };
+        visit(declaration.parent);
+      }
+      return;
+    }
+    if (import_typescript3.default.isEnumMember(declaration) && declaration.initializer) {
+      this.value(declaration.initializer, ownerFor(declaration, name, owner), next);
+      return;
+    }
+    const fn = functionOf(declaration);
+    if (fn)
+      this.builderBody(fn, { node: declaration, name, kind: "builder" }, next);
+  }
+  assembly(declaration, owner, walk) {
+    if (!import_typescript3.default.isIdentifier(declaration.name))
+      return;
+    const name = declaration.name.text;
+    const scope = enclosingScope(declaration);
+    if (!scope)
+      return;
+    const isThis = (identifier) => identifier.text === name && this.declarationsOf(identifier).includes(declaration);
+    const visit = (node) => {
+      if (import_typescript3.default.isCallExpression(node) && import_typescript3.default.isPropertyAccessExpression(node.expression) && import_typescript3.default.isIdentifier(node.expression.expression) && isThis(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_typescript3.default.isBinaryExpression(node) && import_typescript3.default.isIdentifier(node.left) && isThis(node.left)) {
+        if (node.operatorToken.kind === import_typescript3.default.SyntaxKind.PlusEqualsToken)
+          this.value(node.right, owner, walk);
+        if (node.operatorToken.kind === import_typescript3.default.SyntaxKind.EqualsToken && node.right !== declaration.initializer)
+          this.value(node.right, owner, walk);
+      }
+      import_typescript3.default.forEachChild(node, visit);
+    };
+    visit(scope);
+  }
+  parameter(declaration, at, owner, walk) {
+    const bound = walk.bindings.get(declaration);
+    if (bound) {
+      this.value(bound.expr, undefined, { ...walk, bindings: bound.bindings, project: [...bound.project ?? [], ...walk.project] });
+      return;
+    }
+    const parameter = import_typescript3.default.isParameter(declaration) ? declaration : parameterOf(declaration);
+    const fn = parameter?.parent;
+    if (!parameter || !fn || !import_typescript3.default.isFunctionLike(fn)) {
+      this.markUnresolved(at, "param-unbound", walk);
+      return;
+    }
+    if (walk.paramLevels >= this.maxParamLevels) {
+      this.markUnresolved(at, "depth-limit", walk);
+      return;
+    }
+    if (parameter.initializer)
+      this.value(parameter.initializer, owner, walk);
+    const callers = this.callersOf(fn);
+    if (callers.length === 0) {
+      if (!parameter.initializer)
+        this.markUnresolved(at, "param-unbound", walk);
+      return;
+    }
+    const index = fn.parameters.indexOf(parameter);
+    for (const caller of callers) {
+      const argument = caller.arguments[index];
+      if (!argument)
+        continue;
+      const next = this.step(flag(walk, "caller-argument"), caller, `argument ${index + 1} at a caller of ${functionName(fn) ?? "the function"}`);
+      if (!next)
+        continue;
+      next.paramLevels += 1;
+      next.bindings = new Map;
+      if (import_typescript3.default.isBindingElement(declaration)) {
+        const field = bindingField(declaration);
+        const object = import_typescript3.default.isObjectLiteralExpression(unwrap(argument)) ? unwrap(argument) : undefined;
+        const property = object?.properties.find((p2) => propertyName(p2) === field);
+        if (property && import_typescript3.default.isPropertyAssignment(property))
+          this.value(property.initializer, undefined, next);
+        else if (property && import_typescript3.default.isShorthandPropertyAssignment(property))
+          this.identifier(property.name, undefined, next);
+        else if (!object && field)
+          this.value(argument, undefined, { ...next, project: [field, ...next.project] });
+        continue;
+      }
+      this.value(argument, undefined, next);
+    }
+  }
+  callersOf(fn) {
+    const name = functionName(fn);
+    if (!name)
+      return [];
+    this.indexCallers();
+    const names = [name, ...this.aliasesByName.get(name) ?? []];
+    const candidates = names.flatMap((alias) => this.callersByName.get(alias) ?? []);
+    return candidates.filter((call) => {
+      const callee = import_typescript3.default.isPropertyAccessExpression(call.expression) ? call.expression.name : call.expression;
+      return this.declarationsOf(callee).some((declaration) => functionOf(declaration) === fn || declaration === fn);
+    });
+  }
+  sourceFiles() {
+    const byName = new Map;
+    for (const program of this.context.programs) {
+      for (const file of program.getSourceFiles()) {
+        if (!this.isExternal(file) && !byName.has(file.fileName))
+          byName.set(file.fileName, file);
+      }
+    }
+    return [...byName.values()];
+  }
+  methodsNamed(name) {
+    if (!this.methodIndex) {
+      this.methodIndex = new Map;
+      for (const file of this.sourceFiles()) {
+        {
+          const visit = (node) => {
+            if (import_typescript3.default.isClassLike(node)) {
+              for (const member of node.members) {
+                if ((import_typescript3.default.isMethodDeclaration(member) || import_typescript3.default.isGetAccessorDeclaration(member)) && member.body && member.name && import_typescript3.default.isIdentifier(member.name)) {
+                  const list = this.methodIndex.get(member.name.text) ?? [];
+                  list.push(member);
+                  this.methodIndex.set(member.name.text, list);
+                }
+              }
+            }
+            import_typescript3.default.forEachChild(node, visit);
+          };
+          visit(file);
+        }
+      }
+    }
+    return this.methodIndex.get(name) ?? [];
+  }
+  indexCallers() {
+    if (this.callersIndexed)
+      return;
+    this.callersIndexed = true;
+    for (const file of this.sourceFiles()) {
+      {
+        const visit = (node) => {
+          if (import_typescript3.default.isCallExpression(node)) {
+            const callee = import_typescript3.default.isPropertyAccessExpression(node.expression) ? node.expression.name : node.expression;
+            if (import_typescript3.default.isIdentifier(callee)) {
+              const list = this.callersByName.get(callee.text) ?? [];
+              list.push(node);
+              this.callersByName.set(callee.text, list);
+            }
+          }
+          if ((import_typescript3.default.isImportSpecifier(node) || import_typescript3.default.isExportSpecifier(node)) && node.propertyName && import_typescript3.default.isIdentifier(node.propertyName)) {
+            const aliases = this.aliasesByName.get(node.propertyName.text) ?? new Set;
+            aliases.add(node.name.text);
+            this.aliasesByName.set(node.propertyName.text, aliases);
+          }
+          import_typescript3.default.forEachChild(node, visit);
+        };
+        visit(file);
+      }
+    }
+  }
+  objectLiteralOf(node) {
+    let current = unwrap(node);
+    for (let i = 0;i < 6; i++) {
+      if (import_typescript3.default.isObjectLiteralExpression(current) || import_typescript3.default.isArrayLiteralExpression(current))
+        return current;
+      const target = import_typescript3.default.isPropertyAccessExpression(current) ? current.name : current;
+      const declaration = this.declarationsOf(target)[0];
+      if (!declaration)
+        return;
+      const initializer = import_typescript3.default.isVariableDeclaration(declaration) || import_typescript3.default.isPropertyAssignment(declaration) || import_typescript3.default.isPropertyDeclaration(declaration) ? declaration.initializer : undefined;
+      if (!initializer)
+        return;
+      current = unwrap(initializer);
+    }
+    return;
+  }
+  declarationsOf(node) {
+    const path = this.relative(node.getSourceFile().fileName);
+    const checker = this.context.checkerFor(path);
+    if (!checker)
+      return [];
+    let symbol = import_typescript3.default.isShorthandPropertyAssignment(node.parent) && node.parent.name === node ? checker.getShorthandAssignmentValueSymbol(node.parent) : checker.getSymbolAtLocation(node);
+    if (!symbol)
+      return [];
+    if (symbol.flags & import_typescript3.default.SymbolFlags.Alias) {
+      try {
+        symbol = checker.getAliasedSymbol(symbol);
+      } catch {
+        return [];
+      }
+    }
+    return (symbol.declarations ?? []).filter((declaration) => !this.isExternal(declaration.getSourceFile()));
+  }
+  step(walk, node, reason) {
+    if (walk.depth + 1 > this.maxDepth) {
+      this.markUnresolved(node, "depth-limit", walk);
+      return;
+    }
+    const hop = { path: this.relative(node.getSourceFile().fileName), line: lineOf2(node), reason };
+    return { ...walk, depth: walk.depth + 1, hops: [...walk.hops, hop] };
+  }
+  text(at, text, owner, walk) {
+    if (walk.namedOnly && !owner?.name)
+      return;
+    const anchor = owner?.node ?? at;
+    const sf = anchor.getSourceFile();
+    const path = this.relative(sf.fileName);
+    if (TEST_SOURCE.test(path))
+      return;
+    if (LOCAL_ONLY_SITE.test(walk.site.path) && path !== walk.site.path)
+      return;
+    const line = lineOf2(anchor);
+    const id = `${path}:${line}`;
+    const key = owner ? `${path}@${anchor.getStart(sf)}` : id;
+    let ref = this.refs.get(key);
+    if (!ref) {
+      ref = {
+        id,
+        path,
+        line,
+        endLine: sf.getLineAndCharacterOfPosition(anchor.getEnd()).line + 1,
+        ...owner?.name ? { name: owner.name } : {},
+        kind: owner?.kind ?? "literal",
+        role: walk.role,
+        text: "",
+        callSiteIds: [],
+        hops: walk.hops,
+        via: [...walk.flags],
+        pieces: new Map,
+        start: anchor.getStart(sf)
+      };
+      this.refs.set(key, ref);
+    }
+    ref.start = Math.min(ref.start, anchor.getStart(sf));
+    if (!ref.callSiteIds.includes(walk.site.id))
+      ref.callSiteIds.push(walk.site.id);
+    ref.via = ref.via.filter((f) => walk.flags.includes(f));
+    ref.pieces.set(at.getStart(sf), text);
+  }
+  markUnresolved(node, reason, walk) {
+    const sf = node.getSourceFile();
+    const path = this.relative(sf.fileName);
+    const line = lineOf2(node);
+    const key = `${walk.site.id}|${path}:${line}|${reason}`;
+    if (this.unresolved.has(key))
+      return;
+    this.unresolved.set(key, {
+      callSiteId: walk.site.id,
+      role: walk.role,
+      path,
+      line,
+      expression: node.getText(sf).replace(/\s+/g, " ").slice(0, 120),
+      reason
+    });
+  }
+  columnOf(path, start) {
+    const sf = this.sourceFiles().find((file) => this.relative(file.fileName) === path);
+    return sf ? sf.getLineAndCharacterOfPosition(start).character + 1 : undefined;
+  }
+  where(node) {
+    return `${this.relative(node.getSourceFile().fileName)}:${lineOf2(node)}`;
+  }
+  relative(fileName) {
+    const rel2 = relative6(this.context.rootDir, fileName).replace(/\\/g, "/");
+    return rel2.startsWith("..") ? fileName : rel2;
+  }
+  isExternal(sf) {
+    return sf.isDeclarationFile || /(?:^|\/)node_modules\//.test(sf.fileName);
+  }
+}
+function nodeOf(ref, context) {
+  const node = context.nodeAt(ref);
+  return node && import_typescript3.default.isShorthandPropertyAssignment(node) ? node.name : node;
+}
+function toolName(definition) {
+  const name = stringField(definition, "name");
+  if (name)
+    return name;
+  const parent = definition.parent;
+  if (import_typescript3.default.isPropertyAssignment(parent))
+    return propertyName(parent);
+  if (import_typescript3.default.isCallExpression(parent) && import_typescript3.default.isPropertyAssignment(parent.parent))
+    return propertyName(parent.parent);
+  if (import_typescript3.default.isCallExpression(parent) && import_typescript3.default.isVariableDeclaration(parent.parent) && import_typescript3.default.isIdentifier(parent.parent.name))
+    return parent.parent.name.text;
+  return;
+}
+function flag(walk, f) {
+  return walk.flags.includes(f) ? walk : { ...walk, flags: [...walk.flags, f] };
+}
+function unwrap(node) {
+  let current = node;
+  for (;; ) {
+    if (import_typescript3.default.isParenthesizedExpression(current) || import_typescript3.default.isAsExpression(current) || import_typescript3.default.isNonNullExpression(current) || import_typescript3.default.isAwaitExpression(current) || import_typescript3.default.isTypeAssertionExpression(current) || import_typescript3.default.isSatisfiesExpression(current)) {
+      current = current.expression;
+      continue;
+    }
+    return current;
+  }
+}
+function lineOf2(node) {
+  const sf = node.getSourceFile();
+  return sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1;
+}
+function propertyName(property) {
+  const name = property.name;
+  if (!name)
+    return;
+  if (import_typescript3.default.isIdentifier(name) || import_typescript3.default.isStringLiteral(name) || import_typescript3.default.isNumericLiteral(name) || import_typescript3.default.isPrivateIdentifier(name))
+    return name.text;
+  return;
+}
+function stringField(object, field) {
+  for (const property of object.properties) {
+    if (!import_typescript3.default.isPropertyAssignment(property) || propertyName(property) !== field)
+      continue;
+    const value = unwrap(property.initializer);
+    if (import_typescript3.default.isStringLiteral(value) || import_typescript3.default.isNoSubstitutionTemplateLiteral(value))
+      return value.text;
+  }
+  return;
+}
+function declarationName(declaration) {
+  const name = declaration.name;
+  if (name && (import_typescript3.default.isIdentifier(name) || import_typescript3.default.isStringLiteral(name) || import_typescript3.default.isPrivateIdentifier(name)))
+    return name.text;
+  return;
+}
+function functionName(fn) {
+  const own = declarationName(fn);
+  if (own)
+    return own;
+  const parent = fn.parent;
+  if (parent && (import_typescript3.default.isVariableDeclaration(parent) || import_typescript3.default.isPropertyAssignment(parent) || import_typescript3.default.isPropertyDeclaration(parent))) {
+    return declarationName(parent);
+  }
+  return;
+}
+function functionOf(declaration) {
+  if (import_typescript3.default.isFunctionDeclaration(declaration) || import_typescript3.default.isMethodDeclaration(declaration) || import_typescript3.default.isGetAccessorDeclaration(declaration) || import_typescript3.default.isArrowFunction(declaration) || import_typescript3.default.isFunctionExpression(declaration)) {
+    return declaration;
+  }
+  if ((import_typescript3.default.isVariableDeclaration(declaration) || import_typescript3.default.isPropertyAssignment(declaration) || import_typescript3.default.isPropertyDeclaration(declaration)) && declaration.initializer) {
+    const init = unwrap(declaration.initializer);
+    if (import_typescript3.default.isArrowFunction(init) || import_typescript3.default.isFunctionExpression(init))
+      return init;
+  }
+  return;
+}
+function hasValue(declaration) {
+  return !import_typescript3.default.isPropertySignature(declaration) && !import_typescript3.default.isMethodSignature(declaration) && !import_typescript3.default.isIndexSignatureDeclaration(declaration);
+}
+function ownerFor(declaration, name, outer) {
+  if (outer?.kind === "builder" && outer.node.getSourceFile() === declaration.getSourceFile() && contains(outer.node, declaration))
+    return outer;
+  return { node: declaration, name, kind: "literal" };
+}
+function contains(outer, inner) {
+  return inner.getStart() >= outer.getStart() && inner.getEnd() <= outer.getEnd();
+}
+function enclosingScope(declaration) {
+  for (let node = declaration.parent;node; node = node.parent) {
+    if (import_typescript3.default.isBlock(node) || import_typescript3.default.isSourceFile(node) || import_typescript3.default.isModuleBlock(node))
+      return node;
+  }
+  return;
+}
+function isParameterBinding(element) {
+  return Boolean(parameterOf(element));
+}
+function parameterOf(element) {
+  for (let node = element.parent;node; node = node.parent) {
+    if (import_typescript3.default.isParameter(node))
+      return node;
+    if (!import_typescript3.default.isBindingElement(node) && !import_typescript3.default.isObjectBindingPattern(node) && !import_typescript3.default.isArrayBindingPattern(node))
+      return;
+  }
+  return;
+}
+function bindingField(element) {
+  const name = element.propertyName ?? element.name;
+  return import_typescript3.default.isIdentifier(name) || import_typescript3.default.isStringLiteral(name) ? name.text : undefined;
+}
+function bindParameters(fn, args, outer, into) {
+  fn.parameters.forEach((parameter, index) => {
+    const argument = args[index];
+    if (!argument)
+      return;
+    if (import_typescript3.default.isIdentifier(parameter.name)) {
+      into.set(parameter, { expr: argument, bindings: outer });
+      return;
+    }
+    if (import_typescript3.default.isObjectBindingPattern(parameter.name)) {
+      const object = unwrap(argument);
+      for (const element of parameter.name.elements) {
+        const field = bindingField(element);
+        if (!import_typescript3.default.isObjectLiteralExpression(object)) {
+          if (field)
+            into.set(element, { expr: argument, bindings: outer, project: [field] });
+          continue;
+        }
+        const property = object.properties.find((p2) => propertyName(p2) === field);
+        if (property && import_typescript3.default.isPropertyAssignment(property))
+          into.set(element, { expr: property.initializer, bindings: outer });
+        else if (property && import_typescript3.default.isShorthandPropertyAssignment(property))
+          into.set(element, { expr: property.name, bindings: outer });
+      }
+    }
+  });
+}
+
+// src/harness-extract/prompts/assembler.ts
+var DIRECT_PROMPT_CONFIDENCE = 0.9;
+var INDIRECT_PROMPT_CONFIDENCE = 0.75;
+var MAX_HOP_EVIDENCE = 4;
+var CALL_PATH_REASON = "call path:";
+var MAX_BODY_CHARS = 64 * 1024;
+function assemblePromptArtifacts(resolution, callSites, promoted, options = {}) {
+  const allow = new Set(options.allow ?? ["caller-argument", "dynamic-key", "interpolated", "projected"]);
+  const sites = new Map(callSites.map((site) => [site.id, site]));
+  const toolAgents = new Map;
+  for (const tool of options.toolDefinitions ?? []) {
+    const site = toolDefinitionSite(tool);
+    sites.set(site.id, site);
+    toolAgents.set(site.id, tool.agentIds ?? []);
+  }
+  const kept = resolution.refs.filter((ref) => ref.via.every((flag2) => allow.has(flag2)));
+  const resolved = kept.map((ref) => refArtifact(ref, sites, options.agentForScope, toolAgents));
+  const refs = new Map(resolved.map((artifact, index) => [artifact, kept[index]]));
+  const byId = new Map;
+  for (const artifact of resolved)
+    byId.set(artifact.id, artifact);
+  let merged = 0;
+  let keptPromoted = 0;
+  const artifacts = [...resolved];
+  for (const artifact of promoted) {
+    if (artifact.type !== "prompt") {
+      artifacts.push(artifact);
+      continue;
+    }
+    const same = byId.get(artifact.id) ?? sameDefinition(artifact, resolved, refs);
+    if (same) {
+      mergeInto(same, artifact);
+      merged += 1;
+      continue;
+    }
+    artifacts.push(artifact);
+    keptPromoted += 1;
+  }
+  return {
+    artifacts,
+    unresolved: unresolvedReports(resolution, sites),
+    stats: { resolved: resolved.length, merged, keptPromoted }
+  };
+}
+function refArtifact(ref, sites, agentForScope, toolAgents = new Map) {
+  const callSites = ref.callSiteIds.map((id) => sites.get(id)).filter((site) => Boolean(site));
+  const agentIds = [...new Set(callSites.flatMap((site) => toolAgents.get(site.id) ?? site.agentIds ?? (site.scope && agentForScope ? agentForScope(site.scope) : [])))].sort();
+  const first2 = callSites[0];
+  const evidence = [{ path: ref.path, line: ref.line, reason: `prompt ${ref.kind} definition` }];
+  for (const site of callSites.slice(0, MAX_HOP_EVIDENCE)) {
+    evidence.push({ path: site.path, line: site.line, reason: `passed to a model call: ${site.callee} as ${ref.role}` });
+  }
+  for (const hop of ref.hops.slice(-MAX_HOP_EVIDENCE)) {
+    if (hop.path === ref.path && hop.line === ref.line)
+      continue;
+    evidence.push({ path: hop.path, line: hop.line, reason: `${CALL_PATH_REASON} ${hop.reason}` });
+  }
+  const direct = ref.via.length === 0;
+  const where = `${ref.path}:${ref.line}`;
+  const reach = first2 ? `${first2.callee} at ${first2.path}:${first2.line}` : "a model call";
+  return {
+    id: stableId("prompt", `${ref.path.replace(/\.[^.]+$/, "")}:L${ref.line}${ref.column ? `C${ref.column}` : ""}`),
+    type: "prompt",
+    name: ref.name ? titleFromId(ref.name) : `Inline Prompt (${where})`,
+    scope: agentIds.length === 1 ? "agent" : "shared",
+    ...agentIds.length === 1 ? { ownedByAgentId: agentIds[0] } : {},
+    usedByAgentIds: agentIds,
+    confidence: direct ? DIRECT_PROMPT_CONFIDENCE : INDIRECT_PROMPT_CONFIDENCE,
+    confidenceReason: direct ? `Call site: ${ref.kind === "builder" ? "builder" : "text"} ${ref.name ?? ""} at ${where} is passed to ${reach} as ${ref.role}.`.replace(/\s+/g, " ") : `Call site: ${ref.name ?? "text"} at ${where} reaches ${reach} as ${ref.role} through ${ref.via.join(", ")}.`,
+    evidence,
+    body: ref.text.length > MAX_BODY_CHARS ? `${ref.text.slice(0, MAX_BODY_CHARS)}
+[truncated]` : ref.text
+  };
+}
+function sameDefinition(promoted, resolved, refs) {
+  const at = promoted.evidence[0];
+  const line = at?.line;
+  if (!at || line === undefined || promoted.sourcePath)
+    return;
+  const columned = /C\d+$/.test(promoted.id);
+  const span = (ref) => ref.endLine - ref.line;
+  return resolved.map((candidate) => ({ candidate, ref: refs.get(candidate) })).filter(({ ref }) => ref.path === at.path && (ref.line === line ? !columned && !ref.column : ref.line < line && line <= ref.endLine)).sort((a, b) => Number(b.ref.line === line) - Number(a.ref.line === line) || span(a.ref) - span(b.ref))[0]?.candidate;
+}
+function mergeInto(target, promoted) {
+  const seen = new Set(target.evidence.map((e) => `${e.path}:${e.line}`));
+  for (const evidence of promoted.evidence) {
+    if (!seen.has(`${evidence.path}:${evidence.line}`))
+      target.evidence.push(evidence);
+  }
+  target.confidence = Math.max(target.confidence, promoted.confidence);
+  if ((promoted.body?.length ?? 0) > (target.body?.length ?? 0) && target.body?.includes("{{") !== true)
+    target.body = promoted.body;
+  if (target.id !== promoted.id)
+    target.id = promoted.id;
+}
+function unresolvedReports(resolution, sites) {
+  const resolvedSites = new Set(resolution.refs.flatMap((ref) => ref.callSiteIds.map((id) => `${id}|${ref.role}`)));
+  const reports = new Map;
+  for (const value of resolution.unresolved) {
+    if (resolvedSites.has(`${value.callSiteId}|${value.role}`))
+      continue;
+    const site = sites.get(value.callSiteId);
+    if (!site)
+      continue;
+    const key = `${value.callSiteId}|${value.role}`;
+    const report = reports.get(key) ?? { callSiteId: site.id, path: site.path, line: site.line, role: value.role, values: [] };
+    report.values.push({ path: value.path, line: value.line, expression: value.expression, reason: value.reason });
+    reports.set(key, report);
+  }
+  return [...reports.values()];
+}
+
+// src/harness-extract/prompts/index.ts
+function promptArtifactsFromCallSites(callSites, context, promoted, options = {}) {
+  return assemblePromptArtifacts(resolvePromptArguments(callSites, context, options), callSites, promoted, options);
+}
+
 // src/harness-sync-limits.ts
 var MAX_HARNESS_SYNC_GRAPH_BYTES = 2000000;
 function assertHarnessGraphSyncSize(graph) {
@@ -15655,7 +16744,7 @@ async function runHarnessCommand(context) {
           report: {
             reportId: report.reportId,
             reportHash,
-            path: normalizePath2(relative6(rootDir, reportPath)) || ".moda/harness-report.json"
+            path: normalizePath2(relative7(rootDir, reportPath)) || ".moda/harness-report.json"
           },
           validation,
           approval: {
@@ -15801,7 +16890,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-0mxwmp6g.js");
+        const { runGithubActionsAnalyze } = await import("./harness-github-actions-vt8tt6n9.js");
         const result = await runGithubActionsAnalyze(rootDir, {
           writeReport: (report2) => {
             const normalized = normalizeHarnessReport(report2);
@@ -15923,7 +17012,7 @@ async function runHarnessCommand(context) {
         report: {
           reportId: approval.report.reportId,
           reportHash: hashHarnessReport(approval.report),
-          path: normalizePath2(relative6(rootDir, reportPath)) || ".moda/harness-report.json"
+          path: normalizePath2(relative7(rootDir, reportPath)) || ".moda/harness-report.json"
         },
         validation: approval.validation,
         approval: approval.approval
@@ -15974,7 +17063,7 @@ async function runHarnessCommand(context) {
     }
     case "extract": {
       writeHumanProgress(context, "Harness extract: tracing model call sites (no LLM, no network)...");
-      const { extractHarness, serializeExtractResult } = await import("./index-gtqxj0fp.js");
+      const { extractHarness, serializeExtractResult } = await import("./index-xkgawks9.js");
       const result = extractHarness(rootDir, { fresh: true });
       writeHumanProgress(context, `Harness extract: ${result.callSites.length} call sites, ${result.roles.length} traced roles across ${result.files} files (${result.programs} programs, ${result.durationMs.toLocaleString()} ms).`);
       context.output.writeData(serializeExtractResult(result));
@@ -16069,9 +17158,9 @@ async function runHarnessCommand(context) {
       const readFlags = { list: ["limit", "offset"], show: ["version"], versions: ["limit", "offset"], diff: ["from", "to"] };
       assertFlags(`harness ${subcommand}`, context.flags, [...readFlags[subcommand], "path"]);
       assertPositionals(`harness ${subcommand}`, context.positionals, subcommand === "list" ? 1 : 2, `moda harness ${subcommand}${subcommand === "list" ? "" : " <harness-id-or-key>"}`);
-      for (const flag of readFlags[subcommand]) {
-        if (context.flags[flag] === "true")
-          throw new CliInputError(`--${flag} needs a value.`);
+      for (const flag2 of readFlags[subcommand]) {
+        if (context.flags[flag2] === "true")
+          throw new CliInputError(`--${flag2} needs a value.`);
       }
       const profileOptions = { profile: context.profile, env: context.env };
       if (!resolveApiKey(profileOptions)) {
@@ -16530,7 +17619,7 @@ function modelIdsUsedInSource(rootDir, ids) {
   const walk = (current) => {
     if (pending.size === 0)
       return false;
-    const rel2 = normalizePath2(relative6(rootReal, current)) || ".";
+    const rel2 = normalizePath2(relative7(rootReal, current)) || ".";
     let stat;
     try {
       stat = lstatSync7(current);
@@ -16760,6 +17849,8 @@ function mergeDeterministicArtifacts(graph, rootDir, options = {}) {
   let promoted;
   try {
     promoted = promoteHarnessCandidates(detectHarnessCandidates(rootDir), rootDir, { fullEvidence: true });
+    if (!allowedTypes || allowedTypes.has("prompt"))
+      promoted = withCallSitePrompts(rootDir, promoted);
   } catch {
     return { added: 0 };
   }
@@ -16801,6 +17892,18 @@ function mergeDeterministicArtifacts(graph, rootDir, options = {}) {
   }
   return { added };
 }
+function withCallSitePrompts(rootDir, promoted) {
+  if (process.env.MODA_HARNESS_CALLSITE_PROMPTS === "0")
+    return promoted;
+  try {
+    const { result, ctx } = extractHarnessWithContext(rootDir);
+    const sites = result.callSites.filter((site) => !site.isTest);
+    const toolDefinitions = result.toolDefinitions ?? [];
+    return promptArtifactsFromCallSites(sites, ctx, promoted, { toolDefinitions }).artifacts;
+  } catch {
+    return promoted;
+  }
+}
 function backfillRefutationEvidenceReasons(graph) {
   for (const unknown of graph.unknowns ?? []) {
     if (!/refut/i.test(String(unknown.id ?? "")))
@@ -16907,7 +18010,7 @@ ${existing.body ?? ""}`, promoted.name)))
       return true;
   }
   const promotedName = promoted.name.toLowerCase();
-  const isDefinitionLine = (entry) => typeof entry.line === "number" && !/^(?:passed to a model call|prompt-named literal referenced)/.test(entry.reason ?? "");
+  const isDefinitionLine = (entry) => typeof entry.line === "number" && !/^(?:passed to a model call|prompt-named literal referenced|call path:)/.test(entry.reason ?? "");
   const promotedLines = promoted.evidence.filter(isDefinitionLine);
   const promotedSource = artifactSourceKey(promoted);
   const isWholeFilePrompt = promoted.type === "prompt" && Boolean(promoted.sourcePath);
@@ -17293,10 +18396,10 @@ function parseExternalAgentEventBody(event) {
   const subtype = stringValue(event.subtype);
   if (type === "rate_limit_event")
     return { kind: "rate_limit", message: "rate limit wait" };
-  const toolName = stringValue(event.name) ?? stringValue(event.tool_name) ?? stringValue(event.toolName) ?? stringValue(call?.name);
-  if (toolName && /tool|call|exec|command|bash/i.test(`${type ?? ""} ${subtype ?? ""}`)) {
+  const toolName2 = stringValue(event.name) ?? stringValue(event.tool_name) ?? stringValue(event.toolName) ?? stringValue(call?.name);
+  if (toolName2 && /tool|call|exec|command|bash/i.test(`${type ?? ""} ${subtype ?? ""}`)) {
     const detail = toolInputDetail(event.input ?? event.arguments ?? call?.input ?? call?.arguments);
-    return { kind: "tool", toolName, message: `tool ${toolName}`, ...detail ? { detail } : {} };
+    return { kind: "tool", toolName: toolName2, message: `tool ${toolName2}`, ...detail ? { detail } : {} };
   }
   const directText = stringValue(event.text) ?? stringValue(event.message) ?? stringValue(event.delta) ?? stringValue(event.result);
   if (directText && !isLowSignalEventType(type)) {
@@ -17653,8 +18756,8 @@ var READ_ONLY_CLAUDE_ARG_FLAGS = new Map([
 function readOnlyClaudeExtraArgs(args) {
   const kept = [];
   for (let i = 0;i < args.length; i += 1) {
-    const [flag, inline] = args[i].split(/=(.*)/s, 2);
-    const takesValue = READ_ONLY_CLAUDE_ARG_FLAGS.get(flag);
+    const [flag2, inline] = args[i].split(/=(.*)/s, 2);
+    const takesValue = READ_ONLY_CLAUDE_ARG_FLAGS.get(flag2);
     if (takesValue === undefined) {
       if (inline === undefined && args[i + 1] !== undefined && !args[i + 1].startsWith("-"))
         i += 1;
@@ -17663,7 +18766,7 @@ function readOnlyClaudeExtraArgs(args) {
     if (takesValue && inline === undefined) {
       if (args[i + 1] === undefined)
         continue;
-      kept.push(flag, args[i + 1]);
+      kept.push(flag2, args[i + 1]);
       i += 1;
     } else {
       kept.push(args[i]);
@@ -18179,7 +19282,7 @@ function collectSnapshotInputs(rootDir, maxFiles, maxTextBytes) {
   let inventoryFileCount = 0;
   let inventoryTextBytes = 0;
   function walk(current) {
-    const path = normalizePath2(relative6(rootDir, current)) || ".";
+    const path = normalizePath2(relative7(rootDir, current)) || ".";
     let stat;
     try {
       stat = lstatSync7(current);
@@ -18250,7 +19353,7 @@ function buildSourceSnapshot(rootDir) {
 }
 function buildCommandScanPlan(context, rootDir) {
   const explicitPath = context.flags.path !== undefined;
-  const rel2 = normalizePath2(relative6(context.cwd, rootDir)) || ".";
+  const rel2 = normalizePath2(relative7(context.cwd, rootDir)) || ".";
   const scope = explicitPath && rel2 !== "." ? "narrow" : "broad";
   const machineReadable = context.outputMode !== "human";
   const approvalRequired = context.positional === "analyze" && scope === "broad" && !context.yes;
@@ -18335,7 +19438,7 @@ function writeHumanBlock(context, message) {
 function buildHarnessReadPlan(rootDir, pathWasExplicit) {
   return {
     scope: pathWasExplicit ? "narrow" : "broad",
-    rootPaths: [normalizePath2(relative6(rootDir, rootDir)) || "."],
+    rootPaths: [normalizePath2(relative7(rootDir, rootDir)) || "."],
     willRead: [
       "package manifests",
       "source files under the selected path",
@@ -18548,7 +19651,7 @@ function findFresherHarnessReports(rootDir) {
         const candidate = lstatSync7(join9(child, HARNESS_REPORT_PATH));
         if (candidate.isFile() && candidate.mtimeMs > rootMtimeMs) {
           fresher.push({
-            path: normalizePath2(relative6(rootDir, join9(child, HARNESS_REPORT_PATH))),
+            path: normalizePath2(relative7(rootDir, join9(child, HARNESS_REPORT_PATH))),
             mtimeMs: candidate.mtimeMs
           });
         }
@@ -18560,7 +19663,7 @@ function findFresherHarnessReports(rootDir) {
   return fresher.sort((a, b) => b.mtimeMs - a.mtimeMs);
 }
 function warnFresherSubdirHarnessReports(context, rootDir, explicitReport) {
-  const explicitReportPath = explicitReport && explicitReport !== "true" ? normalizePath2(relative6(rootDir, resolve10(rootDir, explicitReport))) : undefined;
+  const explicitReportPath = explicitReport && explicitReport !== "true" ? normalizePath2(relative7(rootDir, resolve10(rootDir, explicitReport))) : undefined;
   if (explicitReportPath && explicitReportPath !== normalizePath2(HARNESS_REPORT_PATH))
     return;
   let fresher;
@@ -18767,7 +19870,7 @@ function inventoryFiles(rootDir, skipped, options = {}) {
   const maxTextBytes = numericEnv("MODA_HARNESS_MAX_TEXT_BYTES", DEFAULT_MAX_INVENTORY_TEXT_BYTES);
   let textBytes = 0;
   function walk(current) {
-    const rel2 = normalizePath2(relative6(rootReal, current)) || ".";
+    const rel2 = normalizePath2(relative7(rootReal, current)) || ".";
     let stat;
     try {
       stat = lstatSync7(current);
@@ -20118,7 +21221,7 @@ function contentHashForAnnotatedSource(sourcePath, annotation) {
 function readSmallTextFileForHash(absPath, rootDir) {
   if (!existsSync8(absPath))
     return;
-  const rel2 = normalizePath2(relative6(rootDir, absPath));
+  const rel2 = normalizePath2(relative7(rootDir, absPath));
   if (isSecretishPath(rel2))
     return;
   let stat;