@moda-ai/cli 1.55.94 → 1.55.95

package/dist/cli-gcqpbes6.js

@@ -0,0 +1,1660 @@
+import {
+  enumerateToolCatalog,
+  enumerateWorkflows
+} from "./cli-f1sx9dsa.js";
+import {
+  require_out
+} from "./cli-764m5azg.js";
+import {
+  EXTRACT_SCHEMA_VERSION,
+  TEST_PATH,
+  collectModels,
+  emitToolsCached,
+  enclosingClass,
+  enclosingFunction,
+  enumerateAgents,
+  enumerationRepository,
+  evalFileSignal,
+  evalSuiteKey,
+  extractHarnessWithContext,
+  functionName,
+  isFunctionLike,
+  lineOf,
+  modelArtifacts,
+  parse,
+  propertyNameText,
+  relPath,
+  resolvePromptArguments,
+  resolvedSymbol,
+  scopeOf,
+  stableId,
+  svelteVirtualName,
+  toolArtifacts,
+  toolNamesOf,
+  unwrap,
+  valueDeclaration,
+  visit
+} from "./cli-1sdz17sn.js";
+import"./cli-k0vxtzxb.js";
+import"./cli-97fnztpy.js";
+import {
+  detectBoundRuntimeClasses,
+  isTestWorkerConfig
+} from "./cli-krm4w2v9.js";
+import"./cli-13zdcv4w.js";
+import"./cli-6ga6kmdp.js";
+import"./cli-e0kbye4s.js";
+import"./cli-dxajrq9h.js";
+import {
+  EXIT_DEGRADED,
+  VERSION
+} from "./cli-1nd4339b.js";
+import {
+  CliInputError
+} from "./cli-k4tqwah4.js";
+import {
+  require_typescript
+} from "./cli-r0pkdy83.js";
+import"./cli-9kfxkxmk.js";
+import"./cli-0semcakc.js";
+import {
+  __toESM
+} from "./cli-0v6na3yp.js";
+
+// src/harness-extract/skeleton/cli.ts
+import { mkdirSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { dirname as dirname2, resolve as resolve3 } from "node:path";
+
+// src/harness-extract/skeleton/index.ts
+var import_fast_glob = __toESM(require_out(), 1);
+var import_typescript2 = __toESM(require_typescript(), 1);
+import { createHash } from "node:crypto";
+import { execFileSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { basename, dirname, resolve as resolve2 } from "node:path";
+
+// src/harness-extract/skeleton/prompt-units.ts
+var import_typescript = __toESM(require_typescript(), 1);
+import { resolve } from "node:path";
+var TEXT_METHODS = new Set(["trim", "trimStart", "trimEnd", "replace", "replaceAll", "toString", "normalize", "padEnd", "padStart", "slice"]);
+var ASSEMBLY_METHODS = new Set(["join", "concat", "filter", "flat", "map", "flatMap"]);
+var TEXT_FUNCTIONS = /^(?:String|dedent|outdent|stripIndent|stripIndents|trim|endent)$/;
+var MAX_DEPTH = 8;
+function roleOf(role) {
+  return ["system", "user", "messages", "prompt", "instructions", "questions"].find((r) => r === role) ?? "unknown";
+}
+function endLineOf(node) {
+  const sf = node.getSourceFile();
+  return sf.getLineAndCharacterOfPosition(node.getEnd()).line + 1;
+}
+function inRepo(node) {
+  const sf = node.getSourceFile();
+  return !sf.isDeclarationFile && !/[\\/]node_modules[\\/]/.test(sf.fileName);
+}
+function sourceFileOf(ctx, path) {
+  const program = ctx.programFor(path);
+  if (!program)
+    return;
+  const abs = resolve(ctx.rootDir, path);
+  return program.getSourceFile(/\.svelte$/i.test(abs) ? svelteVirtualName(abs) : abs);
+}
+function declarationSymbol(decl) {
+  if (import_typescript.default.isVariableDeclaration(decl)) {
+    if (enclosingFunction(decl) || !import_typescript.default.isIdentifier(decl.name))
+      return;
+    return decl.name.text;
+  }
+  if (import_typescript.default.isPropertyDeclaration(decl) || import_typescript.default.isMethodDeclaration(decl) || import_typescript.default.isGetAccessorDeclaration(decl)) {
+    const cls = decl.parent;
+    const name = propertyNameText(decl.name);
+    if (!name)
+      return;
+    if (import_typescript.default.isClassLike(cls)) {
+      if (enclosingFunction(cls))
+        return;
+      return cls.name ? `${cls.name.text}.${name}` : undefined;
+    }
+  }
+  if (import_typescript.default.isPropertyAssignment(decl) || import_typescript.default.isShorthandPropertyAssignment(decl) || import_typescript.default.isMethodDeclaration(decl) || import_typescript.default.isGetAccessorDeclaration(decl)) {
+    const name = propertyNameText(decl.name);
+    const object = decl.parent;
+    if (!name || !import_typescript.default.isObjectLiteralExpression(object))
+      return;
+    const holder = object.parent;
+    if (import_typescript.default.isVariableDeclaration(holder) || import_typescript.default.isPropertyAssignment(holder) || import_typescript.default.isPropertyDeclaration(holder)) {
+      const outer = declarationSymbol(holder);
+      return outer ? `${outer}.${name}` : undefined;
+    }
+    if (import_typescript.default.isAsExpression(holder) || import_typescript.default.isSatisfiesExpression(holder) || import_typescript.default.isParenthesizedExpression(holder)) {
+      const inner = holder.parent;
+      if (import_typescript.default.isVariableDeclaration(inner)) {
+        const outer = declarationSymbol(inner);
+        return outer ? `${outer}.${name}` : undefined;
+      }
+    }
+  }
+  if (import_typescript.default.isFunctionDeclaration(decl) && decl.name && !enclosingFunction(decl))
+    return decl.name.text;
+  return;
+}
+function collectPromptUnits(input) {
+  const { rootDir, ctx } = input;
+  const warnings = [];
+  const timings = {};
+  let clock = Date.now();
+  const pseudo = [];
+  for (const site of input.sites) {
+    if (!/\.[cm]?[jt]sx?$/.test(site.path))
+      continue;
+    site.promptArgs.forEach((arg, index) => {
+      const id = `${site.id}\x00${index}`;
+      pseudo.push({ site, role: roleOf(arg.role), pseudo: { ...site, id, promptArgs: [arg], toolsArg: undefined } });
+    });
+  }
+  const byId = new Map(pseudo.map((entry) => [entry.pseudo.id, entry]));
+  let refsBySite = new Map;
+  try {
+    const views = {};
+    for (const entry of pseudo)
+      views[entry.pseudo.id] = (site) => site === entry.pseudo;
+    const resolution = resolvePromptArguments(pseudo.map((entry) => entry.pseudo), ctx, { views, viewOf: (site) => site.id });
+    refsBySite = new Map(Object.entries(resolution.views ?? {}));
+  } catch (error) {
+    warnings.push(`prompt units: resolver failed (${error.message})`);
+  }
+  timings.resolve = Date.now() - clock;
+  clock = Date.now();
+  const units = new Map;
+  const add = (head, site, refs) => {
+    let unit = units.get(head.identity);
+    if (!unit) {
+      unit = {
+        key: head.key,
+        kind: head.kind,
+        path: head.path,
+        line: head.line,
+        endLine: head.endLine,
+        ...head.symbol ? { symbol: head.symbol } : {},
+        name: head.name,
+        roles: new Set,
+        sites: new Set,
+        identity: head.identity
+      };
+      units.set(head.identity, unit);
+    }
+    unit.roles.add(head.role);
+    unit.sites.add(site.id);
+    const flags = new Set(refs.flatMap((ref) => ref.via));
+    unit.via = unit.via ? new Set([...unit.via].filter((flag) => flags.has(flag))) : flags;
+    if (head.kind === "inline" && !unit.excerpt) {
+      const text = refs.map((ref) => ref.text).find((value) => value.trim().length > 0);
+      if (text)
+        unit.excerpt = text.replace(/\s+/g, " ").trim().slice(0, 80);
+    }
+  };
+  for (const [pseudoId, refs] of refsBySite) {
+    const entry = byId.get(pseudoId);
+    if (!entry || refs.length === 0)
+      continue;
+    const { site, role } = entry;
+    const models = refs.filter((ref) => ref.role !== "tool-description" && ref.role !== "tool-result");
+    if (models.length === 0)
+      continue;
+    let heads = [];
+    try {
+      const node = ctx.nodeAt(entry.pseudo.promptArgs[0].arg) ?? undefined;
+      const arg = entry.pseudo.promptArgs[0].arg;
+      if (node)
+        heads = new HeadFinder(rootDir, ctx, site).argument(node, arg.key ? arg.key.split(".") : [], role);
+    } catch (error) {
+      warnings.push(`prompt units ${site.id}: ${error.message}`);
+    }
+    const claimed = new Map;
+    const rest = [];
+    for (const ref of models) {
+      const owner = heads.length === 1 ? heads[0] : heads.find((head) => contains(head, ref));
+      if (owner) {
+        const list = claimed.get(owner) ?? [];
+        list.push(ref);
+        claimed.set(owner, list);
+      } else
+        rest.push(ref);
+    }
+    const members = [...claimed];
+    for (const ref of rest) {
+      const head = new HeadFinder(rootDir, ctx, site).fromHops(ref, heads[0]?.role ?? role);
+      if (head)
+        members.push([head, [ref]]);
+    }
+    if (heads.length === 0 && input.wrappedSinkIds?.has(site.id))
+      continue;
+    const call = members.some(([head]) => head.kind === "inline") ? new HeadFinder(rootDir, ctx, site).callFunction(role) : undefined;
+    for (const [head, list] of members) {
+      const target = head.kind === "inline" && call ? call : head;
+      add(target, site, list);
+      if (target !== head) {
+        const unit = units.get(target.identity);
+        unit.members ??= new Map;
+        unit.members.set(head.identity, { path: head.path, line: head.line, ...head.symbol ? { symbol: head.symbol } : {}, kind: head.kind });
+      }
+    }
+  }
+  timings.heads = Date.now() - clock;
+  return { units: [...units.values()], warnings, timings };
+}
+function contains(head, ref) {
+  if (ref.path === head.path && ref.line >= head.line && ref.line <= head.endLine)
+    return true;
+  return ref.hops.some((hop) => hop.path === head.path && hop.line === head.hopLine);
+}
+
+class HeadFinder {
+  rootDir;
+  ctx;
+  site;
+  constructor(rootDir, ctx, site) {
+    this.rootDir = rootDir;
+    this.ctx = ctx;
+    this.site = site;
+  }
+  callFunction(role) {
+    if (this.site.sdk === "think-hook")
+      return;
+    const sf = sourceFileOf(this.ctx, this.site.path);
+    if (!sf)
+      return;
+    const pos = sf.getPositionOfLineAndCharacter(Math.max(0, this.site.line - 1), Math.max(0, this.site.col - 1));
+    let node;
+    const visit2 = (current) => {
+      if (current.getStart(sf) <= pos && pos < current.getEnd()) {
+        node = current;
+        import_typescript.default.forEachChild(current, visit2);
+      }
+    };
+    visit2(sf);
+    if (!node)
+      return;
+    let outer;
+    for (let fn = isFunctionLike(node) ? node : enclosingFunction(node);fn; fn = enclosingFunction(fn)) {
+      if (functionName(fn))
+        return this.builder(fn, role, "call");
+      outer = fn;
+    }
+    if (!outer?.body)
+      return;
+    const path = relPath(this.rootDir, sf.fileName);
+    const scope = scopeOf(this.rootDir, outer.body);
+    const symbol = scope.includes("#") ? scope.slice(scope.indexOf("#") + 1) : `L${lineOf(outer)}`;
+    return {
+      kind: "call",
+      path,
+      line: lineOf(outer),
+      endLine: endLineOf(outer),
+      hopLine: lineOf(outer),
+      symbol,
+      name: symbol,
+      role,
+      identity: `${path}@${outer.getStart()}`,
+      key: `prompt:${path}#${symbol}`
+    };
+  }
+  argument(node, project, role) {
+    let current = node;
+    for (const field of project) {
+      const value = import_typescript.default.isExpression(current) ? this.objectField(unwrap(current), field) : undefined;
+      if (!value)
+        return [];
+      current = value;
+    }
+    if (role === "messages")
+      return this.messages(current, 0);
+    return this.heads(current, role, 0);
+  }
+  objectField(expr, field, depth = 0) {
+    if (depth > 3)
+      return;
+    if (import_typescript.default.isObjectLiteralExpression(expr)) {
+      for (const property of [...expr.properties].reverse()) {
+        if (propertyNameText(property.name) === field) {
+          if (import_typescript.default.isPropertyAssignment(property))
+            return property.initializer;
+          if (import_typescript.default.isShorthandPropertyAssignment(property))
+            return property.name;
+        }
+      }
+      return;
+    }
+    if (import_typescript.default.isIdentifier(expr)) {
+      const decl = this.declarationOf(expr);
+      if (decl && import_typescript.default.isVariableDeclaration(decl) && decl.initializer)
+        return this.objectField(unwrap(decl.initializer), field, depth + 1);
+    }
+    if (import_typescript.default.isCallExpression(expr) && expr.expression.getText() === "JSON.stringify" && expr.arguments[0])
+      return this.objectField(unwrap(expr.arguments[0]), field, depth + 1);
+    return;
+  }
+  checker(node) {
+    return this.ctx.checkerFor(relPath(this.rootDir, node.getSourceFile().fileName));
+  }
+  declarationOf(node) {
+    const checker = this.checker(node);
+    return checker ? valueDeclaration(resolvedSymbol(node, checker)) : undefined;
+  }
+  messages(node, depth) {
+    if (depth > MAX_DEPTH || !import_typescript.default.isExpression(node))
+      return [];
+    const expr = unwrap(node);
+    if (import_typescript.default.isIdentifier(expr)) {
+      const decl = this.declarationOf(expr);
+      if (decl && import_typescript.default.isVariableDeclaration(decl) && decl.initializer && inRepo(decl))
+        return this.messages(decl.initializer, depth + 1);
+      return [];
+    }
+    if (import_typescript.default.isArrayLiteralExpression(expr)) {
+      return expr.elements.flatMap((element) => import_typescript.default.isSpreadElement(element) ? this.messages(element.expression, depth + 1) : this.message(element, depth + 1));
+    }
+    if (import_typescript.default.isConditionalExpression(expr))
+      return [...this.messages(expr.whenTrue, depth + 1), ...this.messages(expr.whenFalse, depth + 1)];
+    return [];
+  }
+  message(node, depth) {
+    const expr = unwrap(node);
+    if (!import_typescript.default.isObjectLiteralExpression(expr))
+      return [];
+    const roleValue = this.objectField(expr, "role");
+    const roleText = roleValue && import_typescript.default.isStringLiteralLike(unwrap(roleValue)) ? unwrap(roleValue).text : undefined;
+    if (roleText && /^(?:assistant|tool|function|model)$/.test(roleText))
+      return [];
+    const role = roleText === "system" || roleText === "developer" ? "system" : roleText === "user" ? "user" : "messages";
+    const content = this.objectField(expr, "content");
+    if (!content)
+      return [];
+    const inner = unwrap(content);
+    if (import_typescript.default.isArrayLiteralExpression(inner)) {
+      return inner.elements.flatMap((part) => {
+        const text = import_typescript.default.isObjectLiteralExpression(unwrap(part)) ? this.objectField(unwrap(part), "text") : undefined;
+        return text ? this.heads(text, role, depth + 1) : [];
+      });
+    }
+    return this.heads(content, role, depth + 1);
+  }
+  heads(node, role, depth) {
+    if (depth > MAX_DEPTH)
+      return [];
+    if (isFunctionLike(node) || import_typescript.default.isFunctionDeclaration(node)) {
+      const head = this.builder(node, role);
+      return head ? [head] : [this.assembly(node, role)];
+    }
+    if (!import_typescript.default.isExpression(node))
+      return [];
+    const expr = unwrap(node);
+    if (import_typescript.default.isStringLiteralLike(expr) || import_typescript.default.isTemplateExpression(expr) || import_typescript.default.isArrayLiteralExpression(expr) || import_typescript.default.isBinaryExpression(expr) && expr.operatorToken.kind === import_typescript.default.SyntaxKind.PlusToken || import_typescript.default.isTaggedTemplateExpression(expr)) {
+      return [this.assembly(expr, role)];
+    }
+    if (import_typescript.default.isConditionalExpression(expr))
+      return [...this.heads(expr.whenTrue, role, depth + 1), ...this.heads(expr.whenFalse, role, depth + 1)];
+    if (import_typescript.default.isBinaryExpression(expr) && (expr.operatorToken.kind === import_typescript.default.SyntaxKind.QuestionQuestionToken || expr.operatorToken.kind === import_typescript.default.SyntaxKind.BarBarToken)) {
+      return [...this.heads(expr.left, role, depth + 1), ...this.heads(expr.right, role, depth + 1)];
+    }
+    if (import_typescript.default.isArrowFunction(expr) || import_typescript.default.isFunctionExpression(expr)) {
+      const head = this.builder(expr, role);
+      return head ? [head] : [this.assembly(expr, role)];
+    }
+    if (import_typescript.default.isIdentifier(expr) || import_typescript.default.isPropertyAccessExpression(expr)) {
+      if (import_typescript.default.isPropertyAccessExpression(expr) && /^(?:process\.env|import\.meta\.env)\b/.test(expr.getText()))
+        return [];
+      const decl = this.declarationOf(import_typescript.default.isPropertyAccessExpression(expr) ? expr.name : expr);
+      if (!decl || !inRepo(decl)) {
+        const file = import_typescript.default.isIdentifier(expr) ? this.textFile(expr) : undefined;
+        return file ? [file] : [];
+      }
+      return this.declarationHeads(decl, role, depth);
+    }
+    if (import_typescript.default.isCallExpression(expr)) {
+      const callee = unwrap(expr.expression);
+      if (import_typescript.default.isPropertyAccessExpression(callee)) {
+        const method = callee.name.text;
+        if (TEXT_METHODS.has(method))
+          return this.heads(callee.expression, role, depth + 1);
+        if (ASSEMBLY_METHODS.has(method))
+          return [this.assembly(expr, role)];
+      }
+      if (import_typescript.default.isIdentifier(callee) && TEXT_FUNCTIONS.test(callee.text))
+        return expr.arguments[0] ? this.heads(expr.arguments[0], role, depth + 1) : [];
+      const decl = this.declarationOf(import_typescript.default.isPropertyAccessExpression(callee) ? callee.name : callee);
+      const fn = decl ? this.functionOf(decl) : undefined;
+      if (fn && fn.body && inRepo(fn)) {
+        const head = this.builder(fn, role);
+        if (head)
+          return [head];
+      }
+      return [];
+    }
+    return [];
+  }
+  functionOf(decl) {
+    if (isFunctionLike(decl))
+      return decl;
+    if ((import_typescript.default.isVariableDeclaration(decl) || import_typescript.default.isPropertyAssignment(decl) || import_typescript.default.isPropertyDeclaration(decl)) && decl.initializer) {
+      const init = unwrap(decl.initializer);
+      if (import_typescript.default.isArrowFunction(init) || import_typescript.default.isFunctionExpression(init))
+        return init;
+    }
+    return;
+  }
+  declarationHeads(decl, role, depth) {
+    if (import_typescript.default.isParameter(decl) || import_typescript.default.isBindingElement(decl))
+      return [];
+    const fn = this.functionOf(decl);
+    if (fn) {
+      const head = this.builder(fn, role);
+      return head ? [head] : [];
+    }
+    const symbol = declarationSymbol(decl);
+    if (import_typescript.default.isVariableDeclaration(decl) && !symbol) {
+      if (!decl.initializer)
+        return [this.assembly(decl, role)];
+      const init = unwrap(decl.initializer);
+      const mutable = !(decl.parent.flags & import_typescript.default.NodeFlags.Const) || import_typescript.default.isArrayLiteralExpression(init);
+      return mutable ? [this.assembly(decl, role)] : this.heads(init, role, depth + 1);
+    }
+    if (!symbol)
+      return [];
+    if (import_typescript.default.isVariableDeclaration(decl) && decl.initializer) {
+      const init = unwrap(decl.initializer);
+      if (import_typescript.default.isCallExpression(init) && !this.isTextCall(init)) {
+        const heads = this.heads(init, role, depth + 1);
+        if (heads.length > 0)
+          return heads;
+      }
+    }
+    return [this.template(decl, symbol, role)];
+  }
+  isTextCall(call) {
+    const callee = unwrap(call.expression);
+    if (import_typescript.default.isIdentifier(callee))
+      return TEXT_FUNCTIONS.test(callee.text);
+    return import_typescript.default.isPropertyAccessExpression(callee) && (TEXT_METHODS.has(callee.name.text) || ASSEMBLY_METHODS.has(callee.name.text));
+  }
+  textFile(identifier) {
+    const checker = this.checker(identifier);
+    const clause = checker?.getSymbolAtLocation(identifier)?.declarations?.find(import_typescript.default.isImportClause);
+    const statement = clause?.parent;
+    if (!statement || !import_typescript.default.isStringLiteral(statement.moduleSpecifier))
+      return;
+    const spec = statement.moduleSpecifier.text;
+    if (!/\.(?:md|mdx|txt|prompt)(?:\?raw)?$/.test(spec) || !spec.startsWith("."))
+      return;
+    const path = relPath(this.rootDir, resolve(statement.getSourceFile().fileName, "..", spec.replace(/\?raw$/, "")));
+    return { kind: "file", path, line: 1, endLine: 1, hopLine: 1, name: path.split("/").pop() ?? path, role: "system", identity: `file:${path}`, key: `prompt:${path}` };
+  }
+  builder(fn, role, kind = "builder") {
+    if (!functionName(fn) || !inRepo(fn) || !fn.body)
+      return;
+    const scope = scopeOf(this.rootDir, fn.body);
+    const path = relPath(this.rootDir, fn.getSourceFile().fileName);
+    const holder = import_typescript.default.isArrowFunction(fn) || import_typescript.default.isFunctionExpression(fn) ? fn.parent : fn;
+    const symbol = scope.includes("#") ? scope.slice(scope.indexOf("#") + 1) : functionName(fn);
+    return {
+      kind,
+      path,
+      line: lineOf(holder),
+      endLine: endLineOf(fn),
+      hopLine: lineOf(fn),
+      symbol,
+      name: symbol,
+      role,
+      identity: `${path}@${fn.getStart()}`,
+      key: `prompt:${path}#${symbol}`
+    };
+  }
+  template(decl, symbol, role) {
+    const path = relPath(this.rootDir, decl.getSourceFile().fileName);
+    return {
+      kind: "template",
+      path,
+      line: lineOf(decl),
+      endLine: endLineOf(decl),
+      hopLine: lineOf(decl),
+      symbol,
+      name: symbol,
+      role,
+      identity: `${path}@${decl.getStart()}`,
+      key: `prompt:${path}#${symbol}`
+    };
+  }
+  assembly(node, role) {
+    for (let current = node;current && !import_typescript.default.isSourceFile(current); current = current.parent) {
+      if (isFunctionLike(current) || import_typescript.default.isFunctionDeclaration(current)) {
+        const fn = current;
+        if (fn.body && scopeOf(this.rootDir, fn.body) !== this.site.scope && functionName(fn)) {
+          const head = this.builder(fn, role);
+          if (head)
+            return head;
+        }
+        break;
+      }
+      if (current !== node && (import_typescript.default.isCallExpression(current) || import_typescript.default.isNewExpression(current)) && !(import_typescript.default.isCallExpression(current) && this.isTextCall(current)))
+        break;
+      if (import_typescript.default.isVariableDeclaration(current) || import_typescript.default.isPropertyDeclaration(current) || import_typescript.default.isPropertyAssignment(current)) {
+        const symbol = declarationSymbol(current);
+        if (symbol)
+          return this.template(current, symbol, role);
+      }
+    }
+    const path = relPath(this.rootDir, node.getSourceFile().fileName);
+    const scope = this.site.scope;
+    const owner = scope.includes("#") ? scope.slice(scope.indexOf("#") + 1) : scope.split("/").pop() ?? scope;
+    return {
+      kind: "inline",
+      path,
+      line: lineOf(node),
+      endLine: endLineOf(node),
+      hopLine: lineOf(node),
+      name: `${owner} ${role} prompt`,
+      role,
+      identity: `${path}@${node.getStart()}`,
+      key: `prompt:${scope}:${role}`
+    };
+  }
+  fromHops(ref, role) {
+    for (const hop of ref.hops) {
+      const builder = /^builder (\S+) called at /.exec(hop.reason);
+      const defined = / defined here$/.test(hop.reason) ? hop.reason.slice(0, -" defined here".length) : undefined;
+      if (!builder && (!defined || defined === "value"))
+        continue;
+      const sf2 = sourceFileOf(this.ctx, hop.path);
+      if (!sf2)
+        continue;
+      const name = builder ? builder[1] : defined;
+      const found = findDeclaration(sf2, hop.line, name);
+      if (!found)
+        continue;
+      const fn = isFunctionLike(found) ? found : this.functionOf(found);
+      if (fn) {
+        const head = this.builder(fn, role);
+        if (head)
+          return head;
+        continue;
+      }
+      const symbol = declarationSymbol(found);
+      if (symbol)
+        return this.template(found, symbol, role);
+    }
+    if (ref.kind === "file") {
+      return { kind: "file", path: ref.path, line: 1, endLine: 1, hopLine: 1, name: ref.path.split("/").pop() ?? ref.path, role, identity: `file:${ref.path}`, key: `prompt:${ref.path}` };
+    }
+    const sf = sourceFileOf(this.ctx, ref.path);
+    const anchor = sf ? nodeAtLine(sf, ref.line) : undefined;
+    if (anchor)
+      return this.assembly(anchor, role);
+    return;
+  }
+}
+function findDeclaration(sf, line, name) {
+  let found;
+  const start = sf.getPositionOfLineAndCharacter(Math.max(0, line - 1), 0);
+  const end = line < sf.getLineStarts().length ? sf.getPositionOfLineAndCharacter(line, 0) : sf.getEnd();
+  const visit2 = (node) => {
+    if (found || node.getEnd() < start || node.getStart(sf) > end)
+      return;
+    const named = import_typescript.default.isVariableDeclaration(node) || import_typescript.default.isPropertyAssignment(node) || import_typescript.default.isPropertyDeclaration(node) || import_typescript.default.isMethodDeclaration(node) || import_typescript.default.isFunctionDeclaration(node) || import_typescript.default.isGetAccessorDeclaration(node) || import_typescript.default.isShorthandPropertyAssignment(node) ? propertyNameText(node.name) : isFunctionLike(node) ? functionName(node) : undefined;
+    if (named === name && sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1 === line) {
+      found = node;
+      return;
+    }
+    import_typescript.default.forEachChild(node, visit2);
+  };
+  visit2(sf);
+  return found;
+}
+function nodeAtLine(sf, line) {
+  const start = sf.getPositionOfLineAndCharacter(Math.max(0, line - 1), 0);
+  let best;
+  const visit2 = (node) => {
+    if (best || node.getEnd() < start)
+      return;
+    const nodeLine = sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1;
+    if (nodeLine === line && (import_typescript.default.isExpression(node) || import_typescript.default.isVariableDeclaration(node) || import_typescript.default.isPropertyAssignment(node))) {
+      best = node;
+      return;
+    }
+    if (nodeLine > line)
+      return;
+    import_typescript.default.forEachChild(node, visit2);
+  };
+  visit2(sf);
+  return best;
+}
+
+// src/harness-extract/skeleton/edges.ts
+function skeletonEdgeId(edge) {
+  return `${edge.type}:${edge.from}->${edge.to}`;
+}
+function encodeSkeletonEdges(edges) {
+  const sorted = [...edges].sort((a, b) => skeletonEdgeId(a).localeCompare(skeletonEdgeId(b)));
+  const types = [...new Set(sorted.map((edge) => edge.type))].sort();
+  const nodes = [...new Set(sorted.flatMap((edge) => [edge.from, edge.to]))].sort();
+  const typeIndex = new Map(types.map((type, index) => [type, index]));
+  const nodeIndex = new Map(nodes.map((node, index) => [node, index]));
+  const rows = [];
+  const extra = {};
+  sorted.forEach((edge, row) => {
+    rows.push(typeIndex.get(edge.type), nodeIndex.get(edge.from), nodeIndex.get(edge.to));
+    const { id: _id, type: _type, from: _from, to: _to, source, evidence, ...rest } = edge;
+    const fields = { ...rest };
+    if (source !== "code")
+      fields.source = source;
+    if (evidence.length)
+      fields.evidence = evidence;
+    if (Object.keys(fields).length)
+      extra[String(row)] = fields;
+  });
+  return { types, nodes, rows, ...Object.keys(extra).length ? { extra } : {} };
+}
+function decodeSkeletonEdges(table) {
+  if (!table)
+    return [];
+  const edges = [];
+  for (let row = 0;row * 3 < table.rows.length; row += 1) {
+    const type = table.types[table.rows[row * 3]];
+    const from = table.nodes[table.rows[row * 3 + 1]], to = table.nodes[table.rows[row * 3 + 2]];
+    const { source, evidence, ...rest } = table.extra?.[String(row)] ?? {};
+    edges.push({ id: skeletonEdgeId({ type, from, to }), type, from, to, source: source ?? "code", evidence: evidence ?? [], ...rest });
+  }
+  return edges;
+}
+
+// src/harness-extract/skeleton/types.ts
+var SKELETON_VERSION = "harness-skeleton/v1";
+var SKELETON_DIFF_VERSION = "harness-skeleton-diff/v1";
+// src/harness-extract/skeleton/diff.ts
+import { isDeepStrictEqual } from "node:util";
+var COMPONENTS = ["agent", "entrypoint", "call_site", "prompt", "tool", "model", "skill", "eval", "edge", "control_flow"];
+var FIELDS = {
+  agent: ["entry", "liveKey"],
+  entrypoint: ["name", "trigger"],
+  call_site: ["agentIds", "modelIds", "modelSource", "promptIds", "toolIds", "viaHelper"],
+  prompt: ["unitKind", "roles", "usedByAgentIds"],
+  tool: ["usedByAgentIds", "schema.path", "implementation.path"],
+  model: ["usedByAgentIds", "resolution"],
+  skill: ["name", "liveKey", "skillKind", "usedByAgentIds"],
+  eval: ["usedByAgentIds", "covers"],
+  edge: [],
+  control_flow: ["kind", "actsOn", "condition"]
+};
+function components(graph) {
+  const map = new Map(COMPONENTS.map((kind) => [kind, []]));
+  const add = (kind, value) => {
+    map.get(kind).push(value);
+  };
+  for (const agent of graph.runtimeAgents)
+    add("agent", agent);
+  for (const artifact of graph.artifacts)
+    add(artifact.type === "model_config" ? "model" : artifact.type, artifact);
+  for (const call of graph.skeleton.callSites)
+    add("call_site", { ...call, name: call.callee });
+  for (const item of graph.skeleton.controlFlow)
+    add("control_flow", { ...item, name: `${item.kind}:${item.scope}` });
+  for (const edge of decodeSkeletonEdges(graph.skeleton.edges))
+    add("edge", { ...edge, name: `${edge.type}: ${edge.from} -> ${edge.to}` });
+  return map;
+}
+function at(item) {
+  return item.sourcePath ? { path: item.sourcePath, line: item.line ?? 1 } : undefined;
+}
+function field(item, path) {
+  let value = item;
+  for (const key of path.split("."))
+    value = value && typeof value === "object" ? value[key] : undefined;
+  return value ?? null;
+}
+function moveKey(item, kind) {
+  return JSON.stringify([item.name, kind === "prompt" ? item.unitKind : null]);
+}
+function diffHarnessSkeletons(before, after) {
+  const left = components(before), right = components(after);
+  const changes = [];
+  const summary = Object.fromEntries(COMPONENTS.map((kind) => [kind, { added: 0, removed: 0, moved: 0, changed: 0 }]));
+  const emit = (change) => {
+    changes.push(change);
+    summary[change.component][change.change]++;
+  };
+  const compare = (a, b, kind) => {
+    if (a.sourcePath !== b.sourcePath)
+      emit({ change: "moved", component: kind, id: b.id, ...a.id !== b.id ? { fromId: a.id } : {}, name: b.name, from: at(a), to: at(b) });
+    const fields = FIELDS[kind].filter((key) => !isDeepStrictEqual(field(a, key), field(b, key))).map((key) => ({ field: key, from: field(a, key), to: field(b, key) }));
+    if (fields.length)
+      emit({ change: "changed", component: kind, id: b.id, name: b.name, from: at(a), to: at(b), fields });
+  };
+  for (const kind of COMPONENTS) {
+    const old = new Map(left.get(kind).map((item) => [item.id, item])), next = new Map(right.get(kind).map((item) => [item.id, item]));
+    for (const [id, item] of old)
+      if (next.has(id)) {
+        compare(item, next.get(id), kind);
+        old.delete(id);
+        next.delete(id);
+      }
+    for (const [id, item] of old) {
+      const key = moveKey(item, kind);
+      const from = [...old.values()].filter((candidate) => moveKey(candidate, kind) === key);
+      const to = [...next.values()].filter((candidate) => moveKey(candidate, kind) === key);
+      if (from.length !== 1 || to.length !== 1 || item.sourcePath === to[0].sourcePath)
+        continue;
+      compare(item, to[0], kind);
+      old.delete(id);
+      next.delete(to[0].id);
+    }
+    for (const item of old.values())
+      emit({ change: "removed", component: kind, id: item.id, name: item.name, from: at(item) });
+    for (const item of next.values())
+      emit({ change: "added", component: kind, id: item.id, name: item.name, to: at(item) });
+  }
+  changes.sort((a, b) => a.component.localeCompare(b.component) || a.change.localeCompare(b.change) || a.id.localeCompare(b.id));
+  return {
+    version: SKELETON_DIFF_VERSION,
+    from: { commit: before.skeleton.commit, contentHash: before.skeleton.contentHash },
+    to: { commit: after.skeleton.commit, contentHash: after.skeleton.contentHash },
+    identical: before.skeleton.contentHash === after.skeleton.contentHash,
+    summary,
+    changes
+  };
+}
+
+// src/harness-extract/skeleton/index.ts
+var controlFlowDetector;
+var COVERAGE = {
+  agents: "complete",
+  workflows: "complete",
+  tools: "complete",
+  skills: "complete",
+  evalFiles: "partial",
+  models: "partial",
+  modelConfig: "partial",
+  evalSuites: "partial",
+  subagentEdges: "partial",
+  prompts: "partial",
+  controlFlow: "partial"
+};
+var KNOWN_GAPS = {
+  prompts: ["text that reaches an agent as a chat message from a client (no model call in its file)", "templates selected from a table by a runtime key", "model calls in Svelte components (the prompt resolver reads JavaScript and TypeScript)"],
+  subagentEdges: ["dispatch through a runner object built by a host and passed in as data", "logical initiators (a component that asks the host to start a sub-agent)"],
+  models: ["model ids in flag or alias tables read with a computed key (calls list them as modelCandidates)", "rate-card and compatibility ids no call uses"],
+  tools: ["tool sets passed through a shared helper whose tools parameter is not traced to its callers (a host that calls the helper is credited with the registry)"],
+  modelConfig: ["configuration rows outside model call arguments (CI workflows, tables)"],
+  evalSuites: ["suites grouped by runner rather than directory"],
+  controlFlow: ["filled by the registered control-flow detector only"]
+};
+function agentKey(name) {
+  return name.replace(/\s*\([^)]*\)\s*$/, "").toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function toolKey(name) {
+  return name.replace(/\s*\([^)]*\)\s*$/, "").trim();
+}
+function skillKey(name) {
+  return name.trim().toLowerCase();
+}
+function modelKey(id) {
+  return id.trim().toLowerCase().replace(/^[a-z0-9-]+[/:]/, "").replace(/[._]/g, "-").replace(/-(?:low|medium|high|xhigh|max|minimal|none|fast|thinking)$/, "").replace(/-(?:latest|\d{8}|\d{4}-\d{2}-\d{2})$/, "");
+}
+function canonicalJson(value) {
+  return JSON.stringify(value, (_key, item) => item && typeof item === "object" && !Array.isArray(item) ? Object.fromEntries(Object.entries(item).filter(([, v]) => v !== undefined).sort(([a], [b]) => a.localeCompare(b))) : item);
+}
+var ROUTE_METHOD = /^(GET|POST|PUT|PATCH|DELETE|OPTIONS|HEAD)\b/;
+var sorted = (values) => [...new Set(values)].sort();
+var byId = (a, b) => a.id.localeCompare(b.id);
+var staticStatus = (status) => status === "reachable" || status === "in_prod" ? "reachable" : "defined_only";
+var location = (node, ctx) => ({ path: relPath(ctx.rootDir, node.getSourceFile().fileName), line: lineOf(node) });
+function setOwners(item, ids, global = false) {
+  delete item.ownedByAgentId;
+  Object.assign(item, owned(ids, global));
+}
+function owned(ids, global = false) {
+  const users = sorted(ids);
+  return {
+    scope: users.length === 1 ? "agent" : global && users.length === 0 ? "global" : "shared",
+    usedByAgentIds: users,
+    ...users.length === 1 ? { ownedByAgentId: users[0] } : {}
+  };
+}
+function git(root, args) {
+  try {
+    return execFileSync("git", ["-C", root, ...args], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+  } catch {
+    return;
+  }
+}
+function repoName(root) {
+  try {
+    const pkg = JSON.parse(readFileSync(resolve2(root, "package.json"), "utf8"));
+    if (typeof pkg.name === "string")
+      return pkg.name;
+  } catch {}
+  try {
+    const project = parse(readFileSync(resolve2(root, "pyproject.toml"), "utf8")).project;
+    if (project && typeof project === "object" && typeof project.name === "string")
+      return project.name;
+  } catch {}
+  return basename(root);
+}
+function buildHarnessSkeleton(rootDir, options = {}) {
+  const start = Date.now();
+  const { result, ctx } = extractHarnessWithContext(resolve2(rootDir), { ...options, tracePrompts: false });
+  options.onTiming?.({ phase: "extract", durationMs: Date.now() - start });
+  for (const [phase, durationMs] of Object.entries(result.timings))
+    options.onTiming?.({ phase: `extract.${phase}`, durationMs });
+  const graph = skeletonFromExtract(result, ctx, options);
+  graph.skeleton.durationMs = Date.now() - start;
+  return graph;
+}
+function skeletonFromExtract(result, ctx, options = {}) {
+  const start = Date.now();
+  let clock = start;
+  const mark = (phase) => {
+    const now = Date.now();
+    options.onTiming?.({ phase: `build.${phase}`, durationMs: now - clock });
+    clock = now;
+  };
+  const repo = enumerationRepository(ctx);
+  const enumeration = enumerateAgents(result, ctx);
+  const agentForScope = enumeration.agentForScope;
+  const warnings = [...result.warnings];
+  const sites = result.callSites.filter((site) => !site.isTest).sort((a, b) => a.path.localeCompare(b.path) || a.line - b.line || a.col - b.col);
+  const ordinals = new Map;
+  const unique = (key) => {
+    const n = (ordinals.get(key) ?? 0) + 1;
+    ordinals.set(key, n);
+    return n === 1 ? key : `${key}~${n}`;
+  };
+  const callIds = new Map(sites.map((site) => [site.id, unique(`call:${site.scope}:${site.callee}`)]));
+  const callSites = sites.map((site) => ({
+    id: callIds.get(site.id),
+    sourcePath: site.path,
+    line: site.line,
+    col: site.col,
+    scope: site.scope,
+    callee: site.callee,
+    sdk: site.sdk,
+    ...site.provider ? { provider: site.provider } : {},
+    ...site.viaHelper && callIds.has(site.viaHelper) ? { viaHelper: callIds.get(site.viaHelper) } : {},
+    agentIds: sorted(agentForScope(site.scope)),
+    modelIds: [],
+    promptIds: [],
+    toolIds: [],
+    status: staticStatus(site.status),
+    ...site.isEval ? { isEval: true } : {}
+  }));
+  const callByExtractId = new Map(sites.map((site, i) => [site.id, callSites[i]]));
+  const agents = enumeration.runtimeAgents.map((agent) => {
+    const evidence = agent.evidence[0];
+    const path = evidence?.path ?? ".";
+    const line = evidence?.line ?? 1;
+    const file = repo.files.find((file2) => file2.path === path);
+    let anchor;
+    if (file)
+      visit(file.source, (node) => {
+        if (!anchor && (import_typescript2.default.isClassLike(node) || import_typescript2.default.isFunctionDeclaration(node) || import_typescript2.default.isArrowFunction(node) || import_typescript2.default.isMethodDeclaration(node)) && lineOf(node) === line)
+          anchor = node;
+      });
+    const method = ROUTE_METHOD.exec(agent.name)?.[1];
+    if (file && method) {
+      let handler;
+      visit(file.source, (node) => {
+        if (!handler && isFunctionLike(node) && functionName(node) === method && lineOf(node) <= line && line <= node.getSourceFile().getLineAndCharacterOfPosition(node.getEnd()).line + 1)
+          handler = node;
+      });
+      if (handler) {
+        anchor = import_typescript2.default.isVariableDeclaration(handler.parent) ? handler.parent : handler;
+      }
+    }
+    const cls = anchor && import_typescript2.default.isClassLike(anchor) ? anchor : undefined;
+    const symbol = cls?.name?.text ?? agent.name;
+    const base = cls?.heritageClauses?.flatMap((clause) => clause.types)[0]?.expression.getText();
+    return {
+      ...agent,
+      root: ".",
+      status: staticStatus(agent.status),
+      evidence: agent.evidence.slice(0, 3),
+      sourcePath: path,
+      line: anchor ? lineOf(anchor) : line,
+      endLine: anchor ? anchor.getSourceFile().getLineAndCharacterOfPosition(anchor.getEnd()).line + 1 : line,
+      entry: { kind: cls ? "class" : ROUTE_METHOD.test(agent.name) ? "route" : "function", symbol, ...base ? { base } : {} },
+      callSiteIds: callSites.filter((site) => site.agentIds.includes(agent.id)).map((site) => site.id).sort(),
+      artifactIds: [],
+      entrypointIds: []
+    };
+  });
+  mark("agents");
+  const artifacts = [];
+  const prompts = collectPromptUnits({ rootDir: ctx.rootDir, ctx, sites, wrappedSinkIds: new Set(Object.values(result.wrapperSinks).map((wrapper) => wrapper.sinkId)) });
+  warnings.push(...prompts.warnings);
+  for (const [phase, durationMs] of Object.entries(prompts.timings))
+    options.onTiming?.({ phase: `build.prompts.${phase}`, durationMs });
+  for (const unit of prompts.units.sort((a, b) => a.path.localeCompare(b.path) || a.line - b.line || a.identity.localeCompare(b.identity))) {
+    const id = unique(unit.key);
+    const calls = [...unit.sites].flatMap((id2) => callByExtractId.get(id2) ?? []);
+    artifacts.push({
+      id,
+      type: "prompt",
+      name: unit.name,
+      sourcePath: unit.path,
+      line: unit.line,
+      endLine: unit.endLine,
+      unitKind: unit.kind,
+      ...unit.symbol ? { symbol: unit.symbol } : {},
+      roles: [...unit.roles].sort(),
+      callSiteIds: calls.map((call) => call.id).sort(),
+      ...unit.via?.size ? { via: [...unit.via].sort() } : {},
+      ...unit.excerpt ? { excerpt: unit.excerpt.slice(0, 80) } : {},
+      ...unit.members?.size ? { members: [...unit.members.values()].sort((a, b) => a.path.localeCompare(b.path) || a.line - b.line).slice(0, 20) } : {},
+      ...owned(calls.flatMap((call) => call.agentIds)),
+      status: repo.status(unit.path),
+      confidence: 0.9,
+      evidence: [{ path: unit.path, line: unit.line, reason: `skeleton prompt-unit ${unit.kind}` }]
+    });
+    for (const call of calls)
+      call.promptIds.push(id);
+  }
+  mark("prompts");
+  const tools = emitToolsCached(result, ctx);
+  const emittedTools = toolArtifacts(tools, agents);
+  for (let i = 0;i < tools.length; i++) {
+    const tool = tools[i], emitted = emittedTools[i];
+    const definition = tool.definitions[0];
+    const node = definition && ctx.nodeAt(definition);
+    const details = node ? toolLocations(node, ctx) : { schema: null, implementation: null };
+    artifacts.push({
+      id: emitted.id,
+      type: "tool",
+      name: tool.name,
+      ...owned(emitted.usedByAgentIds),
+      sourcePath: definition?.path ?? tool.evidence[0]?.path,
+      line: definition?.line ?? tool.evidence[0]?.line,
+      ...definition ? { definition: { path: definition.path, line: definition.line } } : {},
+      ...tool.definitions.length > 1 ? { definitionCount: tool.definitions.length } : {},
+      ...details,
+      via: tool.via,
+      status: tool.status,
+      confidence: emitted.confidence,
+      evidence: emitted.evidence.slice(0, 3)
+    });
+  }
+  const catalog = enumerateToolCatalog(result, ctx);
+  warnings.push(...catalog.warnings);
+  for (const tool of catalog.artifacts) {
+    if (artifacts.some((item) => item.type === "tool" && item.name === tool.name && item.sourcePath === tool.sourcePath))
+      continue;
+    artifacts.push({
+      id: tool.id,
+      type: "tool",
+      name: tool.name,
+      sourcePath: tool.sourcePath,
+      line: tool.evidence[0]?.line,
+      ...owned(tool.usedByAgentIds),
+      confidence: tool.confidence,
+      status: staticStatus(tool.status),
+      evidence: tool.evidence.slice(0, 3),
+      via: "catalog",
+      schema: null,
+      implementation: null
+    });
+  }
+  for (const role of result.roles.filter((role2) => role2.role === "tools" && !role2.sink.isTest)) {
+    const call = callByExtractId.get(role.sink.id);
+    if (!call)
+      continue;
+    for (const hit of toolNamesOf(role.tree).names) {
+      const candidates = artifacts.filter((item) => item.type === "tool" && item.name === hit.name);
+      const exact = candidates.filter((item) => tools.find((tool) => tool.id === item.id)?.definitions.some((definition) => definition.path === hit.path && (hit.start === undefined || hit.start >= definition.start && hit.start <= definition.end)));
+      const matches = exact.length ? exact : candidates.length === 1 ? candidates : candidates.filter((item) => item.usedByAgentIds.some((id) => call.agentIds.includes(id)));
+      for (const tool of matches) {
+        call.toolIds.push(tool.id);
+        setOwners(tool, [...tool.usedByAgentIds, ...call.agentIds]);
+      }
+    }
+  }
+  const dynamicTools = new Set(result.roles.filter((role) => role.role === "tools" && (role.sink.sdk === "think-hook" || toolNamesOf(role.tree).unresolved.length > 0)).map((role) => role.sink.id));
+  const forwardsTools = new Set(Object.values(result.wrapperSinks).filter((wrapper) => wrapper.roles.some((role) => role.role === "tools")).map((wrapper) => wrapper.sinkId));
+  const receivingSites = sites.filter((site) => site.toolsArg && !forwardsTools.has(site.id) && dynamicTools.has(site.id));
+  const offeredTo = new Map;
+  for (const call of callSites)
+    for (const id of call.toolIds)
+      for (const agent of call.agentIds)
+        offeredTo.set(id, (offeredTo.get(id) ?? new Set).add(agent));
+  const receivers = new Set(receivingSites.flatMap((site) => agentForScope(site.scope)));
+  for (const item of artifacts)
+    if (item.type === "tool")
+      setOwners(item, item.usedByAgentIds.filter((id) => receivers.has(id) || offeredTo.get(item.id)?.has(id)));
+  mark("tools");
+  let modelResult = result;
+  if (result.models?.some((model) => model.calledFrom.length >= 50)) {
+    modelResult = { ...result, warnings: [] };
+    collectModels(modelResult, ctx, { maxCalledFrom: Math.max(1, result.callSites.length) });
+    warnings.push(...modelResult.warnings);
+  }
+  const models = modelArtifacts(modelResult);
+  const reached = new Map;
+  const extracted = modelResult.models ?? [];
+  extracted.forEach((model, i) => {
+    for (const caller of model.calledFrom)
+      reached.set(caller.callSite, [...reached.get(caller.callSite) ?? [], i]);
+  });
+  const computed = new Set([...reached].filter(([, list]) => list.length >= 3 && list.some((i) => extracted[i].resolution === "oneOf")).map(([id]) => id));
+  for (const id of computed) {
+    const call = callByExtractId.get(id);
+    if (!call)
+      continue;
+    call.modelSource = "factory (computed)";
+    call.modelCandidates = sorted(reached.get(id).map((i) => models[i].id));
+    for (const agent of agents)
+      if (call.agentIds.includes(agent.id))
+        (agent.modelChoices ??= []).push({ callSiteId: call.id, sourcePath: call.sourcePath, line: call.line, source: "computed", candidateIds: call.modelCandidates });
+  }
+  for (let i = 0;i < models.length; i++) {
+    const model = extracted[i], emitted = models[i];
+    const calls = model.calledFrom.filter((caller) => !computed.has(caller.callSite)).flatMap((caller) => callByExtractId.get(caller.callSite) ?? []);
+    artifacts.push({
+      id: emitted.id,
+      type: "model_config",
+      name: emitted.name,
+      sourcePath: model.definition.path,
+      line: model.definition.line,
+      resolution: model.resolution,
+      configLocations: (model.otherDefinitions ?? []).slice(0, 10),
+      callSiteIds: sorted(calls.map((call) => call.id)),
+      ...owned(calls.flatMap((call) => call.agentIds)),
+      confidence: emitted.confidence,
+      evidence: emitted.evidence.slice(0, 3),
+      status: repo.status(model.definition.path)
+    });
+    for (const call of calls)
+      call.modelIds.push(emitted.id);
+  }
+  for (const unresolved of result.unresolvedModels ?? []) {
+    const call = callByExtractId.get(unresolved.callSite);
+    if (call && !call.modelSource)
+      call.modelSource = unresolved.source;
+  }
+  mark("models");
+  const workflows = enumerateWorkflows(result, ctx);
+  warnings.push(...workflows.warnings);
+  for (const entry of workflows.artifacts) {
+    const meta = entry;
+    const users = agentForScope(`${entry.sourcePath}#${entry.name}`);
+    artifacts.push({
+      id: entry.id,
+      type: "entrypoint",
+      name: entry.name,
+      sourcePath: entry.sourcePath,
+      line: entry.evidence[0]?.line ?? 1,
+      ...meta.componentKind ? { componentKind: meta.componentKind } : {},
+      ...meta.trigger ? { trigger: meta.trigger } : {},
+      ...owned(users),
+      confidence: entry.confidence,
+      evidence: entry.evidence.slice(0, 3),
+      status: staticStatus(entry.status)
+    });
+    for (const agent of agents.filter((agent2) => users.includes(agent2.id)))
+      agent.entrypointIds.push(entry.id);
+  }
+  collectTriggers({ ctx, agents, artifacts, enumeration, handoffs: result.handoffs ?? [], status: (path) => staticStatus(repo.status(path)) });
+  mark("workflows");
+  for (const path of import_fast_glob.default.sync(["**/SKILL.md", "**/skills/**/*.md"], {
+    cwd: ctx.rootDir,
+    dot: false,
+    onlyFiles: true,
+    followSymbolicLinks: false,
+    ignore: ["**/node_modules/**", "**/.git/**", "**/.claude/worktrees/**", "**/dist/**", "**/vendor/**", "**/test/**", "**/tests/**", "**/fixtures/**"]
+  }).sort()) {
+    const text = readFileSync(resolve2(ctx.rootDir, path), "utf8");
+    const frontmatter = /^---\r?\n([\s\S]*?)\r?\n---/.exec(text)?.[1];
+    const name2 = frontmatter && /^name:\s*['"]?(.+?)['"]?\s*$/m.exec(frontmatter)?.[1];
+    if (basename(path) !== "SKILL.md" && !(name2 && /^description:/m.test(frontmatter ?? "")))
+      continue;
+    const users = repo.files.filter((file) => !TEST_PATH.test(file.path) && (file.text.includes(path) || file.text.includes(dirname(path)))).flatMap((file) => {
+      const ids = [];
+      visit(file.source, (node) => {
+        if (import_typescript2.default.isStringLiteralLike(node) && (node.text.includes(path) || node.text === dirname(path)))
+          ids.push(...agentForScope(scopeOf(ctx.rootDir, node)));
+      });
+      return ids;
+    });
+    artifacts.push({
+      id: `skill:${path}`,
+      type: "skill",
+      name: name2 ?? basename(dirname(path)),
+      sourcePath: path,
+      line: 1,
+      skillKind: basename(path) === "SKILL.md" ? "skill_md" : "frontmatter",
+      ...owned(users, true),
+      confidence: 1,
+      evidence: [{ path, line: 1, reason: "skeleton skill file" }],
+      status: repo.status(path)
+    });
+  }
+  for (const entry of markdownCatalogs(ctx)) {
+    if (artifacts.some((item) => item.type === "skill" && item.sourcePath === entry.path))
+      continue;
+    artifacts.push({
+      id: `skill:${entry.path}`,
+      type: "skill",
+      name: entry.name,
+      sourcePath: entry.path,
+      line: 1,
+      skillKind: "catalog",
+      ...owned([], true),
+      confidence: 0.8,
+      evidence: [{ path: entry.path, line: 1, reason: "skeleton skill file" }, { path: entry.catalogPath, line: entry.catalogLine, reason: "skeleton markdown catalog entry" }],
+      status: repo.status(entry.catalogPath)
+    });
+  }
+  mark("skills");
+  const relationships = [];
+  const edgeIds = new Set;
+  const addEdge = (edge) => {
+    const id = `${edge.type}:${edge.from}->${edge.to}`;
+    if (!edgeIds.has(id)) {
+      edgeIds.add(id);
+      relationships.push({ id, source: "code", ...edge });
+    }
+  };
+  for (const handoff of result.handoffs ?? []) {
+    const scoped = agentForScope(handoff.scope);
+    const parents = scoped.length ? scoped : agents.filter((agent) => handoff.owners.some((owner) => owner.path === agent.sourcePath && owner.name === agent.entry.symbol)).map((agent) => agent.id);
+    for (const target of handoff.targets)
+      for (const from of parents) {
+        const child = agents.find((agent) => agent.sourcePath === target.path && agent.entry.symbol === target.name);
+        if (child && child.id !== from)
+          addEdge({
+            type: "invokes_subagent",
+            from,
+            to: child.id,
+            sourcePath: handoff.path,
+            line: handoff.line,
+            via: handoff.callee,
+            evidence: [{ path: handoff.path, line: handoff.line, reason: "skeleton subagent class call" }]
+          });
+      }
+  }
+  collectDeclaredHandoffs(ctx, agents, agentForScope, addEdge);
+  mark("handoffs");
+  const suites = new Map;
+  for (const file of repo.files)
+    if (evalFileSignal(file.path, file.text)) {
+      const key = evalSuiteKey(file.path);
+      suites.set(key, [...suites.get(key) ?? [], file]);
+    }
+  const importsByPath = new Map;
+  for (const [key, members] of suites) {
+    const runner = [...members].sort((a, b) => Number(!/(?:^|\/)(?:run|runner|index|main|eval)\.[^.]+$/.test(a.path)) - Number(!/(?:^|\/)(?:run|runner|index|main|eval)\.[^.]+$/.test(b.path)) || a.path.localeCompare(b.path))[0];
+    const paths = importClosure(members.map((file) => file.path), ctx, importsByPath, new Set(members.map((file) => file.path)));
+    const drivesWorker = members.some((file) => /from\s+['"]cloudflare:(?:workers|test)['"]/.test(file.text) && /\b(?:exports|SELF)\b/.test(file.text));
+    const configs = [...new Set(agents.flatMap((agent) => agent.entrypointIds).map((id2) => /^binding:((?:[^#]*\/)?wrangler\.(?:jsonc?|toml))#/.exec(id2)?.[1]).filter((path) => Boolean(path)))];
+    const worker = configs.filter((path) => {
+      const dir = path.includes("/") ? path.slice(0, path.lastIndexOf("/") + 1) : "";
+      return runner.path.startsWith(dir);
+    }).sort((a, b) => b.length - a.length)[0];
+    const workerAgents = drivesWorker && worker ? agents.filter((agent) => agent.entrypointIds.some((id2) => id2.startsWith(`binding:${worker}#`))).map((agent) => agent.id) : [];
+    const coveredAgents = agents.filter((agent) => paths.has(agent.sourcePath) || workerAgents.includes(agent.id));
+    const covered = artifacts.filter((item) => item.sourcePath && paths.has(item.sourcePath));
+    const evalCalls = callSites.filter((call) => members.some((file) => file.path === call.sourcePath));
+    const covers = {
+      agentIds: coveredAgents.map((agent) => agent.id).sort(),
+      promptIds: sorted([...covered.filter((item) => item.type === "prompt").map((item) => item.id), ...evalCalls.flatMap((call) => call.promptIds)]),
+      toolIds: sorted([...covered.filter((item) => item.type === "tool").map((item) => item.id), ...evalCalls.flatMap((call) => call.toolIds)]),
+      modelIds: sorted([...covered.filter((item) => item.type === "model_config").map((item) => item.id), ...evalCalls.flatMap((call) => call.modelIds)])
+    };
+    const id = `eval:${key}`;
+    artifacts.push({
+      id,
+      type: "eval",
+      name: key,
+      sourcePath: runner.path,
+      line: 1,
+      memberCount: members.length,
+      covers,
+      ...owned(covers.agentIds, true),
+      confidence: 0.9,
+      evidence: [{ path: runner.path, line: 1, reason: "skeleton eval suite" }],
+      status: repo.status(runner.path)
+    });
+    for (const from of [...covers.agentIds, ...covers.toolIds])
+      addEdge({ type: "covered_by_eval", from, to: id, evidence: [] });
+  }
+  mark("evals");
+  for (const call of callSites) {
+    call.promptIds = sorted(call.promptIds);
+    call.toolIds = sorted(call.toolIds);
+    call.modelIds = sorted(call.modelIds);
+  }
+  for (const agent of agents) {
+    agent.artifactIds = artifacts.filter((item) => item.usedByAgentIds.includes(agent.id)).map((item) => item.id).sort();
+    agent.entrypointIds.sort();
+  }
+  let controlFlow = [];
+  let controlFlowStatus = "not_run";
+  if (controlFlowDetector) {
+    try {
+      const knownCalls = new Set(callSites.map((call) => call.id)), knownAgents = new Set(agents.map((agent) => agent.id));
+      controlFlow = controlFlowDetector({ result, ctx, callSites, agents, callSiteIdOf: (id) => callIds.get(id) }).filter((item) => item.actsOn.callSiteIds.every((id) => knownCalls.has(id)) && item.actsOn.agentIds.every((id) => knownAgents.has(id))).map((item) => ({ ...item, condition: item.condition.slice(0, 160) })).sort(byId);
+      controlFlowStatus = "ran";
+    } catch (error) {
+      controlFlowStatus = "failed";
+      warnings.push(`control-flow detector: ${error.message}`);
+    }
+  }
+  for (const agent of agents)
+    for (const entry of agent.entrypointIds)
+      addEdge({ type: "triggers", from: entry, to: agent.id, evidence: [] });
+  for (const item of artifacts) {
+    if (item.type === "prompt" || item.type === "tool" || item.type === "model_config")
+      for (const agent of item.usedByAgentIds)
+        addEdge({ type: "uses_artifact", from: agent, to: item.id, evidence: [] });
+    if (item.type === "tool" && item.implementation)
+      addEdge({ type: "implemented_by", from: item.id, to: `code:${item.implementation.path}#${item.implementation.symbol ?? item.id}`, evidence: [] });
+  }
+  for (const item of controlFlow) {
+    for (const agent of item.actsOn.agentIds)
+      addEdge({ type: "has_control_flow", from: agent, to: item.id, evidence: [] });
+    for (const call of item.actsOn.callSiteIds)
+      addEdge({ type: "guards", from: item.id, to: call, evidence: [] });
+  }
+  for (const agent of agents)
+    agent.liveKey = agentKey(agent.entry.kind === "class" ? agent.entry.symbol : agent.name);
+  for (const item of artifacts) {
+    const key = item.type === "tool" ? toolKey(item.name) : item.type === "model_config" ? modelKey(item.name) : item.type === "skill" ? skillKey(item.name) : undefined;
+    if (key)
+      item.liveKey = key;
+    else
+      delete item.liveKey;
+  }
+  agents.sort(byId);
+  artifacts.sort(byId);
+  callSites.sort(byId);
+  relationships.sort((a, b) => a.id.localeCompare(b.id));
+  const edgeTable = encodeSkeletonEdges(relationships);
+  const graphEdges = relationships.filter((edge) => edge.type === "invokes_subagent" || edge.type === "hands_off_to").map(({ id: _id, source: _source, ...edge }) => {
+    return edge;
+  });
+  const name = repoName(ctx.rootDir), generatorVersion = VERSION;
+  mark("ownershipAndControlFlow");
+  const graph = {
+    schemaVersion: "harness.v0.1",
+    harnessId: stableId("harness", name),
+    repo: {
+      root: ".",
+      name,
+      languages: sorted(sites.map((site) => site.language === "py" ? "python" : "typescript")),
+      packageManagers: import_fast_glob.default.sync(["package-lock.json", "bun.lock", "bun.lockb", "pnpm-lock.yaml", "yarn.lock", "uv.lock"], { cwd: ctx.rootDir }).map((path) => path.startsWith("bun") ? "bun" : path.startsWith("pnpm") ? "pnpm" : path.startsWith("yarn") ? "yarn" : path.startsWith("uv") ? "uv" : "npm").sort()
+    },
+    scan: {
+      createdAt: new Date().toISOString(),
+      scannerVersion: generatorVersion,
+      mode: "permissioned",
+      rootPaths: ["."],
+      skipped: [],
+      readPlan: { scope: "broad", rootPaths: ["."], willRead: ["Local source and harness configuration"], willSkip: ["Dependencies, generated files, ordinary unit tests"], skipsSecretFiles: true, followsSymlinks: false, uploadsSourceByDefault: false }
+    },
+    agentFamilies: [],
+    runtimeAgents: agents,
+    developerAgentAdapters: [],
+    channelAdapters: [],
+    artifacts,
+    identityNamespaces: [],
+    environments: [],
+    agentFrameworks: [],
+    modelProviders: [],
+    deployments: [],
+    relationships: graphEdges,
+    unknowns: [],
+    skeleton: {
+      version: SKELETON_VERSION,
+      commit: git(ctx.rootDir, ["rev-parse", "HEAD"]) ?? null,
+      dirty: Boolean(git(ctx.rootDir, ["status", "--porcelain"])),
+      contentHash: createHash("sha256").update(canonicalJson({ runtimeAgents: agents, artifacts, relationships, callSites, controlFlow })).digest("hex"),
+      generator: { tool: "moda-cli", version: generatorVersion, extractSchemaVersion: EXTRACT_SCHEMA_VERSION },
+      durationMs: Date.now() - start,
+      counts: {
+        agents: agents.length,
+        entrypoints: artifacts.filter((a) => a.type === "entrypoint").length,
+        callSites: callSites.length,
+        prompts: artifacts.filter((a) => a.type === "prompt").length,
+        tools: artifacts.filter((a) => a.type === "tool").length,
+        models: artifacts.filter((a) => a.type === "model_config").length,
+        skills: artifacts.filter((a) => a.type === "skill").length,
+        evals: artifacts.filter((a) => a.type === "eval").length,
+        edges: relationships.length,
+        controlFlow: controlFlow.length
+      },
+      callSites,
+      edges: edgeTable,
+      controlFlow,
+      controlFlowStatus,
+      coverage: { ...COVERAGE },
+      knownGaps: KNOWN_GAPS,
+      warnings: sorted(warnings)
+    }
+  };
+  mark("finalize");
+  return graph;
+}
+function toolLocations(node, ctx) {
+  const output = { schema: null, implementation: null };
+  const seen = new Set;
+  const walk = (node2) => {
+    if (seen.has(node2))
+      return;
+    seen.add(node2);
+    if (import_typescript2.default.isPropertyAssignment(node2) || import_typescript2.default.isMethodDeclaration(node2) || import_typescript2.default.isShorthandPropertyAssignment(node2)) {
+      const name = propertyNameText(node2.name);
+      const key = name && /^(?:inputSchema|input_schema|parameters|schema)$/.test(name) ? "schema" : name && /^(?:execute|handler|run)$/.test(name) ? "implementation" : undefined;
+      if (key && !output[key]) {
+        const value = import_typescript2.default.isPropertyAssignment(node2) ? unwrap(node2.initializer) : import_typescript2.default.isShorthandPropertyAssignment(node2) ? node2.name : node2;
+        const checker = ctx.checkerFor(relPath(ctx.rootDir, node2.getSourceFile().fileName));
+        const declaration = checker && (import_typescript2.default.isIdentifier(value) || import_typescript2.default.isPropertyAccessExpression(value)) ? valueDeclaration(resolvedSymbol(import_typescript2.default.isPropertyAccessExpression(value) ? value.name : value, checker)) : undefined;
+        const target = declaration && !declaration.getSourceFile().isDeclarationFile && !declaration.getSourceFile().fileName.includes("/node_modules/") ? declaration : node2;
+        const symbol = key === "implementation" && target !== node2 ? propertyNameText(target.name) : undefined;
+        output[key] = { ...location(target, ctx), ...symbol ? { symbol } : {} };
+      }
+    }
+    if (import_typescript2.default.isFunctionLike(node2))
+      return;
+    import_typescript2.default.forEachChild(node2, walk);
+  };
+  walk(node);
+  return output;
+}
+function importClosure(roots, ctx, importsByPath, expand) {
+  const paths = new Set, queue = [...roots];
+  const follow = (path) => {
+    if (expand.has(path))
+      return true;
+    const source = ctx.programFor(path)?.getSourceFile(resolve2(ctx.rootDir, path));
+    return Boolean(source && source.statements.length > 0 && source.statements.every((statement) => import_typescript2.default.isImportDeclaration(statement) || import_typescript2.default.isExportDeclaration(statement) && statement.moduleSpecifier));
+  };
+  for (let i = 0;i < queue.length; i++) {
+    const path = queue[i];
+    if (paths.has(path))
+      continue;
+    paths.add(path);
+    if (!follow(path))
+      continue;
+    const cached = importsByPath.get(path);
+    if (cached) {
+      queue.push(...cached);
+      continue;
+    }
+    const imports = [];
+    importsByPath.set(path, imports);
+    const source = ctx.programFor(path)?.getSourceFile(resolve2(ctx.rootDir, path)), checker = ctx.checkerFor(path);
+    if (!source || !checker)
+      continue;
+    visit(source, (node) => {
+      if (!import_typescript2.default.isStringLiteralLike(node) || !(import_typescript2.default.isImportDeclaration(node.parent) || import_typescript2.default.isExportDeclaration(node.parent)))
+        return;
+      const symbol = checker.getSymbolAtLocation(node);
+      for (const declaration of symbol?.declarations ?? []) {
+        const sf = declaration.getSourceFile(), relative = relPath(ctx.rootDir, sf.fileName);
+        if (!sf.isDeclarationFile && !relative.startsWith("../") && !relative.includes("node_modules/"))
+          imports.push(relative);
+      }
+    });
+    queue.push(...imports);
+  }
+  return paths;
+}
+function collectDeclaredHandoffs(ctx, agents, agentForScope, add) {
+  for (const file of ctx.sourceFiles()) {
+    const path = relPath(ctx.rootDir, file.fileName);
+    if (TEST_PATH.test(path))
+      continue;
+    const checker = ctx.checkerFor(path);
+    if (!checker)
+      continue;
+    const targets = (node, seen = new Set) => {
+      if (seen.has(node))
+        return [];
+      seen.add(node);
+      if (import_typescript2.default.isArrayLiteralExpression(node))
+        return node.elements.flatMap((element) => targets(element, seen));
+      if (import_typescript2.default.isCallExpression(node) || import_typescript2.default.isNewExpression(node))
+        return [...targets(node.expression, seen), ...(node.arguments ?? []).flatMap((arg) => targets(arg, seen))];
+      if (import_typescript2.default.isIdentifier(node) || import_typescript2.default.isPropertyAccessExpression(node)) {
+        const declaration = valueDeclaration(resolvedSymbol(import_typescript2.default.isPropertyAccessExpression(node) ? node.name : node, checker));
+        if (!declaration)
+          return [];
+        const ids = agents.filter((agent) => agent.sourcePath === relPath(ctx.rootDir, declaration.getSourceFile().fileName) && import_typescript2.default.isClassLike(declaration) && declaration.name?.text === agent.entry.symbol).map((agent) => agent.id);
+        if (ids.length)
+          return ids;
+        if (import_typescript2.default.isVariableDeclaration(declaration) && declaration.initializer)
+          return targets(unwrap(declaration.initializer), seen);
+      }
+      return [];
+    };
+    visit(file, (node) => {
+      const expr = import_typescript2.default.isPropertyAssignment(node) && propertyNameText(node.name) === "handoffs" ? node.initializer : import_typescript2.default.isPropertyDeclaration(node) && propertyNameText(node.name) === "handoffs" ? node.initializer : import_typescript2.default.isCallExpression(node) && /(?:^|\.)handoff$/.test(node.expression.getText()) ? node.arguments[0] : undefined;
+      if (!expr)
+        return;
+      const cls = enclosingClass(node);
+      const owners = agentForScope(scopeOf(ctx.rootDir, node));
+      if (!owners.length && cls?.name)
+        owners.push(...agentForScope(`${path}#${cls.name.text}`));
+      for (const from of owners)
+        for (const to of sorted(targets(expr)))
+          if (from !== to)
+            add({
+              type: "hands_off_to",
+              from,
+              to,
+              sourcePath: path,
+              line: lineOf(node),
+              via: import_typescript2.default.isCallExpression(node) ? node.expression.getText() : "handoffs",
+              evidence: [{ path, line: lineOf(node), reason: "skeleton framework handoff declaration" }]
+            });
+    });
+  }
+}
+function markdownCatalogs(ctx) {
+  const out = [];
+  for (const file of ctx.sourceFiles()) {
+    const path = relPath(ctx.rootDir, file.fileName);
+    if (TEST_PATH.test(path))
+      continue;
+    const imports = new Map;
+    for (const statement of file.statements) {
+      if (!import_typescript2.default.isImportDeclaration(statement) || !import_typescript2.default.isStringLiteral(statement.moduleSpecifier) || !statement.importClause?.name)
+        continue;
+      const spec = statement.moduleSpecifier.text;
+      if (!spec.startsWith(".") || !/\.(?:md|mdx|txt)(?:\?raw)?$/.test(spec))
+        continue;
+      imports.set(statement.importClause.name.text, relPath(ctx.rootDir, resolve2(dirname(file.fileName), spec.replace(/\?raw$/, ""))));
+    }
+    if (imports.size < 3)
+      continue;
+    const markdownOf = (node) => {
+      const value = node && unwrap(node);
+      return value && import_typescript2.default.isIdentifier(value) ? imports.get(value.text) : undefined;
+    };
+    visit(file, (node) => {
+      if (import_typescript2.default.isObjectLiteralExpression(node)) {
+        const entries = node.properties.flatMap((property) => {
+          const md = import_typescript2.default.isPropertyAssignment(property) ? markdownOf(property.initializer) : import_typescript2.default.isShorthandPropertyAssignment(property) ? imports.get(property.name.text) : undefined;
+          const name = propertyNameText(property.name);
+          return md && name ? [{ path: md, name, catalogPath: path, catalogLine: lineOf(property) }] : [];
+        });
+        if (entries.length >= 3)
+          out.push(...entries);
+      }
+      if (import_typescript2.default.isArrayLiteralExpression(node)) {
+        const entries = node.elements.flatMap((element) => {
+          const object = unwrap(element);
+          if (!import_typescript2.default.isObjectLiteralExpression(object))
+            return [];
+          let name;
+          let md;
+          for (const property of object.properties) {
+            if (!import_typescript2.default.isPropertyAssignment(property))
+              continue;
+            const key = propertyNameText(property.name), value = unwrap(property.initializer);
+            if (key && /^(?:name|id|key)$/.test(key) && import_typescript2.default.isStringLiteralLike(value))
+              name = value.text;
+            md ??= markdownOf(property.initializer);
+          }
+          return md && name ? [{ path: md, name, catalogPath: path, catalogLine: lineOf(object) }] : [];
+        });
+        if (entries.length >= 3)
+          out.push(...entries);
+      }
+    });
+  }
+  return out.sort((a, b) => a.path.localeCompare(b.path));
+}
+function collectTriggers(input) {
+  const { ctx, agents, artifacts, enumeration } = input;
+  const entry = (artifact, targets) => {
+    if (targets.length === 0)
+      return;
+    if (!artifacts.some((item) => item.id === artifact.id))
+      artifacts.push(artifact);
+    for (const agent of agents)
+      if (targets.includes(agent.id) && !agent.entrypointIds.includes(artifact.id))
+        agent.entrypointIds.push(artifact.id);
+  };
+  const base = (id, name, path, line, trigger, reason) => ({ id, type: "entrypoint", name, sourcePath: path, line, trigger, scope: "global", usedByAgentIds: [], confidence: 0.9, evidence: [{ path, line, reason }], status: input.status(path) });
+  for (const agent of agents)
+    if (agent.entry.kind === "route") {
+      const method = ROUTE_METHOD.exec(agent.name)?.[1] ?? "route";
+      entry(base(`route:${agent.sourcePath}#${method}`, `${method} ${agent.sourcePath}`, agent.sourcePath, agent.line, "http_route", "skeleton exported route handler"), [agent.id]);
+    }
+  const classes = new Map;
+  for (const source of ctx.sourceFiles())
+    visit(source, (node) => {
+      if (import_typescript2.default.isClassDeclaration(node) && node.name)
+        classes.set(node.name.text, [...classes.get(node.name.text) ?? [], node]);
+    });
+  const agentOfClass = (node) => agents.find((agent) => agent.entry.kind === "class" && agent.entry.symbol === node.name?.text && agent.sourcePath === relPath(ctx.rootDir, node.getSourceFile().fileName));
+  for (const bound of [...detectBoundRuntimeClasses(ctx.rootDir), ...tomlDurableObjects(ctx.rootDir)].filter((item) => item.kind === "durable_object" && !item.scriptName)) {
+    const found = classes.get(bound.className) ?? [];
+    if (found.length !== 1)
+      continue;
+    const cls = found[0], checker = ctx.checkerFor(relPath(ctx.rootDir, cls.getSourceFile().fileName));
+    const targets = new Set;
+    const own = agentOfClass(cls);
+    if (own)
+      targets.add(own.id);
+    else if (checker)
+      visit(cls, (node) => {
+        if (!import_typescript2.default.isNewExpression(node))
+          return;
+        const declaration = valueDeclaration(resolvedSymbol(node.expression, checker));
+        const constructed = declaration && import_typescript2.default.isClassDeclaration(declaration) ? agentOfClass(declaration) : undefined;
+        if (constructed)
+          targets.add(constructed.id);
+      });
+    entry(base(`binding:${bound.path}#${bound.binding}`, bound.binding, bound.path, bound.line ?? 1, "do_binding", `skeleton Durable Object binding of ${bound.className}`), [...targets]);
+  }
+  const scopes = new Map(enumeration.scopes.map((scope) => [scope.key, scope]));
+  const workflows = artifacts.filter((item) => item.type === "entrypoint" && (item.trigger === "workflow_binding" || item.trigger === "cron" || item.id.startsWith("workflow:")));
+  for (const workflow of workflows) {
+    const roots = enumeration.scopes.filter((scope) => scope.file.path === workflow.sourcePath && (scope.className === workflow.name || lineOf(scope.node) === workflow.line || scope.label === workflow.name));
+    const reached = new Set, queue = roots.map((scope) => ({ key: scope.key, depth: 0 }));
+    for (let i = 0;i < queue.length; i++) {
+      const { key, depth } = queue[i];
+      if (reached.has(key))
+        continue;
+      reached.add(key);
+      if (depth < 8)
+        for (const next of scopes.get(key)?.calls ?? [])
+          queue.push({ key: next, depth: depth + 1 });
+    }
+    const aliases = new Set([...reached].flatMap((key) => scopes.get(key)?.aliases ?? []));
+    const targets = new Set;
+    for (const agent of agents)
+      if (agent.entry.kind !== "class") {
+        const origin = agent.evidence[0];
+        if ([...reached].some((key) => {
+          const scope = scopes.get(key);
+          return scope.file.path === origin?.path && lineOf(scope.node) === origin.line;
+        }))
+          targets.add(agent.id);
+      }
+    for (const handoff of input.handoffs)
+      if (aliases.has(handoff.scope))
+        for (const target of handoff.targets) {
+          const child = agents.find((agent) => agent.sourcePath === target.path && agent.entry.symbol === target.name);
+          if (child)
+            targets.add(child.id);
+        }
+    entry(workflow, [...targets]);
+  }
+}
+function tomlDurableObjects(rootDir) {
+  const out = [];
+  for (const path of import_fast_glob.default.sync(["**/wrangler.toml", "**/wrangler.*.toml"], { cwd: rootDir, onlyFiles: true, followSymbolicLinks: false, ignore: ["**/node_modules/**", "**/.git/**", "**/dist/**", "**/build/**", "**/vendor/**", "**/.*/**"] }).sort()) {
+    let text, config;
+    try {
+      text = readFileSync(resolve2(rootDir, path), "utf8");
+      config = parse(text);
+    } catch {
+      continue;
+    }
+    if (isTestWorkerConfig({ path, name: config.name, mains: [config.main] }))
+      continue;
+    const sections = [config, ...Object.values(config.env ?? {})];
+    const lines = text.split(`
+`);
+    for (const section of sections) {
+      const bindings = section?.durable_objects?.bindings ?? [];
+      for (const binding of bindings) {
+        if (typeof binding.name !== "string" || typeof binding.class_name !== "string")
+          continue;
+        if (out.some((item) => item.path === path && item.binding === binding.name))
+          continue;
+        const line = lines.findIndex((entry) => entry.includes(binding.class_name)) + 1;
+        out.push({ className: binding.class_name, kind: "durable_object", binding: binding.name, ...typeof binding.script_name === "string" ? { scriptName: binding.script_name } : {}, path, ...line > 0 ? { line } : {} });
+      }
+    }
+  }
+  return out;
+}
+
+// src/harness-extract/skeleton/cli.ts
+function readSkeleton(path) {
+  let value;
+  try {
+    value = JSON.parse(readFileSync2(path, "utf8"));
+  } catch (error) {
+    throw new CliInputError(`Cannot read skeleton ${path}: ${error.message}`);
+  }
+  if (value && typeof value === "object" && "data" in value)
+    value = value.data;
+  const graph = value;
+  if (graph?.skeleton?.version !== SKELETON_VERSION || !Array.isArray(graph.runtimeAgents) || !Array.isArray(graph.artifacts) || !Array.isArray(graph.relationships) || !Array.isArray(graph.skeleton.callSites) || !Array.isArray(graph.skeleton.edges?.rows) || !Array.isArray(graph.skeleton.controlFlow) || typeof graph.skeleton.contentHash !== "string") {
+    throw new CliInputError(`Not a ${SKELETON_VERSION} skeleton: ${path}`);
+  }
+  return graph;
+}
+function runSkeletonCommand(context) {
+  if (context.positionals[0] === "skeleton-diff") {
+    const from = context.flags.from ?? context.positionals[1], to = context.flags.to ?? context.positionals[2];
+    if (!from || !to)
+      throw new CliInputError("Usage: moda harness skeleton-diff <before.json> <after.json> (or --from=<file> --to=<file>)");
+    context.output.writeData(diffHarnessSkeletons(readSkeleton(resolve3(context.cwd, from)), readSkeleton(resolve3(context.cwd, to))));
+    return { exitCode: 0 };
+  }
+  if (context.flags.out === "true")
+    throw new CliInputError("Missing output path for --out.", "Usage: moda harness skeleton --out=<file>");
+  const graph = buildHarnessSkeleton(resolve3(context.cwd, context.flags.path ?? "."), { fresh: true });
+  if (context.flags.out) {
+    const path = resolve3(context.cwd, context.flags.out);
+    mkdirSync(dirname2(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(graph, null, 2)}
+`, "utf8");
+  }
+  const warnings = graph.skeleton.warnings;
+  context.output.writeData(graph, { status: warnings.length ? "degraded" : "success", ...warnings.length ? { warnings } : {} });
+  return { exitCode: warnings.length ? EXIT_DEGRADED : 0 };
+}
+export {
+  runSkeletonCommand
+};