@saptools/service-flow 0.1.64 → 0.1.66

package/dist/{chunk-TBH33OYC.js → chunk-TOVX4WYH.js}

@@ -1,6 +1,85 @@
 #!/usr/bin/env node
 
-// src/db/repositories.ts
+// package.json
+var package_default = {
+  name: "@saptools/service-flow",
+  version: "0.1.66",
+  description: "Trace SAP CAP service-to-service flows across multi-repository workspaces with runtime-aware graph resolution",
+  type: "module",
+  publishConfig: {
+    access: "public",
+    registry: "https://registry.npmjs.org/"
+  },
+  bin: {
+    "service-flow": "dist/cli.js"
+  },
+  main: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js"
+    }
+  },
+  files: [
+    "CHANGELOG.md",
+    "README.md",
+    "TECHNICAL-NOTE.md",
+    "dist",
+    "src"
+  ],
+  engines: {
+    node: ">=24.0.0"
+  },
+  scripts: {
+    build: "tsup",
+    typecheck: "tsc --noEmit",
+    lint: "eslint src tests",
+    test: "vitest run tests/unit",
+    "test:unit": "vitest run tests/unit",
+    "test:e2e": "vitest run tests/e2e",
+    "test:e2e:fake": "vitest run tests/e2e"
+  },
+  keywords: [
+    "sap",
+    "cap",
+    "cds",
+    "btp",
+    "cli",
+    "service-graph",
+    "call-graph",
+    "sqlite",
+    "saptools"
+  ],
+  author: "Dong Tran",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/dongitran/saptools.git",
+    directory: "packages/service-flow"
+  },
+  homepage: "https://github.com/dongitran/saptools/tree/main/packages/service-flow#readme",
+  bugs: {
+    url: "https://github.com/dongitran/saptools/issues"
+  },
+  dependencies: {
+    commander: "13.1.0",
+    picocolors: "1.1.1",
+    typescript: "5.9.3",
+    zod: "4.4.3"
+  },
+  devDependencies: {
+    "@vitest/coverage-v8": "3.2.4",
+    tsup: "8.5.1",
+    vitest: "3.2.4"
+  }
+};
+
+// src/version.ts
+var VERSION = package_default.version;
+var ANALYZER_VERSION = "0.1.66-facts.1";
+
+// src/db/000-call-fact-repository.ts
 import { posix } from "path";
 
 // src/utils/000-bounded-projection.ts
@@ -126,6 +205,406 @@ function upperFirst(value) {
   return value ? `${value[0]?.toUpperCase() ?? ""}${value.slice(1)}` : value;
 }
 
+// src/db/000-call-fact-repository.ts
+function insertSymbolCalls(db, repoId, rows2) {
+  const callerStmt = db.prepare("SELECT id FROM symbols WHERE repo_id=? AND source_file=? AND qualified_name=? ORDER BY id LIMIT 1");
+  const insertStmt = db.prepare("INSERT INTO symbol_calls(repo_id,caller_symbol_id,callee_symbol_id,callee_expression,import_source,source_file,source_line,call_site_start_offset,call_site_end_offset,call_role,status,confidence,evidence_json,unresolved_reason) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?)");
+  for (const r of rows2) {
+    const caller = callerStmt.get(repoId, r.sourceFile, r.callerQualifiedName);
+    const target = resolveSymbolCallTarget(db, repoId, r);
+    insertStmt.run(
+      repoId,
+      caller?.id,
+      target.id,
+      r.calleeExpression,
+      r.importSource,
+      r.sourceFile,
+      r.sourceLine,
+      r.callSiteStartOffset,
+      r.callSiteEndOffset,
+      r.callRole,
+      target.status,
+      0.8,
+      JSON.stringify({
+        ...r.evidence,
+        candidateStrategy: target.strategy,
+        candidateCount: target.candidateCount,
+        resolvedModulePath: target.resolvedModulePath
+      }),
+      target.reason
+    );
+  }
+}
+var stripExt = (value) => value.replace(/\.(ts|tsx|js|jsx|cds)$/, "");
+function symbolTargetRows(rows2) {
+  return rows2.flatMap((row) => typeof row.id === "number" ? [{
+    id: row.id,
+    kind: typeof row.kind === "string" ? row.kind : void 0,
+    sourceFile: nullableString(row.sourceFile),
+    evidenceJson: nullableString(row.evidenceJson)
+  }] : []);
+}
+function relativeModuleTargets(callerSourceFile, importSource) {
+  const base = posix.dirname(callerSourceFile);
+  const joined = stripExt(posix.normalize(posix.join(base, importSource)));
+  return /* @__PURE__ */ new Set([joined, `${joined}/index`]);
+}
+function moduleRows(rows2, r) {
+  if (!r.importSource) return [];
+  const targets = relativeModuleTargets(r.sourceFile, r.importSource);
+  return rows2.filter((row) => typeof row.sourceFile === "string" && targets.has(stripExt(row.sourceFile)));
+}
+function resolvedSymbol(row, strategy, candidateCount, moduleScoped = false) {
+  return {
+    id: row.id,
+    status: "resolved",
+    reason: null,
+    strategy,
+    candidateCount,
+    resolvedModulePath: moduleScoped && row.sourceFile ? stripExt(row.sourceFile) : void 0
+  };
+}
+function exportedSymbolRows(db, repoId, r) {
+  return symbolTargetRows(db.prepare("SELECT id,kind,source_file sourceFile,evidence_json evidenceJson FROM symbols WHERE repo_id=? AND source_file<>? AND exported=1 AND (exported_name=? OR name=? OR qualified_name=?) ORDER BY id").all(repoId, r.sourceFile, r.calleeLocalName, r.calleeLocalName, r.calleeLocalName));
+}
+function isRelativeImportedSymbolCall(r) {
+  return Boolean(r.importSource?.startsWith("."));
+}
+function sameFileResolution(db, repoId, r, relation) {
+  const bareImport = relation === "relative_import" && isRelativeImportedSymbolCall(r) && !String(r.calleeLocalName).includes(".");
+  if (bareImport || relation === "relative_import_namespace_member" || relation === "package_import") return void 0;
+  const rows2 = symbolTargetRows(db.prepare("SELECT id FROM symbols WHERE repo_id=? AND source_file=? AND (name=? OR qualified_name=?) ORDER BY id").all(repoId, r.sourceFile, r.calleeLocalName, r.calleeLocalName));
+  if (rows2.length === 1 && rows2[0]) return resolvedSymbol(rows2[0], "same_file_exact", 1);
+  return rows2.length > 1 ? {
+    id: null,
+    status: "ambiguous",
+    reason: "Multiple same-file symbol targets matched exactly",
+    strategy: "same_file_exact",
+    candidateCount: rows2.length
+  } : void 0;
+}
+function classInstanceResolution(db, repoId, r, relation) {
+  if (relation !== "class_instance_method" || !isRelativeImportedSymbolCall(r))
+    return void 0;
+  const rows2 = symbolTargetRows(db.prepare("SELECT id FROM symbols WHERE repo_id=? AND source_file<>? AND qualified_name=? ORDER BY id").all(repoId, r.sourceFile, r.calleeLocalName));
+  if (rows2.length === 1 && rows2[0])
+    return resolvedSymbol(rows2[0], "relative_import_class_instance_method", 1);
+  return rows2.length > 1 ? {
+    id: null,
+    status: "ambiguous",
+    reason: "Multiple relative class instance method targets matched exactly",
+    strategy: "relative_import_class_instance_method",
+    candidateCount: rows2.length
+  } : void 0;
+}
+function namespaceResolution(db, repoId, r, relation) {
+  if (relation !== "relative_import_namespace_member" || !isRelativeImportedSymbolCall(r)) return void 0;
+  const rows2 = moduleRows(exportedSymbolRows(db, repoId, r), r);
+  if (rows2.length === 1 && rows2[0])
+    return resolvedSymbol(rows2[0], "relative_import_namespace_member", 1, true);
+  if (rows2.length > 1) return {
+    id: null,
+    status: "ambiguous",
+    reason: "Multiple namespace member targets matched the imported module",
+    strategy: "relative_import_namespace_member",
+    candidateCount: rows2.length
+  };
+  return {
+    id: null,
+    status: "unresolved",
+    reason: "No namespace member target matched the imported module",
+    strategy: "relative_import_namespace_member",
+    candidateCount: 0
+  };
+}
+function proxyResolution(rows2, r, relation) {
+  if (relation !== "relative_import_proxy_member" || rows2.length <= 1) return void 0;
+  const mapped = rows2.filter(isExportedObjectMapping);
+  if (mapped.length > 0) {
+    const concrete = rows2.find((row) => row.kind !== "object_alias") ?? mapped[0];
+    return {
+      id: concrete?.id ?? null,
+      status: "resolved",
+      reason: null,
+      strategy: "proxy_member_exported_object_map",
+      candidateCount: rows2.length
+    };
+  }
+  const scoped = moduleRows(rows2, r);
+  if (scoped.length === 1 && scoped[0])
+    return resolvedSymbol(scoped[0], "relative_import_path_disambiguated", rows2.length, true);
+  return {
+    id: null,
+    status: "ambiguous",
+    reason: "Proxy member target requires explicit factory/module/type evidence; global member name is ambiguous",
+    strategy: "proxy_member_no_global_name_fallback",
+    candidateCount: rows2.length
+  };
+}
+function isExportedObjectMapping(row) {
+  const evidence = String(row.evidenceJson ?? "");
+  return evidence.includes("exported_object_shorthand") || evidence.includes("exported_object_literal");
+}
+function exportedResolution(rows2, r, relation) {
+  if (rows2.length === 1 && rows2[0]) return resolvedSymbol(
+    rows2[0],
+    relation === "relative_import_proxy_member" ? "proxy_member_unique_exported_candidate" : "relative_import_exported_exact",
+    1,
+    moduleRows(rows2, r).length === 1
+  );
+  if (rows2.length <= 1) return void 0;
+  const scoped = isRelativeImportedSymbolCall(r) ? moduleRows(rows2, r) : [];
+  if (scoped.length === 1 && scoped[0])
+    return resolvedSymbol(scoped[0], "relative_import_path_disambiguated", rows2.length, true);
+  return {
+    id: null,
+    status: "ambiguous",
+    reason: "Multiple exported symbol targets matched exactly",
+    strategy: "exported_exact",
+    candidateCount: rows2.length
+  };
+}
+function accessorResolution(db, repoId, r, relation) {
+  if (relation !== "relative_import" || !isRelativeImportedSymbolCall(r) || !/^[^.]+\.[^.]+$/.test(String(r.calleeLocalName))) return void 0;
+  const methodRows = symbolTargetRows(db.prepare("SELECT id,kind,source_file sourceFile FROM symbols WHERE repo_id=? AND source_file<>? AND kind='method' AND qualified_name=? ORDER BY id").all(repoId, r.sourceFile, r.calleeLocalName));
+  const scoped = moduleRows(methodRows, r);
+  if (scoped.length === 1 && scoped[0]) return resolvedSymbol(
+    scoped[0],
+    "relative_import_static_accessor_instance_method",
+    1,
+    true
+  );
+  return scoped.length > 1 ? {
+    id: null,
+    status: "ambiguous",
+    reason: "Multiple static-accessor instance method targets matched the imported module",
+    strategy: "relative_import_static_accessor_instance_method",
+    candidateCount: scoped.length
+  } : void 0;
+}
+function resolveSymbolCallTarget(db, repoId, r) {
+  const relation = r.evidence.relation;
+  const early = sameFileResolution(db, repoId, r, relation) ?? classInstanceResolution(db, repoId, r, relation) ?? namespaceResolution(db, repoId, r, relation);
+  if (early) return early;
+  const rows2 = relation === "package_import" ? [] : exportedSymbolRows(db, repoId, r);
+  const matched = proxyResolution(rows2, r, relation) ?? exportedResolution(rows2, r, relation) ?? accessorResolution(db, repoId, r, relation);
+  if (matched) return matched;
+  if (relation === "package_import") return {
+    id: null,
+    status: "unresolved",
+    reason: "Package import target resolution requires a post-publication workspace pass",
+    strategy: "package_import_unresolved",
+    candidateCount: 0
+  };
+  return {
+    id: null,
+    status: "unresolved",
+    reason: "No local symbol target matched exactly",
+    strategy: relation === "relative_import_proxy_member" ? "proxy_member_no_global_name_fallback" : "exact_symbol_match",
+    candidateCount: 0
+  };
+}
+function insertCalls(db, repoId, rows2) {
+  const stmt = outboundCallInsertStatement(db);
+  for (const row of rows2) insertOutboundCall(db, stmt, repoId, row);
+}
+function outboundCallInsertStatement(db) {
+  return db.prepare(`INSERT INTO outbound_calls(
+    repo_id,source_symbol_id,call_type,method,operation_path_expr,query_entity,
+    event_name_expr,payload_summary,source_file,source_line,call_site_start_offset,
+    call_site_end_offset,confidence,unresolved_reason,local_service_name,
+    local_service_lookup,alias_chain_json,evidence_json,external_target_kind,
+    external_target_id,external_target_label,external_target_dynamic,service_binding_id
+  ) VALUES(
+    ?,COALESCE(
+      (SELECT id FROM symbols WHERE repo_id=? AND source_file=? AND qualified_name=? ORDER BY id LIMIT 1),
+      (SELECT id FROM symbols WHERE repo_id=? AND source_file=? AND start_line<=? AND end_line>=? ORDER BY (end_line-start_line),id LIMIT 1)
+    ),?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?
+  )`);
+}
+function insertOutboundCall(db, stmt, repoId, call) {
+  const binding = resolvePersistedBinding(db, repoId, call);
+  const external = externalTargetValues(call.externalTarget);
+  const evidence = {
+    ...call.evidence ?? {},
+    serviceBindingResolution: binding.evidence
+  };
+  stmt.run(
+    repoId,
+    repoId,
+    call.sourceFile,
+    call.sourceSymbolQualifiedName,
+    repoId,
+    call.sourceFile,
+    call.sourceLine,
+    call.sourceLine,
+    call.callType,
+    call.method,
+    call.operationPathExpr,
+    call.queryEntity,
+    call.eventNameExpr,
+    call.payloadSummary,
+    call.sourceFile,
+    call.sourceLine,
+    call.callSiteStartOffset,
+    call.callSiteEndOffset,
+    call.confidence,
+    call.unresolvedReason ?? binding.unresolvedReason,
+    call.localServiceName,
+    call.localServiceLookup,
+    serializedAliasChain(call.aliasChain),
+    JSON.stringify(evidence),
+    external.kind,
+    external.stableId,
+    external.label,
+    external.dynamic,
+    binding.bindingId
+  );
+}
+function serializedAliasChain(aliasChain) {
+  return aliasChain ? JSON.stringify(aliasChain) : null;
+}
+function externalTargetValues(target) {
+  if (!target) return { kind: null, stableId: null, label: null, dynamic: 0 };
+  return {
+    kind: target.kind,
+    stableId: target.stableId,
+    label: target.label,
+    dynamic: target.dynamic ? 1 : 0
+  };
+}
+function resolvePersistedBinding(db, repoId, call) {
+  if (!call.serviceVariableName)
+    return { bindingId: null, evidence: { status: "not_applicable", candidateCount: 0 } };
+  const candidates2 = bindingCandidates(db, repoId, call);
+  const prior = candidates2.filter((candidate) => candidate.sourceLine <= call.sourceLine);
+  const families = new Set(prior.map(bindingSignature));
+  if (prior.length > 0 && families.size === 1) {
+    const selected = prior.at(-1);
+    return {
+      bindingId: selected?.id ?? null,
+      evidence: bindingEvidence("selected", prior, selected)
+    };
+  }
+  if (prior.length > 1) {
+    return {
+      bindingId: null,
+      unresolvedReason: "ambiguous_service_binding_candidates",
+      evidence: bindingEvidence("ambiguous", prior)
+    };
+  }
+  if (candidates2.length > 0) {
+    return {
+      bindingId: null,
+      unresolvedReason: "service_binding_declared_after_call",
+      evidence: bindingEvidence("rejected_future_binding", candidates2)
+    };
+  }
+  return {
+    bindingId: null,
+    evidence: bindingEvidence("unrecoverable", [])
+  };
+}
+function bindingCandidates(db, repoId, call) {
+  const ownerId = callSymbolId(db, repoId, call);
+  const rows2 = db.prepare(`
+    SELECT id,symbol_id symbolId,variable_name variableName,alias,alias_expr aliasExpr,
+      destination_expr destinationExpr,service_path_expr servicePathExpr,
+      source_file sourceFile,source_line sourceLine,helper_chain_json helperChainJson
+    FROM service_bindings
+    WHERE repo_id=? AND variable_name=? AND source_file=?
+      AND (? IS NULL OR symbol_id IS NULL OR symbol_id=?)
+    ORDER BY source_line,id
+  `).all(
+    repoId,
+    call.serviceVariableName,
+    call.sourceFile,
+    ownerId,
+    ownerId
+  );
+  return rows2.flatMap((row) => {
+    if (typeof row.id !== "number" || typeof row.variableName !== "string" || typeof row.sourceFile !== "string" || typeof row.sourceLine !== "number")
+      return [];
+    return [{
+      id: row.id,
+      symbolId: nullableNumber(row.symbolId),
+      variableName: row.variableName,
+      alias: nullableString(row.alias),
+      aliasExpr: nullableString(row.aliasExpr),
+      destinationExpr: nullableString(row.destinationExpr),
+      servicePathExpr: nullableString(row.servicePathExpr),
+      sourceFile: row.sourceFile,
+      sourceLine: row.sourceLine,
+      helperChainJson: nullableString(row.helperChainJson)
+    }];
+  });
+}
+function nullableString(value) {
+  return value === null || typeof value === "string" ? value : void 0;
+}
+function nullableNumber(value) {
+  return value === null || typeof value === "number" ? value : void 0;
+}
+function callSymbolId(db, repoId, call) {
+  const row = db.prepare(`
+    SELECT id FROM symbols
+    WHERE repo_id=? AND source_file=?
+      AND ((? IS NOT NULL AND qualified_name=?)
+        OR (start_line<=? AND end_line>=?))
+    ORDER BY CASE WHEN qualified_name=? THEN 0 ELSE 1 END,
+      (end_line-start_line),id
+    LIMIT 1
+  `).get(
+    repoId,
+    call.sourceFile,
+    call.sourceSymbolQualifiedName,
+    call.sourceSymbolQualifiedName,
+    call.sourceLine,
+    call.sourceLine,
+    call.sourceSymbolQualifiedName
+  );
+  return typeof row?.id === "number" ? row.id : void 0;
+}
+function bindingEvidence(status, candidates2, selected) {
+  const projection = projectBounded(candidates2, (left, right) => Number(right.id === selected?.id) - Number(left.id === selected?.id) || left.sourceFile.localeCompare(right.sourceFile) || left.sourceLine - right.sourceLine || left.id - right.id);
+  return {
+    status,
+    candidateCount: projection.totalCount,
+    shownCandidateCount: projection.shownCount,
+    omittedCandidateCount: projection.omittedCount,
+    selectedBindingId: selected?.id,
+    sourceOrderRule: "binding_source_line_must_not_follow_call",
+    candidates: projection.items.map((candidate) => ({
+      bindingId: candidate.id,
+      symbolId: candidate.symbolId,
+      variableName: candidate.variableName,
+      alias: candidate.alias,
+      aliasExpr: candidate.aliasExpr,
+      destinationExpr: candidate.destinationExpr,
+      servicePathExpr: candidate.servicePathExpr,
+      sourceFile: candidate.sourceFile,
+      sourceLine: candidate.sourceLine,
+      helperChain: parseBindingChain(candidate.helperChainJson)
+    }))
+  };
+}
+function bindingSignature(candidate) {
+  return JSON.stringify([
+    candidate.alias,
+    candidate.aliasExpr,
+    candidate.destinationExpr,
+    candidate.servicePathExpr
+  ]);
+}
+function parseBindingChain(value) {
+  if (!value) return void 0;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+}
+
 // src/db/repositories.ts
 function upsertWorkspace(db, rootPath, dbPath) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -384,265 +863,6 @@ function insertExecutableSymbols(db, repoId, rows2) {
   const stmt = db.prepare("INSERT INTO symbols(repo_id,file_id,kind,name,qualified_name,exported,start_line,end_line,start_offset,end_offset,source_file,exported_name,evidence_json) VALUES(?,(SELECT id FROM files WHERE repo_id=? AND relative_path=?),?,?,?,?,?,?,?,?,?,?,?)");
   for (const r of rows2) stmt.run(repoId, repoId, r.sourceFile, r.kind, r.localName, r.qualifiedName, r.exported ? 1 : 0, r.startLine, r.endLine, r.startOffset, r.endOffset, r.sourceFile, r.exportedName, r.importExportEvidence ? JSON.stringify(r.importExportEvidence) : null);
 }
-function insertSymbolCalls(db, repoId, rows2) {
-  const callerStmt = db.prepare("SELECT id FROM symbols WHERE repo_id=? AND source_file=? AND qualified_name=? ORDER BY id LIMIT 1");
-  const insertStmt = db.prepare("INSERT INTO symbol_calls(repo_id,caller_symbol_id,callee_symbol_id,callee_expression,import_source,source_file,source_line,status,confidence,evidence_json,unresolved_reason) VALUES(?,?,?,?,?,?,?,?,?,?,?)");
-  for (const r of rows2) {
-    const caller = callerStmt.get(repoId, r.sourceFile, r.callerQualifiedName);
-    const target = resolveSymbolCallTarget(db, repoId, r);
-    insertStmt.run(repoId, caller?.id, target.id, r.calleeExpression, r.importSource, r.sourceFile, r.sourceLine, target.status, 0.8, JSON.stringify({ ...r.evidence, candidateStrategy: target.strategy, candidateCount: target.candidateCount, resolvedModulePath: target.resolvedModulePath }), target.reason);
-  }
-}
-var stripExt = (value) => value.replace(/\.(ts|tsx|js|jsx|cds)$/, "");
-function symbolTargetRows(rows2) {
-  return rows2.flatMap((row) => typeof row.id === "number" ? [{ id: row.id, kind: typeof row.kind === "string" ? row.kind : void 0, sourceFile: nullableString(row.sourceFile), evidenceJson: nullableString(row.evidenceJson) }] : []);
-}
-function relativeModuleTargets(callerSourceFile, importSource) {
-  const base = posix.dirname(callerSourceFile);
-  const joined = stripExt(posix.normalize(posix.join(base, importSource)));
-  return /* @__PURE__ */ new Set([joined, `${joined}/index`]);
-}
-function moduleRows(rows2, r) {
-  if (!r.importSource) return [];
-  const targets = relativeModuleTargets(r.sourceFile, r.importSource);
-  return rows2.filter((row) => typeof row.sourceFile === "string" && targets.has(stripExt(row.sourceFile)));
-}
-function resolvedSymbol(row, strategy, candidateCount, moduleScoped = false) {
-  return { id: row.id, status: "resolved", reason: null, strategy, candidateCount, resolvedModulePath: moduleScoped && row.sourceFile ? stripExt(row.sourceFile) : void 0 };
-}
-function exportedSymbolRows(db, repoId, r) {
-  return symbolTargetRows(db.prepare("SELECT id,kind,source_file sourceFile,evidence_json evidenceJson FROM symbols WHERE repo_id=? AND source_file<>? AND exported=1 AND (exported_name=? OR name=? OR qualified_name=?) ORDER BY id").all(repoId, r.sourceFile, r.calleeLocalName, r.calleeLocalName, r.calleeLocalName));
-}
-function isRelativeImportedSymbolCall(r) {
-  return Boolean(r.importSource?.startsWith("."));
-}
-function sameFileResolution(db, repoId, r, relation) {
-  const bareImport = relation === "relative_import" && isRelativeImportedSymbolCall(r) && !String(r.calleeLocalName).includes(".");
-  if (bareImport || relation === "relative_import_namespace_member" || relation === "package_import") return void 0;
-  const rows2 = symbolTargetRows(db.prepare("SELECT id FROM symbols WHERE repo_id=? AND source_file=? AND (name=? OR qualified_name=?) ORDER BY id").all(repoId, r.sourceFile, r.calleeLocalName, r.calleeLocalName));
-  if (rows2.length === 1 && rows2[0]) return resolvedSymbol(rows2[0], "same_file_exact", 1);
-  return rows2.length > 1 ? { id: null, status: "ambiguous", reason: "Multiple same-file symbol targets matched exactly", strategy: "same_file_exact", candidateCount: rows2.length } : void 0;
-}
-function classInstanceResolution(db, repoId, r, relation) {
-  if (relation !== "class_instance_method" || !isRelativeImportedSymbolCall(r)) return void 0;
-  const rows2 = symbolTargetRows(db.prepare("SELECT id FROM symbols WHERE repo_id=? AND source_file<>? AND qualified_name=? ORDER BY id").all(repoId, r.sourceFile, r.calleeLocalName));
-  if (rows2.length === 1 && rows2[0]) return resolvedSymbol(rows2[0], "relative_import_class_instance_method", 1);
-  return rows2.length > 1 ? { id: null, status: "ambiguous", reason: "Multiple relative class instance method targets matched exactly", strategy: "relative_import_class_instance_method", candidateCount: rows2.length } : void 0;
-}
-function namespaceResolution(db, repoId, r, relation) {
-  if (relation !== "relative_import_namespace_member" || !isRelativeImportedSymbolCall(r)) return void 0;
-  const rows2 = moduleRows(exportedSymbolRows(db, repoId, r), r);
-  if (rows2.length === 1 && rows2[0]) return resolvedSymbol(rows2[0], "relative_import_namespace_member", 1, true);
-  if (rows2.length > 1) return { id: null, status: "ambiguous", reason: "Multiple namespace member targets matched the imported module", strategy: "relative_import_namespace_member", candidateCount: rows2.length };
-  return { id: null, status: "unresolved", reason: "No namespace member target matched the imported module", strategy: "relative_import_namespace_member", candidateCount: 0 };
-}
-function proxyResolution(rows2, r, relation) {
-  if (relation !== "relative_import_proxy_member" || rows2.length <= 1) return void 0;
-  const mapped = rows2.filter((row) => String(row.evidenceJson ?? "").includes("exported_object_shorthand") || String(row.evidenceJson ?? "").includes("exported_object_literal"));
-  if (mapped.length > 0) {
-    const concrete = rows2.find((row) => row.kind !== "object_alias") ?? mapped[0];
-    return { id: concrete?.id ?? null, status: "resolved", reason: null, strategy: "proxy_member_exported_object_map", candidateCount: rows2.length };
-  }
-  const scoped = moduleRows(rows2, r);
-  if (scoped.length === 1 && scoped[0]) return resolvedSymbol(scoped[0], "relative_import_path_disambiguated", rows2.length, true);
-  return { id: null, status: "ambiguous", reason: "Proxy member target requires explicit factory/module/type evidence; global member name is ambiguous", strategy: "proxy_member_no_global_name_fallback", candidateCount: rows2.length };
-}
-function exportedResolution(rows2, r, relation) {
-  if (rows2.length === 1 && rows2[0]) return resolvedSymbol(rows2[0], relation === "relative_import_proxy_member" ? "proxy_member_unique_exported_candidate" : "relative_import_exported_exact", 1, moduleRows(rows2, r).length === 1);
-  if (rows2.length <= 1) return void 0;
-  const scoped = isRelativeImportedSymbolCall(r) ? moduleRows(rows2, r) : [];
-  if (scoped.length === 1 && scoped[0]) return resolvedSymbol(scoped[0], "relative_import_path_disambiguated", rows2.length, true);
-  return { id: null, status: "ambiguous", reason: "Multiple exported symbol targets matched exactly", strategy: "exported_exact", candidateCount: rows2.length };
-}
-function accessorResolution(db, repoId, r, relation) {
-  if (relation !== "relative_import" || !isRelativeImportedSymbolCall(r) || !/^[^.]+\.[^.]+$/.test(String(r.calleeLocalName))) return void 0;
-  const methodRows = symbolTargetRows(db.prepare("SELECT id,kind,source_file sourceFile FROM symbols WHERE repo_id=? AND source_file<>? AND kind='method' AND qualified_name=? ORDER BY id").all(repoId, r.sourceFile, r.calleeLocalName));
-  const scoped = moduleRows(methodRows, r);
-  if (scoped.length === 1 && scoped[0]) return resolvedSymbol(scoped[0], "relative_import_static_accessor_instance_method", 1, true);
-  return scoped.length > 1 ? { id: null, status: "ambiguous", reason: "Multiple static-accessor instance method targets matched the imported module", strategy: "relative_import_static_accessor_instance_method", candidateCount: scoped.length } : void 0;
-}
-function resolveSymbolCallTarget(db, repoId, r) {
-  const relation = r.evidence.relation;
-  const early = sameFileResolution(db, repoId, r, relation) ?? classInstanceResolution(db, repoId, r, relation) ?? namespaceResolution(db, repoId, r, relation);
-  if (early) return early;
-  const rows2 = relation === "package_import" ? [] : exportedSymbolRows(db, repoId, r);
-  const matched = proxyResolution(rows2, r, relation) ?? exportedResolution(rows2, r, relation) ?? accessorResolution(db, repoId, r, relation);
-  if (matched) return matched;
-  if (relation === "package_import") return { id: null, status: "unresolved", reason: "Package import target resolution requires a post-publication workspace pass", strategy: "package_import_unresolved", candidateCount: 0 };
-  return { id: null, status: "unresolved", reason: "No local symbol target matched exactly", strategy: relation === "relative_import_proxy_member" ? "proxy_member_no_global_name_fallback" : "exact_symbol_match", candidateCount: 0 };
-}
-function insertCalls(db, repoId, rows2) {
-  const stmt = db.prepare(
-    "INSERT INTO outbound_calls(repo_id,source_symbol_id,call_type,method,operation_path_expr,query_entity,event_name_expr,payload_summary,source_file,source_line,confidence,unresolved_reason,local_service_name,local_service_lookup,alias_chain_json,evidence_json,external_target_kind,external_target_id,external_target_label,external_target_dynamic,service_binding_id) VALUES(?,COALESCE((SELECT id FROM symbols WHERE repo_id=? AND source_file=? AND qualified_name=? ORDER BY id LIMIT 1),(SELECT id FROM symbols WHERE repo_id=? AND source_file=? AND start_line<=? AND end_line>=? ORDER BY (end_line-start_line),id LIMIT 1)),?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)"
-  );
-  for (const r of rows2) {
-    const binding = resolvePersistedBinding(db, repoId, r);
-    const evidence = {
-      ...r.evidence ?? {},
-      serviceBindingResolution: binding.evidence
-    };
-    stmt.run(
-      repoId,
-      repoId,
-      r.sourceFile,
-      r.sourceSymbolQualifiedName,
-      repoId,
-      r.sourceFile,
-      r.sourceLine,
-      r.sourceLine,
-      r.callType,
-      r.method,
-      r.operationPathExpr,
-      r.queryEntity,
-      r.eventNameExpr,
-      r.payloadSummary,
-      r.sourceFile,
-      r.sourceLine,
-      r.confidence,
-      r.unresolvedReason ?? binding.unresolvedReason,
-      r.localServiceName,
-      r.localServiceLookup,
-      r.aliasChain ? JSON.stringify(r.aliasChain) : null,
-      JSON.stringify(evidence),
-      r.externalTarget?.kind ?? null,
-      r.externalTarget?.stableId ?? null,
-      r.externalTarget?.label ?? null,
-      r.externalTarget?.dynamic ? 1 : 0,
-      binding.bindingId
-    );
-  }
-}
-function resolvePersistedBinding(db, repoId, call) {
-  if (!call.serviceVariableName)
-    return { bindingId: null, evidence: { status: "not_applicable", candidateCount: 0 } };
-  const candidates2 = bindingCandidates(db, repoId, call);
-  const prior = candidates2.filter((candidate) => candidate.sourceLine <= call.sourceLine);
-  const families = new Set(prior.map(bindingSignature));
-  if (prior.length > 0 && families.size === 1) {
-    const selected = prior.at(-1);
-    return {
-      bindingId: selected?.id ?? null,
-      evidence: bindingEvidence("selected", prior, selected)
-    };
-  }
-  if (prior.length > 1) {
-    return {
-      bindingId: null,
-      unresolvedReason: "ambiguous_service_binding_candidates",
-      evidence: bindingEvidence("ambiguous", prior)
-    };
-  }
-  if (candidates2.length > 0) {
-    return {
-      bindingId: null,
-      unresolvedReason: "service_binding_declared_after_call",
-      evidence: bindingEvidence("rejected_future_binding", candidates2)
-    };
-  }
-  return {
-    bindingId: null,
-    evidence: bindingEvidence("unrecoverable", [])
-  };
-}
-function bindingCandidates(db, repoId, call) {
-  const ownerId = callSymbolId(db, repoId, call);
-  const rows2 = db.prepare(`
-    SELECT id,symbol_id symbolId,variable_name variableName,alias,alias_expr aliasExpr,
-      destination_expr destinationExpr,service_path_expr servicePathExpr,
-      source_file sourceFile,source_line sourceLine,helper_chain_json helperChainJson
-    FROM service_bindings
-    WHERE repo_id=? AND variable_name=? AND source_file=?
-      AND (? IS NULL OR symbol_id IS NULL OR symbol_id=?)
-    ORDER BY source_line,id
-  `).all(
-    repoId,
-    call.serviceVariableName,
-    call.sourceFile,
-    ownerId,
-    ownerId
-  );
-  return rows2.flatMap((row) => {
-    if (typeof row.id !== "number" || typeof row.variableName !== "string" || typeof row.sourceFile !== "string" || typeof row.sourceLine !== "number")
-      return [];
-    return [{
-      id: row.id,
-      symbolId: nullableNumber(row.symbolId),
-      variableName: row.variableName,
-      alias: nullableString(row.alias),
-      aliasExpr: nullableString(row.aliasExpr),
-      destinationExpr: nullableString(row.destinationExpr),
-      servicePathExpr: nullableString(row.servicePathExpr),
-      sourceFile: row.sourceFile,
-      sourceLine: row.sourceLine,
-      helperChainJson: nullableString(row.helperChainJson)
-    }];
-  });
-}
-function nullableString(value) {
-  return value === null || typeof value === "string" ? value : void 0;
-}
-function nullableNumber(value) {
-  return value === null || typeof value === "number" ? value : void 0;
-}
-function callSymbolId(db, repoId, call) {
-  const row = db.prepare(`
-    SELECT id FROM symbols
-    WHERE repo_id=? AND source_file=?
-      AND ((? IS NOT NULL AND qualified_name=?)
-        OR (start_line<=? AND end_line>=?))
-    ORDER BY CASE WHEN qualified_name=? THEN 0 ELSE 1 END,
-      (end_line-start_line),id
-    LIMIT 1
-  `).get(
-    repoId,
-    call.sourceFile,
-    call.sourceSymbolQualifiedName,
-    call.sourceSymbolQualifiedName,
-    call.sourceLine,
-    call.sourceLine,
-    call.sourceSymbolQualifiedName
-  );
-  return typeof row?.id === "number" ? row.id : void 0;
-}
-function bindingEvidence(status, candidates2, selected) {
-  const projection = projectBounded(candidates2, (left, right) => Number(right.id === selected?.id) - Number(left.id === selected?.id) || left.sourceFile.localeCompare(right.sourceFile) || left.sourceLine - right.sourceLine || left.id - right.id);
-  return {
-    status,
-    candidateCount: projection.totalCount,
-    shownCandidateCount: projection.shownCount,
-    omittedCandidateCount: projection.omittedCount,
-    selectedBindingId: selected?.id,
-    sourceOrderRule: "binding_source_line_must_not_follow_call",
-    candidates: projection.items.map((candidate) => ({
-      bindingId: candidate.id,
-      symbolId: candidate.symbolId,
-      variableName: candidate.variableName,
-      alias: candidate.alias,
-      aliasExpr: candidate.aliasExpr,
-      destinationExpr: candidate.destinationExpr,
-      servicePathExpr: candidate.servicePathExpr,
-      sourceFile: candidate.sourceFile,
-      sourceLine: candidate.sourceLine,
-      helperChain: parseBindingChain(candidate.helperChainJson)
-    }))
-  };
-}
-function bindingSignature(candidate) {
-  return JSON.stringify([
-    candidate.alias,
-    candidate.aliasExpr,
-    candidate.destinationExpr,
-    candidate.servicePathExpr
-  ]);
-}
-function parseBindingChain(value) {
-  if (!value) return void 0;
-  try {
-    return JSON.parse(value);
-  } catch {
-    return void 0;
-  }
-}
 
 // src/discovery/discover-repositories.ts
 import fs from "fs/promises";
@@ -3059,10 +3279,14 @@ function wrapperCallFact(source, filePath, call, spec, serviceBindings) {
     payloadSummary: call.getText(source),
     sourceFile: normalizePath(filePath),
     sourceLine: lineOf3(source, call),
+    callSiteStartOffset: call.getStart(source),
+    callSiteEndOffset: call.getEnd(),
     confidence: operationPathExpr ? 0.85 : 0.5,
     unresolvedReason,
     evidence: {
       parser: "typescript_ast",
+      startOffset: call.getStart(source),
+      endOffset: call.getEnd(),
       classifier: importedWrapperClassifier(pathAnalysis.status),
       receiver: client.text,
       wrapperFunction: spec.chain[0],
@@ -4012,7 +4236,15 @@ function classifyOutboundCallsInSource(source, filePath) {
   const wrapperSpecs = collectWrapperSpecs(source);
   const wrapperInternalRanges = [...wrapperSpecs.values()].map((spec) => ({ start: spec.internalStart, end: spec.internalEnd }));
   const add = (node, fact, extra) => {
-    calls.push({ node, fact: { ...fact, sourceFile, sourceLine: lineOf4(source.text, node.getStart(source)), confidence: fact.confidence ?? 0.8, evidence: parserEvidence(source, node, extra) } });
+    calls.push({ node, fact: {
+      ...fact,
+      sourceFile,
+      sourceLine: lineOf4(source.text, node.getStart(source)),
+      callSiteStartOffset: node.getStart(source),
+      callSiteEndOffset: node.getEnd(),
+      confidence: fact.confidence ?? 0.8,
+      evidence: parserEvidence(source, node, extra)
+    } });
   };
   const visit = (node) => {
     if (ts10.isCallExpression(node)) {
@@ -4167,6 +4399,8 @@ function parseLocalServiceCalls(text, filePath, source = ts10.createSourceFile(
         aliasChain: parsed.chain,
         sourceFile: normalizePath(filePath),
         sourceLine: lineOf4(text, node.getStart(source)),
+        callSiteStartOffset: node.getStart(source),
+        callSiteEndOffset: node.getEnd(),
         confidence: 0.9,
         unresolvedReason: ["send", "emit", "publish", "on"].includes(parsed.operation) ? "transport_client_method" : void 0,
         evidence: parserEvidence(source, node, {
@@ -5757,51 +5991,516 @@ function linkPackageImportSymbolCalls(db, workspaceId) {
   return summary;
 }
 
-// src/linker/cross-repo-linker.ts
-function linkWorkspace(db, workspaceId, vars = {}) {
-  return db.transaction(() => {
-    const generation = nextGraphGeneration(db, workspaceId);
-    db.prepare("DELETE FROM graph_edges WHERE workspace_id=?").run(workspaceId);
-    const deps = linkHelperPackages(db, workspaceId, generation);
-    linkPackageImportSymbolCalls(db, workspaceId);
-    const impl = linkImplementations(db, workspaceId, generation);
-    const callSummary = linkCalls(db, workspaceId, vars, generation);
-    db.prepare("UPDATE repositories SET graph_generation=?, graph_stale_reason=NULL, graph_stale_at=NULL WHERE workspace_id=?").run(generation, workspaceId);
-    return { ...callSummary, edgeCount: deps.edgeCount + callSummary.edgeCount + impl.edgeCount, dependencyResolvedCount: deps.resolvedCount, dependencyAmbiguousCount: deps.ambiguousCount, implementationResolvedCount: impl.resolvedCount, implementationAmbiguousCount: impl.ambiguousCount, implementationUnresolvedCount: impl.unresolvedCount };
-  });
+// src/linker/004-event-subscription-handler-linker.ts
+var symbolCallReasonLimit = 512;
+function subscriptionRows(db, workspaceId) {
+  return db.prepare(`SELECT c.id,r.workspace_id workspaceId,c.repo_id repoId,r.name repoName,
+    c.source_symbol_id sourceSymbolId,c.event_name_expr eventName,
+    c.source_file sourceFile,c.source_line sourceLine,
+    c.call_site_start_offset startOffset,c.call_site_end_offset endOffset,
+    c.confidence
+    FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id
+    WHERE r.workspace_id=? AND c.call_type='async_subscribe'
+    ORDER BY r.name COLLATE BINARY,r.id,c.source_file COLLATE BINARY,
+      c.call_site_start_offset,c.call_site_end_offset,c.id`).all(
+    workspaceId
+  );
 }
-function nextGraphGeneration(db, workspaceId) {
-  const row = db.prepare("SELECT COALESCE(MAX(graph_generation),0) generation FROM repositories WHERE workspace_id=?").get(workspaceId);
-  return Number(row?.generation ?? 0) + 1;
+function roleSiteRows(db, subscription) {
+  if (typeof subscription.startOffset !== "number" || typeof subscription.endOffset !== "number") return [];
+  return db.prepare(`SELECT sc.id,sc.caller_symbol_id callerSymbolId,
+    sc.callee_symbol_id calleeSymbolId,sc.status,
+    sc.unresolved_reason unresolvedReason,sc.confidence,sc.source_line sourceLine,
+    json_extract(sc.evidence_json,'$.factOrigin') factOrigin,
+    json_extract(sc.evidence_json,'$.wrapperFunction') wrapperFunction,
+    json_extract(sc.evidence_json,'$.candidateStrategy') strategy,
+    json_extract(sc.evidence_json,'$.candidateCount') candidateCount,
+    target.source_file targetSourceFile,target.start_line targetSourceLine,
+    target_repo.workspace_id targetWorkspaceId
+    FROM symbol_calls sc LEFT JOIN symbols target ON target.id=sc.callee_symbol_id
+    LEFT JOIN repositories target_repo ON target_repo.id=target.repo_id
+    WHERE sc.repo_id=? AND sc.source_file=?
+      AND sc.call_site_start_offset=? AND sc.call_site_end_offset=?
+      AND sc.call_role='event_subscribe_handler'
+    ORDER BY sc.id`).all(
+    subscription.repoId,
+    subscription.sourceFile,
+    subscription.startOffset,
+    subscription.endOffset
+  );
 }
-function linkCalls(db, workspaceId, vars, generation) {
-  let edgeCount = 0;
-  let unresolvedCount = 0;
-  let resolvedCount = 0;
-  let remoteResolvedCount = 0;
-  let localResolvedCount = 0;
-  let ambiguousCount = 0;
-  let dynamicCount = 0;
-  let terminalCount = 0;
-  const calls = db.prepare(`SELECT c.*,r.name repoName,b.id selectedBindingId,b.alias,b.alias_expr aliasExpr,b.destination_expr destinationExpr,b.service_path_expr servicePathExpr,b.is_dynamic isDynamic,b.placeholders_json placeholdersJson,b.source_file bindingSourceFile,b.source_line bindingSourceLine,b.helper_chain_json helperChainJson,req.service_path requireServicePath,req.destination requireDestination FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id LEFT JOIN service_bindings b ON b.id=c.service_binding_id LEFT JOIN cds_requires req ON req.repo_id=c.repo_id AND req.alias=b.alias WHERE r.workspace_id=?`).all(workspaceId);
-  for (const call of calls) {
-    const result = insertCallEdge(db, workspaceId, call, vars, generation);
-    edgeCount += 1;
-    resolvedCount += result.status === "resolved" ? 1 : 0;
-    remoteResolvedCount += result.status === "resolved" && result.callType !== "local_service_call" ? 1 : 0;
-    localResolvedCount += result.status === "resolved" && result.callType === "local_service_call" ? 1 : 0;
-    unresolvedCount += result.status === "unresolved" ? 1 : 0;
-    ambiguousCount += result.status === "ambiguous" ? 1 : 0;
-    dynamicCount += result.status === "dynamic" ? 1 : 0;
-    terminalCount += result.status === "terminal" ? 1 : 0;
-  }
-  return { edgeCount, unresolvedCount, resolvedCount, remoteResolvedCount, localResolvedCount, ambiguousCount, dynamicCount, terminalCount };
+function invalidSpan(subscription) {
+  return typeof subscription.startOffset !== "number" || typeof subscription.endOffset !== "number" || subscription.startOffset < 0 || subscription.endOffset <= subscription.startOffset;
 }
-function insertCallEdge(db, workspaceId, call, vars, generation) {
-  const callType = String(call.call_type);
-  const rawOp = applyVariables(String(call.operation_path_expr ?? ""), vars);
-  const intent = classifyODataPathIntent(rawOp, call.method);
-  const isEntityQueryIntent = ["entity_query", "entity_key_read", "entity_navigation_query"].includes(intent.kind);
+function associationFor(subscription, matches2) {
+  if (invalidSpan(subscription)) return missingAssociation(
+    subscription.id,
+    matches2.length,
+    "subscription_call_span_missing"
+  );
+  if (matches2.length === 0) return missingAssociation(
+    subscription.id,
+    0,
+    "subscription_handler_role_site_missing"
+  );
+  if (matches2.length > 1) return ambiguousRoleSiteAssociation(
+    subscription.id,
+    matches2
+  );
+  const call = matches2[0];
+  return call ? singleCallAssociation(subscription, call) : missingAssociation(
+    subscription.id,
+    0,
+    "subscription_handler_role_site_missing"
+  );
+}
+function ambiguousRoleSiteAssociation(subscriptionId, matches2) {
+  return {
+    status: "ambiguous",
+    toKind: "subscription_handler",
+    toId: String(subscriptionId),
+    reasonCode: "multiple_handler_role_site_matches",
+    matchCount: matches2.length,
+    missing: false,
+    factOrigin: agreedOrMixed(matches2.map((match) => match.factOrigin)),
+    symbolCallResolutionStatus: agreedOrMixed(
+      matches2.map((match) => match.status)
+    )
+  };
+}
+function singleCallAssociation(subscription, call) {
+  const mismatch2 = associationMismatch(subscription, call);
+  if (mismatch2) return missingAssociation(subscription.id, 1, mismatch2, call);
+  return handlerReferenceAssociation(call);
+}
+function associationMismatch(subscription, call) {
+  if (subscription.sourceSymbolId != null && call.callerSymbolId !== subscription.sourceSymbolId)
+    return "subscription_handler_caller_mismatch";
+  if (call.sourceLine !== subscription.sourceLine)
+    return "subscription_handler_source_line_mismatch";
+  if (call.targetWorkspaceId != null && call.targetWorkspaceId !== subscription.workspaceId)
+    return "subscription_handler_target_workspace_mismatch";
+  return void 0;
+}
+function handlerReferenceAssociation(call) {
+  if (call.status === "resolved" && typeof call.calleeSymbolId === "number")
+    return { status: "resolved", toKind: "symbol", toId: String(call.calleeSymbolId), call, matchCount: 1, missing: false };
+  if (call.status === "ambiguous") return {
+    status: "ambiguous",
+    toKind: "symbol_reference",
+    toId: String(call.id),
+    reasonCode: "subscription_handler_reference_ambiguous",
+    call,
+    matchCount: 1,
+    missing: false
+  };
+  return {
+    status: "unresolved",
+    toKind: "symbol_reference",
+    toId: String(call.id),
+    reasonCode: call.status === "resolved" ? "resolved_handler_symbol_missing" : "subscription_handler_reference_unresolved",
+    call,
+    matchCount: 1,
+    missing: false
+  };
+}
+function agreedOrMixed(values) {
+  const distinct = new Set(values.map((value2) => value2 ?? "missing"));
+  if (distinct.size > 1) return "mixed";
+  const value = distinct.values().next().value;
+  return value === "missing" ? void 0 : value;
+}
+function missingAssociation(subscriptionId, matchCount, reasonCode, call) {
+  return {
+    status: "unresolved",
+    toKind: "subscription_handler",
+    toId: String(subscriptionId),
+    reasonCode,
+    call,
+    matchCount,
+    missing: true
+  };
+}
+function evidenceFor(subscription, association) {
+  const call = association.call ?? {};
+  const symbolCallReason = boundedSymbolCallReason(call.unresolvedReason);
+  return {
+    eventName: subscription.eventName,
+    associationBasis: "exact_subscription_call_span",
+    dispatchScope: "workspace_event_name_only",
+    subscribeCallId: subscription.id,
+    symbolCallId: call.id,
+    roleSiteMatchCount: association.matchCount,
+    callRole: association.matchCount > 0 ? "event_subscribe_handler" : void 0,
+    factOrigin: association.factOrigin ?? call.factOrigin,
+    repositoryId: subscription.repoId,
+    repositoryName: subscription.repoName,
+    sourceFile: subscription.sourceFile,
+    sourceLine: subscription.sourceLine,
+    callSiteStartOffset: subscription.startOffset,
+    callSiteEndOffset: subscription.endOffset,
+    handlerSymbolId: call.calleeSymbolId,
+    handlerSourceFile: call.targetSourceFile,
+    handlerSourceLine: call.targetSourceLine,
+    wrapperFunction: call.wrapperFunction,
+    associationStatus: association.status,
+    symbolCallResolutionStatus: association.symbolCallResolutionStatus ?? call.status,
+    resolutionStatus: association.status,
+    resolutionStrategy: call.strategy,
+    candidateCount: call.candidateCount,
+    reasonCode: association.reasonCode,
+    ...symbolCallReason
+  };
+}
+function boundedSymbolCallReason(reason) {
+  if (!reason) return {};
+  const value = reason.slice(0, symbolCallReasonLimit);
+  return {
+    symbolCallUnresolvedReason: value,
+    omittedSymbolCallUnresolvedReasonCharacterCount: Math.max(0, reason.length - value.length)
+  };
+}
+function insertAssociationEdge(db, workspaceId, generation, subscription, association) {
+  db.prepare(`INSERT INTO graph_edges(
+    workspace_id,edge_type,status,from_kind,from_id,to_kind,to_id,
+    confidence,evidence_json,is_dynamic,unresolved_reason,generation
+  ) VALUES(?,?,?,?,?,?,?,?,?,?,?,?)`).run(
+    workspaceId,
+    "EVENT_SUBSCRIPTION_HANDLED_BY",
+    association.status,
+    "event",
+    subscription.eventName,
+    association.toKind,
+    association.toId,
+    association.call?.confidence ?? subscription.confidence,
+    JSON.stringify(evidenceFor(subscription, association)),
+    0,
+    association.reasonCode ?? association.call?.unresolvedReason ?? null,
+    generation
+  );
+}
+function linkEventSubscriptionHandlers(db, workspaceId, generation) {
+  const summary = {
+    edgeCount: 0,
+    resolvedCount: 0,
+    ambiguousCount: 0,
+    unresolvedCount: 0,
+    missingAssociationCount: 0
+  };
+  for (const subscription of subscriptionRows(db, workspaceId)) {
+    const association = associationFor(
+      subscription,
+      roleSiteRows(db, subscription)
+    );
+    insertAssociationEdge(
+      db,
+      workspaceId,
+      generation,
+      subscription,
+      association
+    );
+    summary.edgeCount += 1;
+    summary.resolvedCount += association.status === "resolved" ? 1 : 0;
+    summary.ambiguousCount += association.status === "ambiguous" ? 1 : 0;
+    summary.unresolvedCount += association.status === "unresolved" ? 1 : 0;
+    summary.missingAssociationCount += association.missing ? 1 : 0;
+  }
+  return summary;
+}
+
+// src/db/schema.ts
+var schemaTablesSql = `
+CREATE TABLE IF NOT EXISTS workspaces (id INTEGER PRIMARY KEY, root_path TEXT UNIQUE NOT NULL, db_path TEXT NOT NULL, created_at TEXT NOT NULL, updated_at TEXT NOT NULL);
+CREATE TABLE IF NOT EXISTS repositories (id INTEGER PRIMARY KEY, workspace_id INTEGER NOT NULL, name TEXT NOT NULL, absolute_path TEXT NOT NULL, relative_path TEXT NOT NULL, package_name TEXT, package_version TEXT, dependencies_json TEXT DEFAULT '{}', kind TEXT NOT NULL, is_git_repo INTEGER NOT NULL, last_indexed_at TEXT, index_status TEXT DEFAULT 'pending', error_count INTEGER DEFAULT 0, fingerprint TEXT, fact_generation INTEGER NOT NULL DEFAULT 0, graph_generation INTEGER NOT NULL DEFAULT 0, graph_stale_reason TEXT, graph_stale_at TEXT, fact_analyzer_version TEXT, UNIQUE(workspace_id, absolute_path), FOREIGN KEY(workspace_id) REFERENCES workspaces(id) ON DELETE CASCADE);
+CREATE TABLE IF NOT EXISTS files (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NULL, relative_path TEXT NOT NULL, extension TEXT NOT NULL, sha256 TEXT NOT NULL, size_bytes INTEGER NOT NULL, last_indexed_at TEXT NOT NULL, UNIQUE(repo_id, relative_path), FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE);
+CREATE TABLE IF NOT EXISTS cds_requires (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NULL, alias TEXT NOT NULL, kind TEXT, model TEXT, destination TEXT, service_path TEXT, request_timeout INTEGER, raw_json TEXT NOT NULL, FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE);
+CREATE TABLE IF NOT EXISTS cds_services (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NULL, namespace TEXT, service_name TEXT NOT NULL, qualified_name TEXT NOT NULL, service_path TEXT NOT NULL, is_extend INTEGER NOT NULL, source_file TEXT NOT NULL, source_line INTEGER NOT NULL, extension_local_ref TEXT, extension_imported_symbol TEXT, extension_local_alias TEXT, extension_module_specifier TEXT, extension_import_kind TEXT, extension_base_service_id INTEGER, extension_base_status TEXT, FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE, FOREIGN KEY(extension_base_service_id) REFERENCES cds_services(id) ON DELETE SET NULL);
+CREATE TABLE IF NOT EXISTS cds_operations (id INTEGER PRIMARY KEY, service_id INTEGER NOT NULL, operation_type TEXT NOT NULL, operation_name TEXT NOT NULL, operation_path TEXT NOT NULL, params_json TEXT NOT NULL, return_type TEXT, source_file TEXT NOT NULL, source_line INTEGER NOT NULL, provenance TEXT NOT NULL DEFAULT 'direct', base_operation_id INTEGER, FOREIGN KEY(service_id) REFERENCES cds_services(id) ON DELETE CASCADE, FOREIGN KEY(base_operation_id) REFERENCES cds_operations(id) ON DELETE SET NULL);
+CREATE TABLE IF NOT EXISTS symbols (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NULL, file_id INTEGER, kind TEXT NOT NULL, name TEXT NOT NULL, qualified_name TEXT NOT NULL, exported INTEGER NOT NULL, start_line INTEGER NOT NULL, end_line INTEGER NOT NULL, start_offset INTEGER, end_offset INTEGER, source_file TEXT, exported_name TEXT, evidence_json TEXT, FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE, FOREIGN KEY(file_id) REFERENCES files(id) ON DELETE CASCADE);
+CREATE TABLE IF NOT EXISTS handler_classes (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NULL, symbol_id INTEGER, class_name TEXT NOT NULL, source_file TEXT NOT NULL, source_line INTEGER NOT NULL, FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE, FOREIGN KEY(symbol_id) REFERENCES symbols(id) ON DELETE SET NULL);
+CREATE TABLE IF NOT EXISTS handler_methods (id INTEGER PRIMARY KEY, handler_class_id INTEGER NOT NULL, method_name TEXT NOT NULL, decorator_kind TEXT NOT NULL, decorator_value TEXT, decorator_raw_expression TEXT NOT NULL, decorator_resolution_json TEXT NOT NULL DEFAULT '{}', source_file TEXT NOT NULL, source_line INTEGER NOT NULL, FOREIGN KEY(handler_class_id) REFERENCES handler_classes(id) ON DELETE CASCADE);
+CREATE TABLE IF NOT EXISTS handler_registrations (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NULL, handler_class_id INTEGER, class_name TEXT, import_source TEXT, registration_file TEXT NOT NULL, registration_line INTEGER NOT NULL, registration_kind TEXT NOT NULL, confidence REAL NOT NULL, FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE, FOREIGN KEY(handler_class_id) REFERENCES handler_classes(id) ON DELETE SET NULL);
+CREATE TABLE IF NOT EXISTS service_bindings (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NULL, symbol_id INTEGER, variable_name TEXT NOT NULL, alias TEXT, alias_expr TEXT, destination_expr TEXT, service_path_expr TEXT, is_dynamic INTEGER NOT NULL, placeholders_json TEXT NOT NULL, source_file TEXT NOT NULL, source_line INTEGER NOT NULL, helper_chain_json TEXT, FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE, FOREIGN KEY(symbol_id) REFERENCES symbols(id) ON DELETE SET NULL);
+CREATE TABLE IF NOT EXISTS outbound_calls (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NULL, source_symbol_id INTEGER, call_type TEXT NOT NULL, service_binding_id INTEGER, method TEXT, operation_path_expr TEXT, query_entity TEXT, event_name_expr TEXT, payload_summary TEXT, source_file TEXT NOT NULL, source_line INTEGER NOT NULL, call_site_start_offset INTEGER, call_site_end_offset INTEGER, confidence REAL NOT NULL, unresolved_reason TEXT, local_service_name TEXT, local_service_lookup TEXT, alias_chain_json TEXT, evidence_json TEXT, external_target_kind TEXT, external_target_id TEXT, external_target_label TEXT, external_target_dynamic INTEGER NOT NULL DEFAULT 0, FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE, FOREIGN KEY(source_symbol_id) REFERENCES symbols(id) ON DELETE SET NULL, FOREIGN KEY(service_binding_id) REFERENCES service_bindings(id) ON DELETE SET NULL);
+CREATE TABLE IF NOT EXISTS symbol_calls (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NULL, caller_symbol_id INTEGER NOT NULL, callee_symbol_id INTEGER, callee_expression TEXT NOT NULL, import_source TEXT, source_file TEXT NOT NULL, source_line INTEGER NOT NULL, call_site_start_offset INTEGER, call_site_end_offset INTEGER, call_role TEXT NOT NULL DEFAULT 'legacy_unknown', status TEXT NOT NULL, confidence REAL NOT NULL, evidence_json TEXT NOT NULL, unresolved_reason TEXT, FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE, FOREIGN KEY(caller_symbol_id) REFERENCES symbols(id) ON DELETE CASCADE, FOREIGN KEY(callee_symbol_id) REFERENCES symbols(id) ON DELETE SET NULL);
+CREATE TABLE IF NOT EXISTS graph_edges (id INTEGER PRIMARY KEY, workspace_id INTEGER NOT NULL, edge_type TEXT NOT NULL, status TEXT NOT NULL DEFAULT 'unresolved', from_kind TEXT NOT NULL, from_id TEXT NOT NULL, to_kind TEXT NOT NULL, to_id TEXT NOT NULL, confidence REAL NOT NULL, evidence_json TEXT NOT NULL, is_dynamic INTEGER NOT NULL, unresolved_reason TEXT, generation INTEGER NOT NULL DEFAULT 0, FOREIGN KEY(workspace_id) REFERENCES workspaces(id) ON DELETE CASCADE);
+CREATE TABLE IF NOT EXISTS index_runs (id INTEGER PRIMARY KEY, workspace_id INTEGER NOT NULL, started_at TEXT NOT NULL, finished_at TEXT, status TEXT NOT NULL, repo_count INTEGER NOT NULL, file_count INTEGER NOT NULL, diagnostic_count INTEGER NOT NULL, error_message TEXT, owner_pid INTEGER, FOREIGN KEY(workspace_id) REFERENCES workspaces(id) ON DELETE CASCADE);
+CREATE TABLE IF NOT EXISTS diagnostics (id INTEGER PRIMARY KEY, repo_id INTEGER, file_id INTEGER, severity TEXT NOT NULL, code TEXT NOT NULL, message TEXT NOT NULL, source_file TEXT, source_line INTEGER, FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE, FOREIGN KEY(file_id) REFERENCES files(id) ON DELETE SET NULL);
+`;
+var schemaIndexesSql = `
+CREATE INDEX IF NOT EXISTS idx_repo_name ON repositories(name);
+CREATE INDEX IF NOT EXISTS idx_service_path ON cds_services(service_path);
+CREATE INDEX IF NOT EXISTS idx_extension_import ON cds_services(extension_module_specifier, extension_imported_symbol, is_extend);
+CREATE INDEX IF NOT EXISTS idx_operation_name ON cds_operations(operation_name, operation_path);
+CREATE INDEX IF NOT EXISTS idx_operation_base ON cds_operations(base_operation_id);
+CREATE INDEX IF NOT EXISTS idx_calls_repo ON outbound_calls(repo_id, call_type);
+CREATE INDEX IF NOT EXISTS idx_symbol_calls_caller ON symbol_calls(repo_id, caller_symbol_id);
+CREATE INDEX IF NOT EXISTS idx_outbound_call_site ON outbound_calls(repo_id, source_file, call_site_start_offset, call_site_end_offset, call_type);
+CREATE INDEX IF NOT EXISTS idx_symbol_call_site_role ON symbol_calls(repo_id, source_file, call_site_start_offset, call_site_end_offset, call_role);
+CREATE VIRTUAL TABLE IF NOT EXISTS search_index USING fts5(kind, name, path, repo);
+`;
+var schemaSql = `${schemaTablesSql}
+${schemaIndexesSql}`;
+
+// src/db/migrations.ts
+var CURRENT_SCHEMA_VERSION = 12;
+var columns = {
+  handler_methods: [
+    { name: "decorator_resolution_json", ddl: "ALTER TABLE handler_methods ADD COLUMN decorator_resolution_json TEXT NOT NULL DEFAULT '{}'" }
+  ],
+  service_bindings: [
+    { name: "helper_chain_json", ddl: "ALTER TABLE service_bindings ADD COLUMN helper_chain_json TEXT" },
+    { name: "alias_expr", ddl: "ALTER TABLE service_bindings ADD COLUMN alias_expr TEXT" }
+  ],
+  repositories: [
+    { name: "fingerprint", ddl: "ALTER TABLE repositories ADD COLUMN fingerprint TEXT" },
+    { name: "fact_generation", ddl: "ALTER TABLE repositories ADD COLUMN fact_generation INTEGER NOT NULL DEFAULT 0" },
+    { name: "graph_generation", ddl: "ALTER TABLE repositories ADD COLUMN graph_generation INTEGER NOT NULL DEFAULT 0" },
+    { name: "graph_stale_reason", ddl: "ALTER TABLE repositories ADD COLUMN graph_stale_reason TEXT" },
+    { name: "graph_stale_at", ddl: "ALTER TABLE repositories ADD COLUMN graph_stale_at TEXT" },
+    { name: "fact_analyzer_version", ddl: "ALTER TABLE repositories ADD COLUMN fact_analyzer_version TEXT DEFAULT 'legacy'" }
+  ],
+  graph_edges: [
+    { name: "status", ddl: "ALTER TABLE graph_edges ADD COLUMN status TEXT NOT NULL DEFAULT 'unresolved'" },
+    { name: "generation", ddl: "ALTER TABLE graph_edges ADD COLUMN generation INTEGER NOT NULL DEFAULT 0" }
+  ],
+  handler_registrations: [
+    { name: "class_name", ddl: "ALTER TABLE handler_registrations ADD COLUMN class_name TEXT" },
+    { name: "import_source", ddl: "ALTER TABLE handler_registrations ADD COLUMN import_source TEXT" }
+  ],
+  symbols: [
+    { name: "start_offset", ddl: "ALTER TABLE symbols ADD COLUMN start_offset INTEGER" },
+    { name: "end_offset", ddl: "ALTER TABLE symbols ADD COLUMN end_offset INTEGER" },
+    { name: "source_file", ddl: "ALTER TABLE symbols ADD COLUMN source_file TEXT" },
+    { name: "exported_name", ddl: "ALTER TABLE symbols ADD COLUMN exported_name TEXT" },
+    { name: "evidence_json", ddl: "ALTER TABLE symbols ADD COLUMN evidence_json TEXT" }
+  ],
+  cds_services: [
+    { name: "extension_local_ref", ddl: "ALTER TABLE cds_services ADD COLUMN extension_local_ref TEXT" },
+    { name: "extension_imported_symbol", ddl: "ALTER TABLE cds_services ADD COLUMN extension_imported_symbol TEXT" },
+    { name: "extension_local_alias", ddl: "ALTER TABLE cds_services ADD COLUMN extension_local_alias TEXT" },
+    { name: "extension_module_specifier", ddl: "ALTER TABLE cds_services ADD COLUMN extension_module_specifier TEXT" },
+    { name: "extension_import_kind", ddl: "ALTER TABLE cds_services ADD COLUMN extension_import_kind TEXT" },
+    { name: "extension_base_service_id", ddl: "ALTER TABLE cds_services ADD COLUMN extension_base_service_id INTEGER" },
+    { name: "extension_base_status", ddl: "ALTER TABLE cds_services ADD COLUMN extension_base_status TEXT" }
+  ],
+  cds_operations: [
+    { name: "provenance", ddl: "ALTER TABLE cds_operations ADD COLUMN provenance TEXT NOT NULL DEFAULT 'direct'" },
+    { name: "base_operation_id", ddl: "ALTER TABLE cds_operations ADD COLUMN base_operation_id INTEGER" }
+  ],
+  outbound_calls: [
+    { name: "local_service_name", ddl: "ALTER TABLE outbound_calls ADD COLUMN local_service_name TEXT" },
+    { name: "local_service_lookup", ddl: "ALTER TABLE outbound_calls ADD COLUMN local_service_lookup TEXT" },
+    { name: "alias_chain_json", ddl: "ALTER TABLE outbound_calls ADD COLUMN alias_chain_json TEXT" },
+    { name: "evidence_json", ddl: "ALTER TABLE outbound_calls ADD COLUMN evidence_json TEXT" },
+    { name: "external_target_kind", ddl: "ALTER TABLE outbound_calls ADD COLUMN external_target_kind TEXT" },
+    { name: "external_target_id", ddl: "ALTER TABLE outbound_calls ADD COLUMN external_target_id TEXT" },
+    { name: "external_target_label", ddl: "ALTER TABLE outbound_calls ADD COLUMN external_target_label TEXT" },
+    { name: "external_target_dynamic", ddl: "ALTER TABLE outbound_calls ADD COLUMN external_target_dynamic INTEGER NOT NULL DEFAULT 0" },
+    { name: "call_site_start_offset", ddl: "ALTER TABLE outbound_calls ADD COLUMN call_site_start_offset INTEGER" },
+    { name: "call_site_end_offset", ddl: "ALTER TABLE outbound_calls ADD COLUMN call_site_end_offset INTEGER" }
+  ],
+  symbol_calls: [
+    { name: "call_site_start_offset", ddl: "ALTER TABLE symbol_calls ADD COLUMN call_site_start_offset INTEGER" },
+    { name: "call_site_end_offset", ddl: "ALTER TABLE symbol_calls ADD COLUMN call_site_end_offset INTEGER" },
+    { name: "call_role", ddl: "ALTER TABLE symbol_calls ADD COLUMN call_role TEXT NOT NULL DEFAULT 'legacy_unknown'" }
+  ],
+  index_runs: [
+    { name: "error_message", ddl: "ALTER TABLE index_runs ADD COLUMN error_message TEXT" },
+    { name: "owner_pid", ddl: "ALTER TABLE index_runs ADD COLUMN owner_pid INTEGER" }
+  ]
+};
+function hasColumn(db, table, column) {
+  return db.prepare(`PRAGMA table_info(${table})`).all().some((row) => row.name === column);
+}
+function userVersion(db) {
+  const row = db.pragma("user_version")[0];
+  return Number(row?.user_version ?? 0);
+}
+function addMissingColumns(db) {
+  for (const [table, tableColumns] of Object.entries(columns)) {
+    for (const column of tableColumns) {
+      if (!hasColumn(db, table, column.name)) db.prepare(column.ddl).run();
+    }
+  }
+}
+function normalizeLegacyStatus(db) {
+  db.prepare("UPDATE graph_edges SET status=CASE WHEN edge_type='REMOTE_CALL_RESOLVES_TO_OPERATION' THEN 'resolved' WHEN edge_type IN ('HANDLER_RUNS_DB_QUERY','HANDLER_CALLS_EXTERNAL_HTTP','HANDLER_EMITS_EVENT','EVENT_CONSUMED_BY_HANDLER') THEN 'terminal' WHEN edge_type='DYNAMIC_EDGE_CANDIDATE' THEN 'dynamic' WHEN status='ambiguous' THEN 'ambiguous' ELSE status END").run();
+  db.prepare("UPDATE repositories SET graph_stale_reason='schema_migration_requires_relink', graph_stale_at=COALESCE(graph_stale_at, datetime('now')) WHERE EXISTS (SELECT 1 FROM graph_edges WHERE graph_edges.workspace_id=repositories.workspace_id) AND graph_generation=0").run();
+}
+function markCallSiteMigrationStale(db, priorVersion) {
+  if (priorVersion >= 12) return;
+  db.prepare(`UPDATE repositories
+    SET graph_stale_reason='schema_v12_call_sites_require_reindex',
+      graph_stale_at=COALESCE(graph_stale_at,datetime('now'))
+    WHERE index_status='indexed' OR last_indexed_at IS NOT NULL`).run();
+}
+function migrate(db) {
+  db.transaction(() => {
+    const version = userVersion(db);
+    if (version > CURRENT_SCHEMA_VERSION) throw new Error(`Unsupported future service-flow schema version ${version}`);
+    db.exec(schemaTablesSql);
+    addMissingColumns(db);
+    db.exec(schemaIndexesSql);
+    normalizeLegacyStatus(db);
+    markCallSiteMigrationStale(db, version);
+    const violations = db.pragma("foreign_key_check");
+    if (violations.length > 0) throw new Error("SQLite foreign_key_check failed during migration");
+    db.pragma(`user_version = ${CURRENT_SCHEMA_VERSION}`);
+  });
+}
+function schemaVersion(db) {
+  return userVersion(db);
+}
+
+// src/db/001-fact-lifecycle.ts
+var remediation = [
+  "service-flow index --workspace /workspace --force",
+  "service-flow link --workspace /workspace --force"
+].join("\n");
+function count(db, sql, ...params) {
+  const row = db.prepare(sql).get(...params);
+  return Number(row?.count ?? 0);
+}
+function oldAnalyzerCount(db, workspaceId) {
+  return count(
+    db,
+    `SELECT COUNT(*) count FROM repositories
+    WHERE (? IS NULL OR workspace_id=?)
+      AND (COALESCE(index_status,'pending')<>'indexed'
+        OR COALESCE(fact_analyzer_version,'legacy')<>?)`,
+    workspaceId,
+    workspaceId,
+    ANALYZER_VERSION
+  );
+}
+function invalidCurrentFactCount(db, workspaceId) {
+  const outbound = count(
+    db,
+    `SELECT COUNT(*) count
+    FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id
+    WHERE (? IS NULL OR r.workspace_id=?) AND r.fact_analyzer_version=?
+      AND (typeof(c.call_site_start_offset)<>'integer'
+        OR typeof(c.call_site_end_offset)<>'integer'
+        OR c.call_site_start_offset<0
+        OR c.call_site_end_offset<=c.call_site_start_offset)`,
+    workspaceId,
+    workspaceId,
+    ANALYZER_VERSION
+  );
+  const symbols = count(
+    db,
+    `SELECT COUNT(*) count
+    FROM symbol_calls c JOIN repositories r ON r.id=c.repo_id
+    WHERE (? IS NULL OR r.workspace_id=?)
+      AND (c.call_role='legacy_unknown'
+        OR (r.fact_analyzer_version=? AND (
+          typeof(c.call_site_start_offset)<>'integer'
+          OR typeof(c.call_site_end_offset)<>'integer'
+          OR c.call_site_start_offset<0
+          OR c.call_site_end_offset<=c.call_site_start_offset
+          OR c.call_role NOT IN ('ordinary_call','event_subscribe_handler'))))`,
+    workspaceId,
+    workspaceId,
+    ANALYZER_VERSION
+  );
+  return outbound + symbols;
+}
+function factLifecycleDiagnostic(db, workspaceId) {
+  return schemaLifecycleDiagnostic(db) ?? currentFactLifecycleDiagnostic(db, workspaceId);
+}
+function schemaLifecycleDiagnostic(db) {
+  const currentSchema = schemaVersion(db);
+  if (currentSchema > CURRENT_SCHEMA_VERSION) return {
+    severity: "error",
+    code: "unsupported_future_schema",
+    message: `Database schema ${currentSchema} is newer than the supported schema ${CURRENT_SCHEMA_VERSION}; upgrade service-flow before reading this database.`,
+    remediation: "Install a service-flow version that supports this database schema.",
+    currentSchemaVersion: currentSchema,
+    supportedSchemaVersion: CURRENT_SCHEMA_VERSION
+  };
+  if (currentSchema < CURRENT_SCHEMA_VERSION) return {
+    severity: "error",
+    code: "schema_upgrade_required",
+    message: `Database schema ${currentSchema} must be upgraded to ${CURRENT_SCHEMA_VERSION} before this command can read current call-site facts.`,
+    remediation,
+    currentSchemaVersion: currentSchema,
+    requiredSchemaVersion: CURRENT_SCHEMA_VERSION
+  };
+  return void 0;
+}
+function currentFactLifecycleDiagnostic(db, workspaceId) {
+  const staleRepositories = oldAnalyzerCount(db, workspaceId);
+  const invalidFacts = invalidCurrentFactCount(db, workspaceId);
+  if (staleRepositories === 0 && invalidFacts === 0) return void 0;
+  return {
+    severity: "error",
+    code: "reindex_required",
+    message: "Call-site facts are stale or lack typed roles and exact spans; force index and link before tracing or rebuilding graph edges.",
+    remediation,
+    staleRepositoryCount: staleRepositories,
+    invalidCallFactCount: invalidFacts,
+    requiredAnalyzerVersion: ANALYZER_VERSION
+  };
+}
+function assertWorkspaceLinkable(db, workspaceId) {
+  const diagnostic = factLifecycleDiagnostic(db, workspaceId);
+  if (!diagnostic) return;
+  throw new Error(`${diagnostic.code}: ${diagnostic.message}
+${diagnostic.remediation}`);
+}
+
+// src/linker/cross-repo-linker.ts
+function linkWorkspace(db, workspaceId, vars = {}) {
+  return db.transaction(() => {
+    assertWorkspaceLinkable(db, workspaceId);
+    const generation = nextGraphGeneration(db, workspaceId);
+    db.prepare("DELETE FROM graph_edges WHERE workspace_id=?").run(workspaceId);
+    const deps = linkHelperPackages(db, workspaceId, generation);
+    linkPackageImportSymbolCalls(db, workspaceId);
+    const subscriptions = linkEventSubscriptionHandlers(
+      db,
+      workspaceId,
+      generation
+    );
+    const impl = linkImplementations(db, workspaceId, generation);
+    const callSummary = linkCalls(db, workspaceId, vars, generation);
+    db.prepare("UPDATE repositories SET graph_generation=?, graph_stale_reason=NULL, graph_stale_at=NULL WHERE workspace_id=?").run(generation, workspaceId);
+    return { ...callSummary, edgeCount: deps.edgeCount + callSummary.edgeCount + impl.edgeCount + subscriptions.edgeCount, dependencyResolvedCount: deps.resolvedCount, dependencyAmbiguousCount: deps.ambiguousCount, implementationResolvedCount: impl.resolvedCount, implementationAmbiguousCount: impl.ambiguousCount, implementationUnresolvedCount: impl.unresolvedCount, subscriptionHandlerResolvedCount: subscriptions.resolvedCount, subscriptionHandlerAmbiguousCount: subscriptions.ambiguousCount, subscriptionHandlerUnresolvedCount: subscriptions.unresolvedCount, subscriptionHandlerMissingAssociationCount: subscriptions.missingAssociationCount };
+  });
+}
+function nextGraphGeneration(db, workspaceId) {
+  const row = db.prepare("SELECT COALESCE(MAX(graph_generation),0) generation FROM repositories WHERE workspace_id=?").get(workspaceId);
+  return Number(row?.generation ?? 0) + 1;
+}
+function linkCalls(db, workspaceId, vars, generation) {
+  let edgeCount = 0;
+  let unresolvedCount = 0;
+  let resolvedCount = 0;
+  let remoteResolvedCount = 0;
+  let localResolvedCount = 0;
+  let ambiguousCount = 0;
+  let dynamicCount = 0;
+  let terminalCount = 0;
+  const calls = db.prepare(`SELECT c.*,r.name repoName,b.id selectedBindingId,b.alias,b.alias_expr aliasExpr,b.destination_expr destinationExpr,b.service_path_expr servicePathExpr,b.is_dynamic isDynamic,b.placeholders_json placeholdersJson,b.source_file bindingSourceFile,b.source_line bindingSourceLine,b.helper_chain_json helperChainJson,req.service_path requireServicePath,req.destination requireDestination FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id LEFT JOIN service_bindings b ON b.id=c.service_binding_id LEFT JOIN cds_requires req ON req.repo_id=c.repo_id AND req.alias=b.alias WHERE r.workspace_id=?`).all(workspaceId);
+  for (const call of calls) {
+    const result = insertCallEdge(db, workspaceId, call, vars, generation);
+    edgeCount += 1;
+    resolvedCount += result.status === "resolved" ? 1 : 0;
+    remoteResolvedCount += result.status === "resolved" && result.callType !== "local_service_call" ? 1 : 0;
+    localResolvedCount += result.status === "resolved" && result.callType === "local_service_call" ? 1 : 0;
+    unresolvedCount += result.status === "unresolved" ? 1 : 0;
+    ambiguousCount += result.status === "ambiguous" ? 1 : 0;
+    dynamicCount += result.status === "dynamic" ? 1 : 0;
+    terminalCount += result.status === "terminal" ? 1 : 0;
+  }
+  return { edgeCount, unresolvedCount, resolvedCount, remoteResolvedCount, localResolvedCount, ambiguousCount, dynamicCount, terminalCount };
+}
+function insertCallEdge(db, workspaceId, call, vars, generation) {
+  const callType = String(call.call_type);
+  const rawOp = applyVariables(String(call.operation_path_expr ?? ""), vars);
+  const intent = classifyODataPathIntent(rawOp, call.method);
+  const isEntityQueryIntent = ["entity_query", "entity_key_read", "entity_navigation_query"].includes(intent.kind);
   const resolutionRawOp = callType === "remote_query" && isEntityQueryIntent ? intent.pathWithoutQuery : rawOp;
   const normalized = normalizeODataOperationInvocationPath(resolutionRawOp);
   const op = normalized?.normalizedOperationPath ?? resolutionRawOp;
@@ -5890,11 +6589,11 @@ function insertCallEdge(db, workspaceId, call, vars, generation) {
   const status = edgeType === "DYNAMIC_EDGE_CANDIDATE" ? "dynamic" : resolution.status === "ambiguous" ? "ambiguous" : edgeType === "UNRESOLVED_EDGE" ? "unresolved" : "terminal";
   const unresolvedReason = status === "terminal" ? null : String(call.unresolved_reason ?? unresolvedOperationReason(resolution));
   const externalTarget = callType === "external_http" ? externalHttpTarget(call) : void 0;
-  const targetKind = callType === "local_db_query" ? "db_entity" : callType.startsWith("async_") ? "event" : callType === "external_http" ? externalTarget?.toKind ?? "external_endpoint" : "operation_candidate";
+  const targetKind2 = callType === "local_db_query" ? "db_entity" : callType.startsWith("async_") ? "event" : callType === "external_http" ? externalTarget?.toKind ?? "external_endpoint" : "operation_candidate";
   const targetId = callType === "local_db_query" ? String(call.query_entity ?? "unknown") : callType === "remote_action" ? op ? `Remote action: ${op}` : call.unresolved_reason === "dynamic_operation_path_identifier" ? "Remote action: dynamic path" : "Remote action: unknown path" : callType === "external_http" ? String(externalTarget?.toId ?? "unknown") : String(call.event_name_expr ?? op ?? "unknown");
   const graphLevelDynamic = edgeType === "DYNAMIC_EDGE_CANDIDATE" && resolution.status === "dynamic";
   const finalEvidence = externalTarget ? { ...evidence, externalTarget } : evidence;
-  db.prepare("INSERT INTO graph_edges(workspace_id,edge_type,status,from_kind,from_id,to_kind,to_id,confidence,evidence_json,is_dynamic,unresolved_reason,generation) VALUES(?,?,?,?,?,?,?,?,?,?,?,?)").run(workspaceId, edgeType, status, "call", String(call.id), targetKind, targetId, Number(call.confidence ?? 0.2), JSON.stringify(finalEvidence), graphLevelDynamic ? 1 : 0, unresolvedReason, generation);
+  db.prepare("INSERT INTO graph_edges(workspace_id,edge_type,status,from_kind,from_id,to_kind,to_id,confidence,evidence_json,is_dynamic,unresolved_reason,generation) VALUES(?,?,?,?,?,?,?,?,?,?,?,?)").run(workspaceId, edgeType, status, "call", String(call.id), targetKind2, targetId, Number(call.confidence ?? 0.2), JSON.stringify(finalEvidence), graphLevelDynamic ? 1 : 0, unresolvedReason, generation);
   return { status, callType };
 }
 function operationCandidateCount(db, workspaceId, operationPath, operationName) {
@@ -6733,18 +7432,18 @@ function dynamicRoutingContext(db, workspaceId, evidence) {
     fallbackUsed: true
   };
 }
-function dynamicReferenceProvenance(reference, kind, template, value) {
-  const sourceKind = reference.selection === "selected_binding" ? `selected_binding.${kind}` : reference.selection === "selected_binding_require" ? `selected_binding_require.${kind}` : `${reference.sourceKind}.${kind}`;
+function dynamicReferenceProvenance(reference2, kind, template, value) {
+  const sourceKind = reference2.selection === "selected_binding" ? `selected_binding.${kind}` : reference2.selection === "selected_binding_require" ? `selected_binding_require.${kind}` : `${reference2.sourceKind}.${kind}`;
   return {
     sourceKind,
     value,
     rule: "exact_indexed_reference_template_match",
     template,
-    sourceRepo: reference.repoName,
-    sourceFile: reference.sourceFile,
-    sourceLine: reference.sourceLine,
-    selection: reference.selection,
-    bindingId: reference.bindingId
+    sourceRepo: reference2.repoName,
+    sourceFile: reference2.sourceFile,
+    sourceLine: reference2.sourceLine,
+    selection: reference2.selection,
+    bindingId: reference2.bindingId
   };
 }
 function contextBase(selected, status, alternatives) {
@@ -6779,12 +7478,12 @@ function selectedBinding(db, workspaceId, evidence) {
 function selectedReferenceFromRow(row) {
   const outboundCallId = numberValue6(row?.outboundCallId);
   const callerRepoId = numberValue6(row?.callerRepoId);
-  const reference = referenceFromRow(
+  const reference2 = referenceFromRow(
     row,
     "service_binding",
     "selected_binding"
   )[0];
-  return reference && outboundCallId !== void 0 && callerRepoId !== void 0 ? { ...reference, outboundCallId, callerRepoId } : void 0;
+  return reference2 && outboundCallId !== void 0 && callerRepoId !== void 0 ? { ...reference2, outboundCallId, callerRepoId } : void 0;
 }
 function exactRequireReferences(db, workspaceId, selected) {
   if (!(selected.aliasExpr ?? selected.alias)) return [];
@@ -6967,7 +7666,7 @@ function buildCandidates(db, targets, references, inputs) {
     const state = emptyCandidate(target, inputs);
     applyDirectSignal(state, inputs, "operationPath", target.operationPath, 0.25);
     applyDirectSignal(state, inputs, "servicePath", target.servicePath, 0.35);
-    const matchingReferences = references.filter((reference) => referenceMatchesCandidate(reference, target.servicePath) && referenceMatchesSelectedAlias(reference, inputs.routing.selectedBinding));
+    const matchingReferences = references.filter((reference2) => referenceMatchesCandidate(reference2, target.servicePath) && referenceMatchesSelectedAlias(reference2, inputs.routing.selectedBinding));
     const referencesForSignals = fallbackReferencesForCandidate(
       state,
       matchingReferences,
@@ -6990,12 +7689,12 @@ function fallbackReferencesForCandidate(state, references, fallbackUsed) {
 }
 function uniqueFallbackReferences(references) {
   const seen = /* @__PURE__ */ new Set();
-  return references.filter((reference) => {
+  return references.filter((reference2) => {
     const signature = [
-      reference.sourceKind,
-      reference.alias,
-      reference.destination,
-      reference.servicePath
+      reference2.sourceKind,
+      reference2.alias,
+      reference2.destination,
+      reference2.servicePath
     ].join("\0");
     if (seen.has(signature)) return false;
     seen.add(signature);
@@ -7067,15 +7766,15 @@ function applyReferenceSignal(state, inputs, references, kind) {
   const original = inputs.original[kind];
   const effective = inputs.effective[kind];
   if (!original || extractPlaceholders(original).length === 0) return;
-  const values = references.flatMap((reference) => {
-    const concrete = kind === "alias" ? reference.alias : reference.destination;
-    return isConcrete(concrete) ? [{ reference, concrete }] : [];
+  const values = references.flatMap((reference2) => {
+    const concrete = kind === "alias" ? reference2.alias : reference2.destination;
+    return isConcrete(concrete) ? [{ reference: reference2, concrete }] : [];
   });
   if (effective && extractPlaceholders(effective).length === 0 && values.length > 0 && !values.some(({ concrete }) => concrete === effective)) {
     reject(state, `${kind}_contradicts_runtime_substitution`);
   }
   let matchedSignal = false;
-  for (const { reference, concrete } of values) {
+  for (const { reference: reference2, concrete } of values) {
     const matched = matchRuntimeTemplate(original, concrete);
     if (!matched) continue;
     matchedSignal = true;
@@ -7084,7 +7783,7 @@ function applyReferenceSignal(state, inputs, references, kind) {
         state,
         key,
         value,
-        dynamicReferenceProvenance(reference, kind, original, value)
+        dynamicReferenceProvenance(reference2, kind, original, value)
       );
     }
   }
@@ -7278,13 +7977,13 @@ function variableOrder(templates, required) {
   ].flatMap((value) => extractPlaceholders(value));
   return [.../* @__PURE__ */ new Set([...ordered, ...required])];
 }
-function referenceMatchesCandidate(reference, servicePath) {
-  return matchRuntimeTemplate(reference.servicePath, servicePath) !== void 0;
+function referenceMatchesCandidate(reference2, servicePath) {
+  return matchRuntimeTemplate(reference2.servicePath, servicePath) !== void 0;
 }
-function referenceMatchesSelectedAlias(reference, selected) {
-  if (reference.selection !== "selected_binding_require") return true;
+function referenceMatchesSelectedAlias(reference2, selected) {
+  if (reference2.selection !== "selected_binding_require") return true;
   const template = selected?.aliasExpr ?? selected?.alias;
-  return matchRuntimeTemplate(template, reference.alias) !== void 0;
+  return matchRuntimeTemplate(template, reference2.alias) !== void 0;
 }
 function cliFor(variables, order) {
   return order.filter((key) => variables[key] !== void 0).map((key) => `--var ${shellArgument(`${key}=${variables[key]}`)}`).join(" ");
@@ -7582,7 +8281,7 @@ function baseTraceEvidence(row, call, persistedEvidence, contextualEvidence2) {
   };
 }
 function runtimeResolution(db, row, evidence, options, workspaceId, contextualState) {
-  const dynamicMode = options.dynamicMode ?? "strict";
+  const dynamicMode2 = options.dynamicMode ?? "strict";
   const candidateCap = positiveCandidateCap(options.maxDynamicCandidates);
   const boundedEvidence = boundCandidateLikeEvidence(evidence, candidateCap);
   if (!isDynamicRemoteOperationEdge(row, evidence))
@@ -7596,7 +8295,7 @@ function runtimeResolution(db, row, evidence, options, workspaceId, contextualSt
     db,
     substituted,
     workspaceId,
-    dynamicMode,
+    dynamicMode2,
     candidateCap
   );
   const enriched = boundDynamicEvidence(
@@ -7608,7 +8307,7 @@ function runtimeResolution(db, row, evidence, options, workspaceId, contextualSt
     row,
     enriched,
     analysis,
-    dynamicMode,
+    dynamicMode2,
     appliedRuntimeValues,
     contextualState
   );
@@ -7626,10 +8325,10 @@ function runtimeResolution(db, row, evidence, options, workspaceId, contextualSt
   }
   return resolveSuppliedRuntimeOperation(db, row, enriched, workspaceId, contextualState);
 }
-function analyzedRuntimeResolution(row, evidence, analysis, dynamicMode, appliedRuntimeValues, contextualState) {
+function analyzedRuntimeResolution(row, evidence, analysis, dynamicMode2, appliedRuntimeValues, contextualState) {
   if (analysis && analysis.viableCandidateCount === 0 && Object.keys(analysis.appliedSuppliedVariables).length > 0)
     return noCandidateRuntimeResolution(row, evidence, contextualState);
-  const inferred = dynamicMode === "infer" ? inferredTarget(analysis) : void 0;
+  const inferred = dynamicMode2 === "infer" ? inferredTarget(analysis) : void 0;
   if (inferred && !isStructuralContextualBlocker(contextualState))
     return resolvedRuntimeResolution(row, evidence, inferred, inferred.reasons);
   if (analysis && analysis.missingVariables.length > 0 && appliedRuntimeValues) {
@@ -8110,19 +8809,25 @@ function positiveCandidateCap(value) {
 function dynamicCandidateBranches(depth, call, evidence) {
   const exploration = objectRecord2(evidence.dynamicTargetExploration);
   return recordArray4(evidence.dynamicTargetCandidateSuggestions).map((candidate) => ({
-    step: depth,
-    type: "dynamic_candidate_branch",
-    from: `${call.repoName}:${call.source_file}:${call.source_line}`,
-    to: `${String(candidate.servicePath ?? "")}${String(candidate.operationPath ?? "")}`,
-    evidence: {
-      ...candidate,
-      exploratory: true,
-      dynamicMode: String(exploration.mode ?? "candidates"),
-      selected: false,
-      omittedCandidateCount: numericValue4(exploration.omittedCandidateCount)
+    edge: {
+      step: depth,
+      type: "dynamic_candidate_branch",
+      from: `${call.repoName}:${call.source_file}:${call.source_line}`,
+      to: `${String(candidate.servicePath ?? "")}${String(candidate.operationPath ?? "")}`,
+      evidence: {
+        ...candidate,
+        exploratory: true,
+        dynamicMode: String(exploration.mode ?? "candidates"),
+        selected: false,
+        omittedCandidateCount: numericValue4(exploration.omittedCandidateCount)
+      },
+      confidence: numericValue4(candidate.score),
+      unresolvedReason: "Exploratory dynamic target candidate; provide runtime variables to select it"
     },
-    confidence: numericValue4(candidate.score),
-    unresolvedReason: "Exploratory dynamic target candidate; provide runtime variables to select it"
+    operationId: optionalNumber(candidate.candidateOperationId),
+    repositoryId: optionalNumber(candidate.repoId),
+    servicePath: optionalString(candidate.servicePath),
+    operationPath: optionalString(candidate.operationPath)
   }));
 }
 function objectRecord2(value) {
@@ -8134,6 +8839,12 @@ function recordArray4(value) {
 function numericValue4(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : 0;
 }
+function optionalNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function optionalString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
 
 // src/trace/002-trace-diagnostics.ts
 function loadTraceDiagnostics(db, repoId, includeWorkspaceDiagnostics, workspaceId) {
@@ -8455,155 +9166,377 @@ function numberValue9(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
 
-// src/trace/trace-engine.ts
-function normalizeOperation2(value) {
-  if (!value) return void 0;
-  return value.startsWith("/") ? value.slice(1) : value;
-}
-function positiveDepth(value) {
-  return Number.isFinite(value) && value > 0 ? Math.floor(value) : 25;
+// src/trace/010-traversal-scope.ts
+import { createHash as createHash2 } from "crypto";
+function compareBinary(left, right) {
+  const leftPoints = [...left];
+  const rightPoints = [...right];
+  const length = Math.min(leftPoints.length, rightPoints.length);
+  for (let index = 0; index < length; index += 1) {
+    const leftPoint = leftPoints[index]?.codePointAt(0) ?? 0;
+    const rightPoint = rightPoints[index]?.codePointAt(0) ?? 0;
+    if (leftPoint !== rightPoint) return leftPoint < rightPoint ? -1 : 1;
+  }
+  return leftPoints.length - rightPoints.length;
+}
+function resolveTraversalWorkspaceId(db, requestedWorkspaceId, repoId) {
+  if (requestedWorkspaceId !== void 0) return requestedWorkspaceId;
+  if (repoId !== void 0) {
+    const row = db.prepare(
+      "SELECT workspace_id workspaceId FROM repositories WHERE id=?"
+    ).get(repoId);
+    return typeof row?.workspaceId === "number" ? row.workspaceId : void 0;
+  }
+  const rows2 = db.prepare(`SELECT DISTINCT w.id workspaceId FROM workspaces w
+    JOIN repositories r ON r.workspace_id=w.id ORDER BY w.id LIMIT 2`).all();
+  return rows2.length === 1 && typeof rows2[0]?.workspaceId === "number" ? rows2[0].workspaceId : void 0;
+}
+function structuralScopeKey(workspaceId, repoId, files, symbolIds) {
+  return JSON.stringify([
+    workspaceId ?? null,
+    repoId ?? null,
+    files ? [...files].sort(compareBinary) : null,
+    symbolIds ? [...symbolIds].sort((left, right) => left - right) : null
+  ]);
 }
-function operationStartScope(db, repoId, start, hintOptions, workspaceId) {
-  const requested = normalizeOperation2(start.operationPath ?? start.operation);
-  if (!requested) return void 0;
-  const rows2 = db.prepare(`SELECT o.id operationId,o.operation_name operationName,o.operation_path operationPath,o.source_file sourceFile,o.source_line sourceLine,s.service_path servicePath,r.id repoId,r.name repoName
-    FROM cds_operations o JOIN cds_services s ON s.id=o.service_id JOIN repositories r ON r.id=s.repo_id
-    WHERE (? IS NULL OR r.workspace_id=?) AND (? IS NULL OR r.id=?)
-      AND (? IS NULL OR s.service_path=?) AND (o.operation_name=? OR o.operation_path=? OR o.operation_path=?)
-    ORDER BY r.name,s.service_path,o.operation_name,o.id`).all(workspaceId, workspaceId, repoId, repoId, start.servicePath, start.servicePath, requested, requested, requested.startsWith("/") ? requested : `/${requested}`);
-  if (rows2.length === 0) return void 0;
-  const repoCount = new Set(rows2.map((row) => String(row.repoName))).size;
-  const serviceCount = new Set(rows2.map((row) => `${String(row.repoName)}:${String(row.servicePath)}`)).size;
-  if (!repoId && repoCount > 1)
-    return { diagnostics: [ambiguousStartDiagnostic(requested, rows2, "Operation trace start matched multiple repositories; add --repo to disambiguate")] };
-  if (!start.servicePath && serviceCount > 1)
-    return { diagnostics: [ambiguousStartDiagnostic(requested, rows2, "Operation trace start matched multiple services; add --service to disambiguate")] };
-  if (rows2.length !== 1)
-    return { diagnostics: [ambiguousStartDiagnostic(requested, rows2, "Operation trace start matched multiple indexed operations")] };
-  const operationId = String(rows2[0]?.operationId);
-  const impl = implementationScope(db, operationId);
-  if (impl.edge?.status === "resolved" && impl.files.size > 0) return { files: impl.files, symbols: impl.symbolId ? /* @__PURE__ */ new Set([impl.symbolId]) : void 0, repoId: impl.repoId, operationId, diagnostics: [] };
-  const hinted = hintedImplementationSelection(
-    db,
-    impl.edge,
-    operationId,
-    hintOptions
-  );
-  if (hinted.methodId) {
-    const hintedScope = handlerScope(db, hinted.methodId);
-    if (hintedScope?.files.size) return { files: hintedScope.files, symbols: hintedScope.symbolId ? /* @__PURE__ */ new Set([hintedScope.symbolId]) : void 0, repoId: hintedScope.repoId, operationId, diagnostics: [] };
+function canonicalContextFingerprint(context) {
+  const entries = [...(context ?? /* @__PURE__ */ new Map()).entries()].map(([name, binding]) => `${JSON.stringify(name)}:${canonicalValue(binding)}`).sort(compareBinary);
+  return createHash2("sha256").update(`[${entries.join(",")}]`).digest("hex");
+}
+function evaluationScopeKey(structuralKey, context) {
+  return JSON.stringify([structuralKey, canonicalContextFingerprint(context)]);
+}
+var TraversalScopeScheduler = class {
+  #scheduled = /* @__PURE__ */ new Set();
+  #expanded = /* @__PURE__ */ new Set();
+  #structuralByEvaluation = /* @__PURE__ */ new Map();
+  #childrenByEvaluation = /* @__PURE__ */ new Map();
+  schedule(identity, parent) {
+    const state = scopeState(identity, parent);
+    this.#rememberState(state);
+    if (parent) this.#rememberState(parent);
+    const cycle = parent ? parent.ancestry.has(state.structuralKey) || this.#reachesStructural(state.evaluationKey, parent.structuralKey) : false;
+    if (parent) this.#recordEdge(parent.evaluationKey, state.evaluationKey);
+    if (cycle)
+      return { kind: "cycle", state, alreadyExpanded: this.#expanded.has(state.evaluationKey) };
+    if (this.#scheduled.has(state.evaluationKey))
+      return { kind: "converged", state, alreadyExpanded: this.#expanded.has(state.evaluationKey) };
+    this.#scheduled.add(state.evaluationKey);
+    return { kind: "scheduled", state, alreadyExpanded: false };
+  }
+  markExpanded(state) {
+    if (this.#expanded.has(state.evaluationKey)) return false;
+    this.#expanded.add(state.evaluationKey);
+    return true;
   }
-  if (impl.edge) {
-    const evidence = parseEvidence(impl.edge.evidence_json);
-    const hintDiagnostic = implementationHintDiagnostic(hinted, evidence);
-    const diagnostics = [implementationStartDiagnostic(impl.edge, evidence)];
-    return { operationId, diagnostics: hintDiagnostic ? [hintDiagnostic, ...diagnostics] : diagnostics };
+  #rememberState(state) {
+    this.#structuralByEvaluation.set(state.evaluationKey, state.structuralKey);
+  }
+  #recordEdge(parent, child) {
+    const children = this.#childrenByEvaluation.get(parent) ?? /* @__PURE__ */ new Set();
+    children.add(child);
+    this.#childrenByEvaluation.set(parent, children);
+  }
+  #reachesStructural(start, targetStructuralKey) {
+    const pending = [start];
+    const seen = /* @__PURE__ */ new Set();
+    let cursor = 0;
+    while (cursor < pending.length) {
+      const current = pending[cursor];
+      cursor += 1;
+      if (seen.has(current)) continue;
+      seen.add(current);
+      if (this.#structuralByEvaluation.get(current) === targetStructuralKey)
+        return true;
+      pending.push(...this.#childrenByEvaluation.get(current) ?? []);
+    }
+    return false;
   }
-  return { operationId, diagnostics: [{ severity: "warning", code: "trace_start_implementation_unresolved", message: "Indexed operation matched but no implementation candidate exists", resolutionStage: "implementation", resolutionStatus: "operation_without_implementation" }] };
+};
+function scopeState(identity, parent) {
+  const structuralKey = structuralScopeKey(
+    identity.workspaceId,
+    identity.repoId,
+    identity.files,
+    identity.symbolIds
+  );
+  const ancestry = new Set(parent?.ancestry ?? []);
+  ancestry.add(structuralKey);
+  return {
+    structuralKey,
+    evaluationKey: evaluationScopeKey(structuralKey, identity.context),
+    ancestry
+  };
+}
+function canonicalValue(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (typeof value === "string") return `string:${JSON.stringify(value)}`;
+  if (typeof value === "boolean") return `boolean:${String(value)}`;
+  if (typeof value === "number") return canonicalNumber(value);
+  if (typeof value === "bigint") return `bigint:${String(value)}`;
+  if (Array.isArray(value))
+    return `array:[${value.map(canonicalValue).join(",")}]`;
+  if (!isRecord8(value)) return `unsupported:${typeof value}`;
+  const entries = Object.entries(value).sort(([left], [right]) => compareBinary(left, right));
+  return `object:{${entries.map(([key, child]) => `${JSON.stringify(key)}:${canonicalValue(child)}`).join(",")}}`;
+}
+function canonicalNumber(value) {
+  if (Number.isNaN(value)) return "number:NaN";
+  if (value === Number.POSITIVE_INFINITY) return "number:Infinity";
+  if (value === Number.NEGATIVE_INFINITY) return "number:-Infinity";
+  if (Object.is(value, -0)) return "number:-0";
+  return `number:${String(value)}`;
+}
+function isRecord8(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
-function sourceFilesForStart(db, repoId, start, workspaceId) {
-  return sourceScopeForSelector(db, repoId, start, workspaceId);
+
+// src/trace/011-event-subscriber-traversal.ts
+function planEventSubscriberTransitions(db, query, scheduler, parent, depth, maxDepth) {
+  return loadEventSubscriberTransitions(db, query).map((transition) => {
+    const handler = transition.handler;
+    if (!handler) return plannedTransition(transition, "not_resolved");
+    if (depth >= maxDepth)
+      return plannedTransition(transition, "depth_limited");
+    const state = scheduler.schedule({
+      workspaceId: query.workspaceId,
+      repoId: handler.repoId,
+      files: /* @__PURE__ */ new Set([handler.sourceFile]),
+      symbolIds: /* @__PURE__ */ new Set([handler.symbolId]),
+      context: /* @__PURE__ */ new Map()
+    }, parent);
+    const bodyExpansion = state.kind === "scheduled" ? "scheduled" : state.kind === "cycle" ? "cycle_blocked" : state.alreadyExpanded ? "already_expanded" : "already_scheduled";
+    return plannedTransition(transition, bodyExpansion, state.state);
+  });
 }
-function startScope(db, start, hintOptions, workspaceId) {
-  const repos = start.repo ? reposByName(db, start.repo, workspaceId).map((row) => ({
-    id: row.id,
-    name: row.name,
-    packageName: row.package_name ?? void 0
-  })) : [];
-  if (start.repo && repos.length === 0) return {
-    selectorMatched: false,
-    startDiagnostics: [selectorRepoNotFoundDiagnostic(start.repo)]
+function plannedTransition(transition, bodyExpansion, state) {
+  return {
+    transition,
+    node: eventSubscriberNode(transition),
+    evidence: eventTransitionEvidence(transition, bodyExpansion),
+    bodyExpansion,
+    state
   };
-  if (start.repo && repos.length > 1) return {
-    selectorMatched: false,
-    startDiagnostics: [selectorRepoAmbiguousDiagnostic(start.repo, repos)]
+}
+function eventSubscriberNode(transition) {
+  const handler = transition.handler;
+  if (!handler) return {
+    id: `event_subscription:${transition.graphEdgeId}`,
+    kind: transition.targetKind,
+    label: `${transition.targetKind}:${transition.targetId}`,
+    graphEdgeId: transition.graphEdgeId
   };
-  const repo = repos[0];
-  const operationScope = operationStartScope(
-    db,
-    repo?.id,
-    start,
-    hintOptions,
-    workspaceId
+  const fileName = handler.sourceFile.split("/").at(-1) ?? handler.sourceFile;
+  return {
+    id: `symbol:${handler.symbolId}`,
+    kind: "symbol",
+    label: `${fileName}:${handler.qualifiedName}`,
+    symbolId: handler.symbolId,
+    symbolName: handler.qualifiedName,
+    qualifiedName: handler.qualifiedName,
+    sourceFile: handler.sourceFile,
+    startLine: handler.sourceLine,
+    endLine: handler.endLine,
+    repoName: handler.repoName,
+    repoId: handler.repoId
+  };
+}
+function eventTransitionEvidence(transition, bodyExpansion) {
+  return {
+    graphEdgeId: transition.graphEdgeId,
+    graphGeneration: transition.graphGeneration,
+    subscribeCallId: transition.subscribeCallId,
+    symbolCallId: transition.symbolCallId,
+    eventName: transition.eventName,
+    matchStrategy: "workspace_exact_event_name",
+    dispatchCertainty: "static_name_only",
+    associationBasis: transition.associationBasis,
+    dispatchScope: transition.dispatchScope,
+    roleSiteMatchCount: transition.roleSiteMatchCount,
+    callRole: transition.callRole,
+    factOrigin: transition.factOrigin,
+    repositoryId: transition.subscriptionRepoId,
+    repositoryName: transition.subscriptionRepoName,
+    sourceFile: transition.sourceFile,
+    sourceLine: transition.sourceLine,
+    callSiteStartOffset: transition.callSiteStartOffset,
+    callSiteEndOffset: transition.callSiteEndOffset,
+    wrapperFunction: transition.wrapperFunction,
+    handlerSymbolId: transition.handler?.symbolId,
+    handlerSourceFile: transition.handler?.sourceFile,
+    handlerSourceLine: transition.handler?.sourceLine,
+    associationStatus: transition.associationStatus ?? transition.status,
+    symbolCallResolutionStatus: transition.symbolCallResolutionStatus,
+    resolutionStatus: transition.status,
+    resolutionStrategy: transition.resolutionStrategy,
+    candidateCount: transition.candidateCount,
+    symbolCallUnresolvedReason: transition.symbolCallUnresolvedReason,
+    omittedSymbolCallUnresolvedReasonCharacterCount: transition.omittedSymbolCallUnresolvedReasonCharacterCount,
+    reasonCode: transition.reasonCode,
+    bodyExpansion,
+    cycle: bodyExpansion === "cycle_blocked" || void 0,
+    cycleReason: bodyExpansion === "cycle_blocked" ? "structural_ancestry_cycle" : void 0
+  };
+}
+function loadEventSubscriberTransitions(db, query) {
+  const rows2 = db.prepare(`SELECT ge.id graphEdgeId,ge.generation graphGeneration,
+      ge.from_id eventName,ge.status,ge.to_kind targetKind,ge.to_id targetId,
+      ge.confidence,ge.unresolved_reason unresolvedReason,ge.evidence_json evidenceJson,
+      subscribe.id subscribeCallId,subscribe.repo_id subscriptionRepoId,
+      subscribe.source_file sourceFile,subscribe.source_line sourceLine,
+      subscribe.call_site_start_offset callSiteStartOffset,
+      subscribe.call_site_end_offset callSiteEndOffset,
+      subscription_repo.name subscriptionRepoName,
+      handler.id handlerSymbolId,handler.kind handlerKind,
+      handler.qualified_name handlerQualifiedName,handler.source_file handlerSourceFile,
+      handler.start_line handlerSourceLine,handler.end_line handlerEndLine,
+      handler.start_offset handlerStartOffset,handler.end_offset handlerEndOffset,
+      handler_repo.id handlerRepoId,handler_repo.name handlerRepoName,
+      handler_repo.package_name handlerPackageName
+    FROM graph_edges ge
+    LEFT JOIN outbound_calls subscribe
+      ON subscribe.id=CAST(json_extract(ge.evidence_json,'$.subscribeCallId') AS INTEGER)
+    LEFT JOIN repositories subscription_repo
+      ON subscription_repo.id=subscribe.repo_id
+      AND subscription_repo.workspace_id=ge.workspace_id
+    LEFT JOIN symbols handler
+      ON ge.to_kind='symbol' AND handler.id=CAST(ge.to_id AS INTEGER)
+    LEFT JOIN repositories handler_repo
+      ON handler_repo.id=handler.repo_id AND handler_repo.workspace_id=ge.workspace_id
+    WHERE ge.workspace_id=? AND ge.generation=?
+      AND ge.edge_type='EVENT_SUBSCRIPTION_HANDLED_BY' AND ge.from_kind='event'
+      AND ge.from_id COLLATE BINARY=? COLLATE BINARY
+    ORDER BY COALESCE(subscription_repo.name,'') COLLATE BINARY,
+      COALESCE(subscription_repo.id,0),COALESCE(subscribe.source_file,'') COLLATE BINARY,
+      subscribe.call_site_start_offset,subscribe.call_site_end_offset,ge.id`).all(
+    query.workspaceId,
+    query.graphGeneration,
+    query.eventName
   );
-  const terminalOperationScope = operationScope && !operationScope.files && (operationScope.diagnostics ?? []).some((d) => d.resolutionStage === "operation" || d.resolutionStage === "implementation");
-  const sourceScope = operationScope?.files || terminalOperationScope ? operationScope : sourceFilesForStart(db, repo?.id, start, workspaceId);
-  const terminalSelectorScope = Boolean(sourceScope?.diagnostics?.length && !sourceScope.files);
-  const sourceFiles = sourceScope?.files;
-  const hasSelector = Boolean(
-    start.handler ?? start.operation ?? start.operationPath ?? start.servicePath
+  return rows2.flatMap((row) => {
+    const transition = transitionFromRow(row);
+    return transition ? [transition] : [];
+  });
+}
+function transitionFromRow(row) {
+  const graphEdgeId = numberValue10(row.graphEdgeId);
+  const graphGeneration2 = numberValue10(row.graphGeneration);
+  const eventName = stringValue13(row.eventName);
+  const targetId = stringValue13(row.targetId);
+  if (graphEdgeId === void 0 || graphGeneration2 === void 0 || eventName === void 0 || targetId === void 0) return void 0;
+  const evidence = parseEvidence(row.evidenceJson);
+  const handler = symbolTarget(row);
+  const status = transitionStatus(stringValue13(row.status), handler);
+  const reasonCode = status === "resolved" ? void 0 : stringValue13(evidence.reasonCode) ?? missingTargetReason(row, handler);
+  return {
+    graphEdgeId,
+    graphGeneration: graphGeneration2,
+    eventName,
+    status,
+    targetKind: targetKind(row.targetKind),
+    targetId,
+    confidence: numberValue10(row.confidence) ?? 0,
+    unresolvedReason: status === "resolved" ? void 0 : stringValue13(row.unresolvedReason) ?? reasonCode,
+    reasonCode,
+    ...associationEvidence(row, evidence),
+    handler
+  };
+}
+function associationEvidence(row, evidence) {
+  const symbolCallUnresolvedReason = stringValue13(
+    evidence.symbolCallUnresolvedReason
   );
-  if (start.servicePath && !start.operation && !start.operationPath && !start.handler)
-    return { repo, selectorMatched: false };
   return {
-    repo,
-    executionRepoId: sourceScope?.repoId ?? repo?.id,
-    sourceFiles,
-    symbolIds: sourceScope?.symbols,
-    selectorMatched: !terminalOperationScope && !terminalSelectorScope && (!hasSelector || sourceFiles !== void 0),
-    startOperationId: operationScope?.operationId,
-    startDiagnostics: operationScope?.diagnostics?.length ? operationScope.diagnostics : sourceScope?.diagnostics
+    subscribeCallId: numberValue10(row.subscribeCallId),
+    symbolCallId: numberValue10(evidence.symbolCallId),
+    roleSiteMatchCount: nonNegativeCount(evidence.roleSiteMatchCount),
+    callRole: stringValue13(evidence.callRole),
+    factOrigin: stringValue13(evidence.factOrigin),
+    associationBasis: stringValue13(evidence.associationBasis),
+    dispatchScope: stringValue13(evidence.dispatchScope),
+    subscriptionRepoId: numberValue10(row.subscriptionRepoId),
+    subscriptionRepoName: stringValue13(row.subscriptionRepoName),
+    sourceFile: stringValue13(row.sourceFile),
+    sourceLine: numberValue10(row.sourceLine),
+    callSiteStartOffset: numberValue10(row.callSiteStartOffset),
+    callSiteEndOffset: numberValue10(row.callSiteEndOffset),
+    wrapperFunction: stringValue13(evidence.wrapperFunction),
+    resolutionStrategy: stringValue13(evidence.resolutionStrategy),
+    associationStatus: stringValue13(evidence.associationStatus),
+    symbolCallResolutionStatus: stringValue13(evidence.symbolCallResolutionStatus),
+    candidateCount: nonNegativeCount(evidence.candidateCount),
+    symbolCallUnresolvedReason,
+    omittedSymbolCallUnresolvedReasonCharacterCount: symbolCallUnresolvedReason ? nonNegativeCount(evidence.omittedSymbolCallUnresolvedReasonCharacterCount) : void 0
+  };
+}
+function symbolTarget(row) {
+  const symbolId = numberValue10(row.handlerSymbolId);
+  const repoId = numberValue10(row.handlerRepoId);
+  const repoName = stringValue13(row.handlerRepoName);
+  const sourceFile = stringValue13(row.handlerSourceFile);
+  const sourceLine2 = numberValue10(row.handlerSourceLine);
+  const endLine = numberValue10(row.handlerEndLine);
+  const kind = stringValue13(row.handlerKind);
+  const qualifiedName = stringValue13(row.handlerQualifiedName);
+  if (symbolId === void 0 || repoId === void 0 || !repoName || !sourceFile || sourceLine2 === void 0 || endLine === void 0 || !kind || !qualifiedName)
+    return void 0;
+  return {
+    symbolId,
+    repoId,
+    repoName,
+    sourceFile,
+    sourceLine: sourceLine2,
+    endLine,
+    kind,
+    qualifiedName,
+    packageName: stringValue13(row.handlerPackageName),
+    startOffset: numberValue10(row.handlerStartOffset),
+    endOffset: numberValue10(row.handlerEndOffset)
   };
 }
-function handlerFilesForOperation(db, operationId) {
-  const op = db.prepare(
-    `SELECT o.operation_name operationName,o.operation_path operationPath,s.repo_id repoId
-    FROM cds_operations o JOIN cds_services s ON s.id=o.service_id WHERE o.id=?`
-  ).get(operationId);
-  if (!op) return /* @__PURE__ */ new Set();
-  const operation = normalizeOperation2(op.operationPath ?? op.operationName);
-  const rows2 = db.prepare(
-    `SELECT DISTINCT hc.source_file sourceFile,sym.id symbolId FROM handler_classes hc
-    JOIN handler_methods hm ON hm.handler_class_id=hc.id
-    LEFT JOIN symbols sym ON sym.repo_id=hc.repo_id
-      AND sym.source_file=hc.source_file
-      AND sym.qualified_name=hc.class_name || '.' || hm.method_name
-      AND sym.start_line=hm.source_line
-    WHERE hc.repo_id=?
-      AND COALESCE(json_extract(hm.decorator_resolution_json,'$.handlerKind'),
-        CASE WHEN hm.decorator_kind='Event' THEN 'event'
-          WHEN hm.decorator_kind IN ('Action','Func','On') THEN 'operation'
-          ELSE 'unsupported' END)='operation'
-      AND COALESCE(json_extract(hm.decorator_resolution_json,'$.executable'),
-        CASE WHEN hm.decorator_kind IN ('Action','Func','On')
-          THEN 1 ELSE 0 END)=1
-      AND (hm.decorator_value=? OR hm.method_name=? OR hm.decorator_value=?)`
-  ).all(op.repoId, operation, operation, op.operationName);
-  return new Set(rows2.map((row) => row.sourceFile).filter(Boolean));
+function transitionStatus(value, handler) {
+  if (value === "resolved" && handler) return "resolved";
+  return value === "ambiguous" ? "ambiguous" : "unresolved";
 }
-function implementationEdge(db, operationId) {
-  return db.prepare("SELECT * FROM graph_edges WHERE edge_type='OPERATION_IMPLEMENTED_BY_HANDLER' AND from_kind='operation' AND from_id=? ORDER BY CASE status WHEN 'resolved' THEN 0 WHEN 'ambiguous' THEN 1 ELSE 2 END,id LIMIT 1").get(operationId);
+function missingTargetReason(row, handler) {
+  return stringValue13(row.status) === "resolved" && !handler ? "subscription_handler_target_missing" : void 0;
 }
-function implementationScope(db, operationId) {
-  const edge = implementationEdge(db, operationId);
-  if (!edge || edge.status !== "resolved") return { files: /* @__PURE__ */ new Set(), edge };
-  const row = db.prepare("SELECT hc.repo_id repoId,hc.source_file sourceFile,s.id symbolId FROM handler_methods hm JOIN handler_classes hc ON hc.id=hm.handler_class_id LEFT JOIN symbols s ON s.repo_id=hc.repo_id AND s.source_file=hc.source_file AND s.qualified_name=hc.class_name || '.' || hm.method_name AND s.start_line=hm.source_line WHERE hm.id=?").get(edge.to_id);
-  if (!row || typeof row.symbolId !== "number")
-    return { repoId: row?.repoId, files: /* @__PURE__ */ new Set(), edge };
-  return { repoId: row?.repoId, files: new Set(row?.sourceFile ? [row.sourceFile] : []), symbolId: row?.symbolId, edge };
+function targetKind(value) {
+  return value === "symbol" || value === "symbol_reference" || value === "subscription_handler" ? value : "subscription_handler";
 }
-function handlerScope(db, methodId) {
-  const row = db.prepare("SELECT hc.repo_id repoId,hc.source_file sourceFile,s.id symbolId FROM handler_methods hm JOIN handler_classes hc ON hc.id=hm.handler_class_id LEFT JOIN symbols s ON s.repo_id=hc.repo_id AND s.source_file=hc.source_file AND s.qualified_name=hc.class_name || '.' || hm.method_name AND s.start_line=hm.source_line WHERE hm.id=?").get(methodId);
-  if (!row || typeof row.symbolId !== "number") return void 0;
-  return { repoId: row.repoId, files: new Set(row.sourceFile ? [row.sourceFile] : []), symbolId: row.symbolId };
+function parseEvidence(value) {
+  try {
+    const parsed = JSON.parse(String(value ?? "{}"));
+    return isRecord9(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
 }
-function traceEdgeType(call, row) {
-  if (row.to_kind === "operation" && row.edge_type === "REMOTE_CALL_RESOLVES_TO_OPERATION") return "remote_action";
-  if (row.to_kind === "operation" && row.edge_type === "LOCAL_CALL_RESOLVES_TO_OPERATION") return "local_service_call";
-  return String(call.call_type);
+function nonNegativeCount(value) {
+  const count2 = numberValue10(value);
+  return count2 === void 0 ? 0 : Math.max(0, Math.floor(count2));
 }
-function includeCall(type, options) {
-  if (!options.includeDb && type === "local_db_query") return false;
-  if (!options.includeExternal && type === "external_http") return false;
-  if (!options.includeAsync && type.startsWith("async_")) return false;
-  return true;
+function numberValue10(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function stringValue13(value) {
+  return typeof value === "string" ? value : void 0;
 }
+function isRecord9(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+// src/trace/012-trace-graph-lookups.ts
 function graphForCalls(db, callIds) {
   const map = /* @__PURE__ */ new Map();
   if (callIds.length === 0) return map;
-  const rows2 = db.prepare(
-    `SELECT * FROM graph_edges WHERE from_kind='call' AND from_id IN (${callIds.map(() => "?").join(",")}) ORDER BY id`
-  ).all(...callIds.map((id) => String(id)));
+  const rows2 = db.prepare(`SELECT * FROM graph_edges
+    WHERE from_kind='call'
+      AND from_id IN (${callIds.map(() => "?").join(",")})
+    ORDER BY id`).all(
+    ...callIds.map(String)
+  );
   for (const row of rows2) {
     const id = Number(row.from_id);
     map.set(id, [...map.get(id) ?? [], row]);
@@ -8611,92 +9544,487 @@ function graphForCalls(db, callIds) {
   return map;
 }
 function symbolNode(db, symbolId) {
-  const row = db.prepare(`SELECT s.id symbolId,s.name symbolName,s.qualified_name qualifiedName,s.source_file sourceFile,s.start_line startLine,s.end_line endLine,r.name repoName,r.id repoId FROM symbols s JOIN repositories r ON r.id=s.repo_id WHERE s.id=?`).get(symbolId);
+  const row = db.prepare(`SELECT s.id symbolId,s.name symbolName,
+    s.qualified_name qualifiedName,s.source_file sourceFile,
+    s.start_line startLine,s.end_line endLine,r.name repoName,r.id repoId
+    FROM symbols s JOIN repositories r ON r.id=s.repo_id
+    WHERE s.id=?`).get(symbolId);
   if (!row) return void 0;
-  const fileName = String(row.sourceFile ?? "").split("/").at(-1) ?? String(row.sourceFile ?? "");
-  return { id: `symbol:${symbolId}`, kind: "symbol", label: `${fileName}:${String(row.qualifiedName ?? row.symbolName)}`, ...row };
+  const sourceFile = String(row.sourceFile ?? "");
+  const fileName = sourceFile.split("/").at(-1) ?? sourceFile;
+  return {
+    id: `symbol:${symbolId}`,
+    kind: "symbol",
+    label: `${fileName}:${String(row.qualifiedName ?? row.symbolName)}`,
+    ...row
+  };
 }
 function operationNode(db, operationId) {
-  const row = db.prepare(`SELECT o.id operationId,o.operation_name operationName,o.operation_type operationType,o.operation_path operationPath,o.source_file sourceFile,o.source_line sourceLine,s.id serviceId,s.service_name serviceName,s.qualified_name qualifiedName,s.service_path servicePath,r.id repoId,r.name repoName FROM cds_operations o JOIN cds_services s ON s.id=o.service_id JOIN repositories r ON r.id=s.repo_id WHERE o.id=?`).get(operationId);
+  const row = db.prepare(`SELECT o.id operationId,o.operation_name operationName,
+    o.operation_type operationType,o.operation_path operationPath,
+    o.source_file sourceFile,o.source_line sourceLine,s.id serviceId,
+    s.service_name serviceName,s.qualified_name qualifiedName,
+    s.service_path servicePath,r.id repoId,r.name repoName
+    FROM cds_operations o JOIN cds_services s ON s.id=o.service_id
+    JOIN repositories r ON r.id=s.repo_id WHERE o.id=?`).get(
+    operationId
+  );
   if (!row) return void 0;
-  return { id: `operation:${operationId}`, kind: "operation", label: `${String(row.repoName)}:${String(row.servicePath)}${String(row.operationPath)}`, ...row };
+  return {
+    id: `operation:${operationId}`,
+    kind: "operation",
+    label: `${String(row.repoName)}:${String(row.servicePath)}${String(row.operationPath)}`,
+    ...row
+  };
+}
+
+// src/trace/013-trace-root-scopes.ts
+function createTraceRootPlan(db, scheduler, scope, requestedWorkspaceId, includeAsync) {
+  const workspaceId = resolveTraversalWorkspaceId(
+    db,
+    requestedWorkspaceId,
+    scope.repoId
+  );
+  if (workspaceId !== void 0) {
+    const lifecycle = currentFactLifecycleDiagnostic(db, workspaceId);
+    if (lifecycle) return {
+      workspaceId,
+      queue: [],
+      pendingRoots: [],
+      diagnostic: lifecycle
+    };
+  }
+  if (!scope.selectorMatched)
+    return { workspaceId, queue: [], pendingRoots: [] };
+  if (workspaceId === void 0) return {
+    workspaceId,
+    queue: [],
+    pendingRoots: [],
+    diagnostic: workspaceAmbiguityDiagnostic(db)
+  };
+  const pendingRoots = includeAsync ? rootScopes(db, workspaceId, scope) : void 0;
+  if (pendingRoots)
+    return { workspaceId, queue: [], pendingRoots };
+  return {
+    workspaceId,
+    queue: initialQueue(scheduler, workspaceId, scope),
+    pendingRoots: []
+  };
 }
-function workspaceIdForCall(db, callId) {
-  return db.prepare("SELECT r.workspace_id workspaceId FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id WHERE c.id=?").get(callId)?.workspaceId;
+function nextPendingRoot(pendingRoots, scheduler, workspaceId) {
+  while (pendingRoots.length > 0) {
+    const root = pendingRoots.shift();
+    if (!root) return void 0;
+    const context = /* @__PURE__ */ new Map();
+    const scheduled = scheduler.schedule({
+      workspaceId,
+      repoId: root.repoId,
+      files: root.files,
+      symbolIds: root.symbolIds,
+      context
+    });
+    if (scheduled.kind !== "scheduled") continue;
+    return { ...root, depth: 1, context, state: scheduled.state };
+  }
+  return void 0;
 }
-function parseEvidence(value) {
+function claimPendingRoot(pendingRoots, target) {
+  const index = pendingRoots.findIndex((root) => target.repoId === root.repoId && !root.unownedOnly && setsEqual(root.files, target.files) && setsEqual(root.symbolIds, target.symbolIds));
+  if (index < 0) return false;
+  pendingRoots.splice(index, 1);
+  return true;
+}
+function enqueueCausalScope(queue, pendingRoots, scope) {
+  if (scope.context.size === 0 && scope.files && scope.symbolIds)
+    claimPendingRoot(pendingRoots, {
+      repoId: scope.repoId,
+      files: scope.files,
+      symbolIds: scope.symbolIds
+    });
+  queue.push(scope);
+}
+function initialQueue(scheduler, workspaceId, scope) {
+  const context = /* @__PURE__ */ new Map();
+  const scheduled = scheduler.schedule({
+    workspaceId,
+    repoId: scope.repoId,
+    files: scope.files,
+    symbolIds: scope.symbolIds,
+    context
+  });
+  return scheduled.kind === "scheduled" ? [{
+    repoId: scope.repoId,
+    files: scope.files,
+    symbolIds: scope.symbolIds,
+    depth: 1,
+    context,
+    state: scheduled.state
+  }] : [];
+}
+function rootScopes(db, workspaceId, scope) {
+  if (scope.symbolIds && scope.symbolIds.size === 1) return void 0;
+  const calls = scopedRootCalls(db, workspaceId, scope);
+  if (!hasExactDispatch(db, calls)) return void 0;
+  if (scope.symbolIds && scope.symbolIds.size > 1)
+    return selectedSymbolRoots(db, workspaceId, scope.symbolIds);
+  return callOwnerRoots(calls);
+}
+function scopedRootCalls(db, workspaceId, scope) {
+  return rootCalls(db, workspaceId, scope.repoId, scope.files).filter((call) => !scope.symbolIds || typeof call.sourceSymbolId === "number" && scope.symbolIds.has(call.sourceSymbolId));
+}
+function callOwnerRoots(calls) {
+  const roots = /* @__PURE__ */ new Map();
+  for (const call of calls) {
+    const [key, root] = callOwnerRoot(call);
+    if (roots.has(key)) continue;
+    roots.set(key, root);
+  }
+  return roots.size > 0 ? [...roots.values()] : void 0;
+}
+function callOwnerRoot(call) {
+  const symbolId = call.sourceSymbolId;
+  const owned = typeof symbolId === "number";
+  const key = owned ? `symbol:${symbolId}` : `unowned:${call.repoId}:${call.sourceFile}`;
+  return [key, {
+    repoId: call.repoId,
+    files: /* @__PURE__ */ new Set([call.sourceFile]),
+    symbolIds: owned ? /* @__PURE__ */ new Set([symbolId]) : /* @__PURE__ */ new Set(),
+    unownedOnly: !owned,
+    rootObservationOnly: true
+  }];
+}
+function selectedSymbolRoots(db, workspaceId, symbolIds) {
+  const ids = [...symbolIds];
+  const rows2 = db.prepare(`SELECT s.id,s.repo_id repoId,s.source_file sourceFile
+    FROM symbols s JOIN repositories r ON r.id=s.repo_id
+    WHERE r.workspace_id=? AND s.id IN (${ids.map(() => "?").join(",")})
+    ORDER BY r.name COLLATE BINARY,r.id,s.source_file COLLATE BINARY,
+      s.start_offset,s.end_offset,s.id`).all(workspaceId, ...ids);
+  return rows2.flatMap((row) => typeof row.id === "number" && typeof row.repoId === "number" && typeof row.sourceFile === "string" ? [{
+    repoId: row.repoId,
+    files: /* @__PURE__ */ new Set([row.sourceFile]),
+    symbolIds: /* @__PURE__ */ new Set([row.id]),
+    unownedOnly: false,
+    rootObservationOnly: false
+  }] : []);
+}
+function setsEqual(left, right) {
+  if (left.size !== right.size) return false;
+  return [...left].every((value) => right.has(value));
+}
+function rootCalls(db, workspaceId, repoId, files) {
+  const rows2 = db.prepare(`SELECT c.id,c.repo_id repoId,r.name repoName,
+      r.workspace_id workspaceId,r.graph_generation graphGeneration,
+      c.source_symbol_id sourceSymbolId,c.source_file sourceFile,
+      c.call_type callType,c.event_name_expr eventName
+    FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id
+    WHERE r.workspace_id=? AND (? IS NULL OR c.repo_id=?)
+    ORDER BY r.name COLLATE BINARY,r.id,c.source_file COLLATE BINARY,
+      c.call_site_start_offset,c.call_site_end_offset,c.source_line,c.id`).all(
+    workspaceId,
+    repoId,
+    repoId
+  );
+  return files ? rows2.filter((row) => files.has(row.sourceFile)) : rows2;
+}
+function hasExactDispatch(db, calls) {
+  const match = db.prepare(`SELECT 1 matched FROM graph_edges emitted
+    WHERE emitted.workspace_id=? AND emitted.generation=?
+      AND emitted.edge_type='HANDLER_EMITS_EVENT'
+      AND emitted.from_kind='call' AND emitted.from_id=?
+      AND EXISTS (SELECT 1 FROM graph_edges subscriber
+        WHERE subscriber.workspace_id=emitted.workspace_id
+          AND subscriber.generation=emitted.generation
+          AND subscriber.edge_type='EVENT_SUBSCRIPTION_HANDLED_BY'
+          AND subscriber.from_kind='event'
+          AND subscriber.from_id COLLATE BINARY=? COLLATE BINARY)
+    LIMIT 1`);
+  return calls.some((call) => call.callType === "async_emit" && typeof call.eventName === "string" && Boolean(match.get(
+    call.workspaceId,
+    call.graphGeneration,
+    String(call.id),
+    call.eventName
+  )));
+}
+function workspaceAmbiguityDiagnostic(db) {
+  const total = Number(db.prepare(`SELECT COUNT(DISTINCT w.id) count
+    FROM workspaces w JOIN repositories r ON r.workspace_id=w.id`).get()?.count ?? 0);
+  const workspaceIds = db.prepare(`SELECT DISTINCT w.id FROM workspaces w
+    JOIN repositories r ON r.workspace_id=w.id ORDER BY w.id LIMIT 5`).all().flatMap((row) => typeof row.id === "number" ? [row.id] : []);
+  return {
+    severity: "error",
+    code: "trace_workspace_ambiguous",
+    message: total > 1 ? "Trace spans multiple indexed workspaces; provide a workspace identity." : "No indexed workspace could be selected for this trace.",
+    workspaceCount: total,
+    workspaceIds,
+    omittedWorkspaceCount: Math.max(0, total - workspaceIds.length),
+    remediation: "Pass TraceOptions.workspaceId or select a repository in one workspace."
+  };
+}
+
+// src/trace/017-trace-context.ts
+function parseTraceEvidence(value) {
   try {
     const parsed = JSON.parse(String(value || "{}"));
-    return isEvidenceRecord2(parsed) ? boundCandidateLikeEvidence(parsed) : {};
+    return isRecord10(parsed) ? boundCandidateLikeEvidence(parsed) : {};
   } catch {
     return {};
   }
 }
-function isEvidenceRecord2(value) {
-  return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-function receiverFromEvidence(value) {
-  const evidence = parseEvidence(value);
+function receiverFromTraceEvidence(value) {
+  const evidence = parseTraceEvidence(value);
   return typeof evidence.receiver === "string" ? evidence.receiver : void 0;
 }
-function hasDynamicPlaceholder(value) {
-  return extractPlaceholders(value).length > 0;
-}
-function enrichBinding(row) {
-  const effectiveServicePath = row.servicePathExpr && !hasDynamicPlaceholder(row.servicePathExpr) ? row.servicePathExpr : !row.servicePathExpr ? row.requireServicePath : void 0;
-  const effectiveDestination = row.destinationExpr && !hasDynamicPlaceholder(row.destinationExpr) ? row.destinationExpr : !row.destinationExpr ? row.requireDestination : void 0;
-  return { ...row, effectiveServicePath, effectiveDestination };
-}
 function knownBindingsForCalls(db, calls) {
   const map = /* @__PURE__ */ new Map();
-  for (const call of calls) {
-    const receiver = receiverFromEvidence(call.evidence_json);
-    const bindingId = Number(call.service_binding_id ?? 0);
-    if (!receiver || !bindingId) continue;
-    const row = db.prepare(`SELECT b.id,b.alias,b.alias_expr aliasExpr,b.destination_expr destinationExpr,b.service_path_expr servicePathExpr,b.source_file sourceFile,b.source_line sourceLine,req.service_path requireServicePath,req.destination requireDestination
-      FROM service_bindings b LEFT JOIN cds_requires req ON req.repo_id=b.repo_id AND req.alias=b.alias
-      WHERE b.id=?`).get(bindingId);
-    if (row) map.set(receiver, enrichBinding({ ...row, bindingId, source: "local_service_binding", calleeReceiver: receiver }));
-  }
+  for (const call of calls) addCallBinding(db, map, call);
   return map;
 }
 function knownBindingsForScope(db, repoId, symbolIds, files) {
   const map = /* @__PURE__ */ new Map();
   if (repoId === void 0) return map;
-  const rows2 = db.prepare(`SELECT b.id,b.symbol_id symbolId,b.variable_name variableName,b.alias,b.alias_expr aliasExpr,b.destination_expr destinationExpr,b.service_path_expr servicePathExpr,b.source_file sourceFile,b.source_line sourceLine,req.service_path requireServicePath,req.destination requireDestination
-    FROM service_bindings b LEFT JOIN cds_requires req ON req.repo_id=b.repo_id AND req.alias=b.alias
-    WHERE b.repo_id=?`).all(repoId);
-  for (const row of rows2) {
-    if (!row.variableName) continue;
-    if (files && !files.has(String(row.sourceFile))) continue;
-    if (symbolIds && symbolIds.size > 0 && row.symbolId != null && !symbolIds.has(Number(row.symbolId))) continue;
-    const candidate = enrichBinding({
-      ...row,
-      bindingId: Number(row.id),
-      source: "local_service_binding",
-      calleeReceiver: row.variableName,
-      resolutionStatus: "selected"
-    });
-    const existing = map.get(row.variableName);
-    if (!existing) {
-      map.set(row.variableName, candidate);
-      continue;
+  const rows2 = db.prepare(`SELECT b.id,b.symbol_id symbolId,
+      b.variable_name variableName,b.alias,b.alias_expr aliasExpr,
+      b.destination_expr destinationExpr,b.service_path_expr servicePathExpr,
+      b.source_file sourceFile,b.source_line sourceLine,
+      req.service_path requireServicePath,req.destination requireDestination
+    FROM service_bindings b LEFT JOIN cds_requires req
+      ON req.repo_id=b.repo_id AND req.alias=b.alias
+    WHERE b.repo_id=?
+    ORDER BY b.source_file COLLATE BINARY,b.source_line,b.id`).all(
+    repoId
+  );
+  for (const row of rows2) addScopeBinding(map, row, symbolIds, files);
+  return map;
+}
+function contextForSymbolCall(db, symbolCall, callerBindings) {
+  const next = /* @__PURE__ */ new Map();
+  if (callerBindings.size === 0) return next;
+  const context = symbolCallContext(db, symbolCall);
+  context.args.forEach((argument, index) => addArgumentBindings(
+    next,
+    callerBindings,
+    context,
+    argument,
+    index
+  ));
+  return next;
+}
+function addCallBinding(db, map, call) {
+  const receiver = receiverFromTraceEvidence(call.evidence_json);
+  const bindingId = Number(call.service_binding_id ?? 0);
+  if (!receiver || !bindingId) return;
+  const row = db.prepare(`SELECT b.id,b.alias,b.alias_expr aliasExpr,
+      b.destination_expr destinationExpr,b.service_path_expr servicePathExpr,
+      b.source_file sourceFile,b.source_line sourceLine,
+      req.service_path requireServicePath,req.destination requireDestination
+    FROM service_bindings b LEFT JOIN cds_requires req
+      ON req.repo_id=b.repo_id AND req.alias=b.alias WHERE b.id=?`).get(
+    bindingId
+  );
+  if (row) map.set(receiver, enrichBinding({
+    ...row,
+    bindingId,
+    source: "local_service_binding",
+    calleeReceiver: receiver
+  }));
+}
+function addScopeBinding(map, row, symbolIds, files) {
+  if (!row.variableName) return;
+  if (files && !files.has(String(row.sourceFile))) return;
+  if (symbolIds?.size && row.symbolId != null && !symbolIds.has(Number(row.symbolId))) return;
+  const candidate = enrichBinding({
+    ...row,
+    bindingId: Number(row.id),
+    source: "local_service_binding",
+    calleeReceiver: row.variableName,
+    resolutionStatus: "selected"
+  });
+  const existing = map.get(row.variableName);
+  if (!existing) {
+    map.set(row.variableName, candidate);
+    return;
+  }
+  map.set(row.variableName, ambiguousBinding(existing, candidate));
+}
+function ambiguousBinding(existing, candidate) {
+  const bindingCandidates2 = uniqueBindingCandidates([
+    ...existing.bindingCandidates ?? [bindingEvidence3(existing)],
+    bindingEvidence3(candidate)
+  ]);
+  return {
+    ...candidate,
+    bindingId: void 0,
+    source: "ambiguous_local_service_bindings",
+    resolutionStatus: "ambiguous",
+    bindingCandidates: bindingCandidates2
+  };
+}
+function symbolCallContext(db, symbolCall) {
+  const callEvidence = parseTraceEvidence(symbolCall.evidence_json);
+  const callee = db.prepare(`SELECT evidence_json evidenceJson,
+    source_file sourceFile,start_line startLine FROM symbols WHERE id=?`).get(
+    symbolCall.callee_symbol_id
+  );
+  const evidence = parseTraceEvidence(callee?.evidenceJson);
+  return {
+    args: recordArray6(callEvidence.callArguments),
+    params: stringArray6(evidence.parameters),
+    parameterBindings: recordArray6(evidence.parameterBindings),
+    parameterPropertyAliases: recordArray6(evidence.parameterPropertyAliases),
+    provenance: {
+      callerSite: {
+        sourceFile: String(symbolCall.source_file ?? ""),
+        sourceLine: Number(symbolCall.source_line ?? 0)
+      },
+      calleeSite: { sourceFile: callee?.sourceFile, sourceLine: callee?.startLine }
     }
-    const candidates2 = uniqueBindingCandidates([
-      ...existing.bindingCandidates ?? [bindingCandidateEvidence(existing)],
-      bindingCandidateEvidence(candidate)
-    ]);
-    map.set(row.variableName, {
-      ...candidate,
-      bindingId: void 0,
-      source: "ambiguous_local_service_bindings",
-      resolutionStatus: "ambiguous",
-      bindingCandidates: candidates2
+  };
+}
+function addArgumentBindings(next, caller, context, argument, index) {
+  const parameterBinding = context.parameterBindings.find(
+    (binding) => binding.index === index
+  );
+  const parameter = parameterBinding?.kind === "identifier" && typeof parameterBinding.name === "string" ? parameterBinding.name : context.params[index];
+  addIdentifierBinding(next, caller, context.provenance, argument, parameter);
+  addObjectBindings(next, caller, context, argument, parameterBinding, parameter, index);
+  addArrayBindings(next, caller, context.provenance, argument, parameterBinding, index);
+}
+function addIdentifierBinding(next, caller, provenance, argument, parameter) {
+  if (argument.kind !== "identifier" || typeof argument.name !== "string" || !parameter) return;
+  const binding = caller.get(argument.name);
+  if (binding) next.set(parameter, {
+    ...binding,
+    ...provenance,
+    source: "local_symbol_argument",
+    callerArgument: argument.name,
+    calleeParameter: parameter,
+    calleeReceiver: parameter
+  });
+}
+function addObjectBindings(next, caller, context, argument, parameterBinding, parameter, index) {
+  if (argument.kind !== "object_literal" || !Array.isArray(argument.properties)) return;
+  for (const property of recordArray6(argument.properties)) addObjectPropertyBinding(
+    next,
+    caller,
+    context,
+    property,
+    parameterBinding,
+    parameter,
+    index
+  );
+}
+function addObjectPropertyBinding(next, caller, context, property, parameterBinding, parameter, index) {
+  if (typeof property.property !== "string" || typeof property.argument !== "string") return;
+  const binding = caller.get(property.argument);
+  if (!binding) return;
+  const local = objectPatternLocal(parameterBinding, property.property);
+  if (local) {
+    next.set(local, objectBinding(
+      binding,
+      context.provenance,
+      property.property,
+      property.argument,
+      String(index),
+      local,
+      "local_symbol_destructured_object_argument"
+    ));
+    return;
+  }
+  if (!parameter) return;
+  const receiver = `${parameter}.${property.property}`;
+  next.set(receiver, objectBinding(
+    binding,
+    context.provenance,
+    property.property,
+    property.argument,
+    parameter,
+    receiver,
+    "local_symbol_object_argument"
+  ));
+  addObjectAliases(next, binding, context, property, parameter, receiver);
+}
+function addObjectAliases(next, binding, context, property, parameter, receiver) {
+  for (const alias of context.parameterPropertyAliases) {
+    if (alias.parameter !== parameter || alias.property !== property.property || typeof alias.local !== "string") continue;
+    next.set(alias.local, {
+      ...objectBinding(
+        binding,
+        context.provenance,
+        String(property.property),
+        String(property.argument),
+        parameter,
+        alias.local,
+        "local_symbol_object_parameter_destructure"
+      ),
+      calleeObjectProperty: receiver,
+      calleeLocalDestructuredIdentifier: alias.local,
+      parameterPropertyAliasKind: alias.kind,
+      parameterPropertyAliasLine: alias.line
     });
   }
-  return map;
 }
-function bindingCandidateEvidence(binding) {
+function addArrayBindings(next, caller, provenance, argument, parameterBinding, index) {
+  const arrays = arrayPattern(argument, parameterBinding);
+  if (!arrays) return;
+  for (const element of arrays.elements)
+    addArrayElement(next, caller, provenance, element, arrays.targets, index);
+}
+function arrayPattern(argument, binding) {
+  if (argument.kind !== "array_literal") return void 0;
+  if (!Array.isArray(argument.elements)) return void 0;
+  if (binding?.kind !== "array_pattern") return void 0;
+  if (!Array.isArray(binding.elements)) return void 0;
+  return {
+    elements: recordArray6(argument.elements),
+    targets: recordArray6(binding.elements)
+  };
+}
+function addArrayElement(next, caller, provenance, element, targets, index) {
+  if (element.kind !== "identifier" || typeof element.name !== "string") return;
+  const target = targets.find((item) => item.index === element.index);
+  if (typeof target?.local !== "string") return;
+  const binding = caller.get(element.name);
+  if (binding) next.set(target.local, {
+    ...binding,
+    ...provenance,
+    source: "local_symbol_destructured_array_argument",
+    callerArgument: element.name,
+    calleeParameter: String(index),
+    calleeReceiver: target.local
+  });
+}
+function objectPatternLocal(binding, property) {
+  if (binding?.kind !== "object_pattern" || !Array.isArray(binding.properties)) return void 0;
+  const match = recordArray6(binding.properties).find(
+    (item) => item.property === property && typeof item.local === "string"
+  );
+  return typeof match?.local === "string" ? match.local : void 0;
+}
+function objectBinding(binding, provenance, callerProperty, callerArgument, parameter, receiver, source) {
+  return {
+    ...binding,
+    ...provenance,
+    source,
+    callerProperty,
+    callerArgument,
+    calleeParameter: parameter,
+    calleeReceiver: receiver
+  };
+}
+function enrichBinding(row) {
+  const servicePath = row.servicePathExpr && !hasPlaceholder(row.servicePathExpr) ? row.servicePathExpr : !row.servicePathExpr ? row.requireServicePath : void 0;
+  const destination = row.destinationExpr && !hasPlaceholder(row.destinationExpr) ? row.destinationExpr : !row.destinationExpr ? row.requireDestination : void 0;
+  return {
+    ...row,
+    effectiveServicePath: servicePath,
+    effectiveDestination: destination
+  };
+}
+function hasPlaceholder(value) {
+  return extractPlaceholders(value).length > 0;
+}
+function bindingEvidence3(binding) {
   return {
     bindingId: binding.bindingId,
     sourceFile: binding.sourceFile,
@@ -8707,74 +10035,672 @@ function bindingCandidateEvidence(binding) {
     servicePathExpr: binding.servicePathExpr
   };
 }
-function uniqueBindingCandidates(candidates2) {
-  const seen = /* @__PURE__ */ new Set();
-  return candidates2.filter((candidate) => {
-    const key = JSON.stringify(candidate);
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
+function uniqueBindingCandidates(candidates2) {
+  const seen = /* @__PURE__ */ new Set();
+  return candidates2.filter((candidate) => {
+    const key = JSON.stringify(candidate);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function recordArray6(value) {
+  return Array.isArray(value) ? value.filter(isRecord10) : [];
+}
+function stringArray6(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function isRecord10(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+// src/trace/015-trace-edge-recorder.ts
+var nonResolvedGraphStatuses = {
+  ambiguous: "ambiguous",
+  dynamic: "dynamic",
+  terminal: "terminal"
+};
+var TraceEdgeRecorder = class {
+  constructor(edges, observer) {
+    this.edges = edges;
+    this.observer = observer;
+  }
+  edges;
+  observer;
+  record(edge, semantics) {
+    const ordinal = this.edges.length;
+    this.edges.push(edge);
+    this.observer?.record(observation(ordinal, edge, semantics));
+    return ordinal;
+  }
+  unavailable(side, endpointKind) {
+    return {
+      kind: "unavailable",
+      side,
+      endpointKind,
+      detailedEdgeIndex: this.edges.length
+    };
+  }
+};
+function semanticCallSource(call, workspaceId) {
+  const symbolId = positiveNumber(call.source_symbol_id);
+  if (symbolId !== void 0) return { kind: "symbol", symbolId };
+  return {
+    kind: "call_site",
+    workspaceId,
+    repositoryId: call.repo_id,
+    repositoryName: call.repoName,
+    sourceFile: call.source_file,
+    sourceLine: call.source_line,
+    startOffset: finiteNumber(call.call_site_start_offset),
+    endOffset: finiteNumber(call.call_site_end_offset),
+    callId: call.id
+  };
+}
+function semanticOperation(value, unavailable) {
+  const operationId = positiveNumber(value);
+  return operationId === void 0 ? unavailable() : { kind: "operation", operationId };
+}
+function semanticSymbol(value, unavailable) {
+  const symbolId = positiveNumber(value);
+  return symbolId === void 0 ? unavailable() : { kind: "symbol", symbolId };
+}
+function semanticHandler(methodIdValue, symbolIdValue, unavailable) {
+  const symbolId = positiveNumber(symbolIdValue);
+  if (symbolId !== void 0) return { kind: "symbol", symbolId };
+  const handlerMethodId = positiveNumber(methodIdValue);
+  return handlerMethodId === void 0 ? unavailable() : { kind: "handler_method", handlerMethodId };
+}
+function semanticGraphTarget(row, call, workspaceId, unavailable) {
+  if (row.to_kind === "event") return {
+    kind: "event",
+    workspaceId,
+    eventName: typeof call.event_name_expr === "string" ? call.event_name_expr : row.to_id
+  };
+  const id = positiveNumber(row.to_id);
+  if (row.to_kind === "operation")
+    return id === void 0 ? unavailable() : { kind: "operation", operationId: id };
+  if (row.to_kind === "symbol")
+    return id === void 0 ? unavailable() : { kind: "symbol", symbolId: id };
+  if (row.to_kind === "handler_method") return id === void 0 ? unavailable() : { kind: "handler_method", handlerMethodId: id };
+  return {
+    kind: "target",
+    workspaceId,
+    repositoryId: positiveNumber(call.repo_id),
+    targetKind: row.to_kind,
+    targetId: row.to_id
+  };
+}
+function semanticScopeTarget(workspaceId, repositoryId, sourceFiles, symbolIds, structuralKey) {
+  return {
+    kind: "scope",
+    workspaceId,
+    repositoryId,
+    sourceFiles: [...sourceFiles ?? []],
+    symbolIds: [...symbolIds ?? []],
+    structuralKey
+  };
+}
+function compactGraphStatus(row, evidence, unresolvedReason, dynamicMode2) {
+  const effective = recordValue2(evidence.effectiveResolution);
+  const status = stringValue14(effective.status) ?? row.status ?? "unresolved";
+  if (status !== "resolved")
+    return nonResolvedGraphStatuses[status] ?? "unresolved";
+  if (unresolvedReason) return "unresolved";
+  const inference = recordValue2(evidence.dynamicTargetInference);
+  if (isDynamicInference(dynamicMode2, inference)) return "dynamic";
+  return traversableTargetKind(row.to_kind) ? "resolved" : "terminal";
+}
+function isDynamicInference(mode, evidence) {
+  return mode === "infer" && evidence.status === "resolved";
+}
+function traversableTargetKind(kind) {
+  return ["operation", "symbol", "handler_method"].includes(kind);
+}
+function compactResolutionStatus(status, unresolvedReason) {
+  if (status === "ambiguous") return "ambiguous";
+  if (status === "dynamic") return "dynamic";
+  return status === "resolved" && !unresolvedReason ? "resolved" : "unresolved";
+}
+function compactEventStatus(status, bodyExpansion) {
+  if (bodyExpansion === "cycle_blocked") return "cycle";
+  if (status === "ambiguous") return "ambiguous";
+  return status === "resolved" ? "inferred" : "unresolved";
+}
+function compactDecisionFromEvidence(evidence, overrides = {}) {
+  const effective = recordValue2(evidence.effectiveResolution);
+  const persisted = recordValue2(evidence.persistedResolution);
+  const dynamic = recordValue2(evidence.dynamicTargetExploration);
+  const implementation = recordValue2(evidence.implementationSelection);
+  const missing = stringArray7(dynamic.missingVariables ?? evidence.missingRuntimeVariables);
+  const authoritativeMissingCount = finiteNumber(
+    dynamic.missingVariableCount ?? evidence.missingVariableCount
+  );
+  return {
+    effectiveResolutionStatus: stringValue14(effective.status),
+    effectiveTarget: targetSummary(effective),
+    persistedResolutionStatus: stringValue14(persisted.status),
+    persistedTarget: targetSummary(persisted),
+    missingVariableNames: missing.length > 0 ? missing : void 0,
+    missingVariableCount: authoritativeMissingCount ?? (missing.length > 0 ? missing.length : void 0),
+    dynamicMode: dynamicMode(dynamic.mode),
+    candidateCount: firstNumber(
+      dynamic.candidateCount,
+      implementation.candidateCount,
+      implementation.candidateScoreCount,
+      evidence.candidateCount,
+      evidence.persistedCandidateCount
+    ),
+    viableCandidateCount: finiteNumber(dynamic.viableCandidateCount),
+    rejectedCandidateCount: finiteNumber(dynamic.rejectedCandidateCount),
+    omittedCandidateCount: finiteNumber(dynamic.omittedCandidateCount),
+    implementationStrategy: stringValue14(implementation.strategy),
+    implementationGuided: booleanValue(implementation.guided),
+    implementationContextual: booleanValue(
+      evidence.contextualImplementationSelected
+    ),
+    reasonCode: stringValue14(evidence.reasonCode ?? evidence.cycleReason),
+    eventMatchStrategy: stringValue14(evidence.matchStrategy),
+    dispatchCertainty: stringValue14(evidence.dispatchCertainty),
+    associationStatus: stringValue14(evidence.associationStatus),
+    associationBasis: stringValue14(evidence.associationBasis),
+    eventScope: stringValue14(evidence.dispatchScope),
+    callRole: stringValue14(evidence.callRole),
+    factOrigin: stringValue14(evidence.factOrigin),
+    roleSiteMatchCount: finiteNumber(evidence.roleSiteMatchCount),
+    bodyExpansion: stringValue14(evidence.bodyExpansion),
+    ...overrides
+  };
+}
+function compactRefs(values) {
+  return {
+    graphEdgeIds: reference(values.graphEdgeId),
+    outboundCallIds: reference(values.outboundCallId),
+    subscribeCallIds: reference(values.subscribeCallId),
+    symbolCallIds: reference(values.symbolCallId),
+    operationIds: reference(values.operationId),
+    symbolIds: reference(values.symbolId),
+    handlerMethodIds: reference(values.handlerMethodId)
+  };
+}
+function compactSite(values) {
+  return {
+    repository: stringValue14(values.repository ?? values.repoName),
+    sourceFile: stringValue14(values.sourceFile ?? values.source_file),
+    sourceLine: finiteNumber(values.sourceLine ?? values.source_line),
+    startOffset: finiteNumber(values.startOffset ?? values.call_site_start_offset),
+    endOffset: finiteNumber(values.endOffset ?? values.call_site_end_offset)
+  };
+}
+function observation(ordinal, edge, semantics) {
+  return {
+    ordinal,
+    step: edge.step,
+    type: edge.type,
+    source: semantics.source,
+    target: semantics.target,
+    status: semantics.status,
+    confidence: edge.confidence,
+    decision: semantics.decision,
+    refs: semantics.refs,
+    site: semantics.site
+  };
+}
+function targetSummary(value) {
+  const kind = stringValue14(value.targetKind);
+  const id = stringValue14(value.targetId);
+  return kind && id ? { kind, id } : void 0;
+}
+function reference(value) {
+  if (typeof value === "string" && value.length > 0) {
+    const numeric2 = Number(value);
+    if (Number.isSafeInteger(numeric2)) return numeric2 > 0 ? [numeric2] : void 0;
+    return [value];
+  }
+  const number = finiteNumber(value);
+  return number === void 0 || number <= 0 ? void 0 : [number];
+}
+function dynamicMode(value) {
+  return value === "strict" || value === "candidates" || value === "infer" ? value : void 0;
+}
+function recordValue2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function stringArray7(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function stringValue14(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function finiteNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value !== "string" || value.trim() === "") return void 0;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function positiveNumber(value) {
+  const number = finiteNumber(value);
+  return number !== void 0 && number > 0 ? number : void 0;
+}
+function booleanValue(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function firstNumber(...values) {
+  for (const value of values) {
+    const numeric2 = finiteNumber(value);
+    if (numeric2 !== void 0) return numeric2;
+  }
+  return void 0;
+}
+
+// src/trace/019-trace-edge-semantics.ts
+function recordImplementationObservation(recorder, edge, input) {
+  const target = semanticHandler(
+    input.handlerMethodId,
+    input.handlerSymbolId,
+    () => recorder.unavailable("target", "selected_handler")
+  );
+  recorder.record(edge, {
+    source: semanticOperation(
+      input.operationId,
+      () => recorder.unavailable("source", "operation")
+    ),
+    target,
+    status: compactResolutionStatus(input.effectiveStatus, input.unresolvedReason),
+    decision: compactDecisionFromEvidence(input.evidence, {
+      effectiveResolutionStatus: input.unresolvedReason ? "unresolved" : input.effectiveStatus,
+      effectiveTarget: decisionTarget(target),
+      persistedResolutionStatus: input.persistedStatus,
+      persistedTarget: input.persistedTargetKind && input.persistedTargetId ? { kind: input.persistedTargetKind, id: input.persistedTargetId } : void 0,
+      implementationStrategy: input.strategy,
+      implementationGuided: input.guided,
+      implementationContextual: input.contextual,
+      reasonCode: input.unresolvedReason ? "selected_handler_unavailable" : void 0
+    }),
+    refs: compactRefs({
+      graphEdgeId: input.graphEdgeId,
+      operationId: input.operationId,
+      handlerMethodId: input.handlerMethodId,
+      symbolId: input.handlerSymbolId
+    }),
+    site: compactSite(input.site)
+  });
+}
+function recordLocalCallObservation(recorder, edge, input) {
+  const source = semanticSymbol(
+    input.symbolCall.caller_symbol_id,
+    () => recorder.unavailable("source", "caller_symbol")
+  );
+  const target = semanticSymbol(
+    input.symbolCall.callee_symbol_id,
+    () => recorder.unavailable("target", "callee_symbol")
+  );
+  recorder.record(edge, {
+    source,
+    target,
+    status: compactResolutionStatus(
+      input.symbolCall.status,
+      input.unresolvedReason
+    ),
+    decision: compactDecisionFromEvidence(input.evidence, {
+      effectiveResolutionStatus: String(input.symbolCall.status),
+      reasonCode: input.unresolvedReason ? "symbol_call_unresolved" : void 0
+    }),
+    refs: {
+      symbolCallIds: idArray(input.symbolCall.id),
+      symbolIds: idArray(
+        input.symbolCall.caller_symbol_id,
+        input.symbolCall.callee_symbol_id
+      )
+    },
+    site: compactSite(input.symbolCall)
+  });
+  return target;
+}
+function recordCycleObservation(recorder, edge, source, scope, refs, site) {
+  recorder.record(edge, {
+    source,
+    target: scope.workspaceId === void 0 ? recorder.unavailable("target", "cycle_scope") : semanticScopeTarget(
+      scope.workspaceId,
+      scope.repositoryId,
+      scope.sourceFiles,
+      scope.symbolIds,
+      scope.structuralKey
+    ),
+    status: "cycle",
+    decision: compactDecisionFromEvidence(edge.evidence, {
+      reasonCode: "structural_ancestry_cycle"
+    }),
+    refs: compactRefs(refs),
+    site: compactSite(site)
+  });
+}
+function recordOutboundObservation(recorder, edge, input) {
+  const source = semanticCallSource(input.call, input.workspaceId);
+  const target = semanticGraphTarget(
+    input.row,
+    input.call,
+    input.workspaceId,
+    () => recorder.unavailable("target", input.row.to_kind)
+  );
+  recorder.record(edge, {
+    source,
+    target,
+    status: compactGraphStatus(
+      input.row,
+      input.evidence,
+      input.unresolvedReason,
+      input.dynamicMode
+    ),
+    decision: compactDecisionFromEvidence(input.evidence, {
+      reasonCode: input.unresolvedReason ? safeReasonCode(input.evidence.reasonCode, "outbound_target_unresolved") : void 0
+    }),
+    refs: compactRefs({
+      graphEdgeId: positiveId(input.evidence.persistedGraphEdgeId),
+      outboundCallId: input.call.id,
+      operationId: input.row.to_kind === "operation" ? input.row.to_id : void 0,
+      symbolId: input.call.source_symbol_id
+    }),
+    site: compactSite(input.call)
+  });
+  return { source, target };
+}
+function recordEventBridgeObservation(recorder, edge, plan, workspaceId, subscriptionCount) {
+  const handler = plan.transition.handler;
+  const target = handler ? { kind: "symbol", symbolId: handler.symbolId } : {
+    kind: "target",
+    workspaceId,
+    repositoryId: plan.transition.subscriptionRepoId,
+    targetKind: plan.transition.targetKind,
+    targetId: plan.transition.targetId
+  };
+  recorder.record(edge, {
+    source: {
+      kind: "event",
+      workspaceId,
+      eventName: plan.transition.eventName
+    },
+    target,
+    status: compactEventStatus(plan.transition.status, plan.bodyExpansion),
+    decision: compactDecisionFromEvidence(plan.evidence, {
+      eventSubscriptionCount: subscriptionCount,
+      reasonCode: plan.transition.reasonCode
+    }),
+    refs: eventReferences(plan),
+    site: eventSite(plan)
+  });
+  return target;
+}
+function recordEventCycleObservation(recorder, edge, plan, source, workspaceId) {
+  const handler = plan.transition.handler;
+  if (!plan.state) return;
+  recorder.record(edge, {
+    source,
+    target: semanticScopeTarget(
+      workspaceId,
+      handler?.repoId,
+      handler ? /* @__PURE__ */ new Set([handler.sourceFile]) : void 0,
+      handler ? /* @__PURE__ */ new Set([handler.symbolId]) : void 0,
+      plan.state.structuralKey
+    ),
+    status: "cycle",
+    decision: compactDecisionFromEvidence(edge.evidence, {
+      reasonCode: "structural_ancestry_cycle",
+      dispatchCertainty: "static_name_only"
+    }),
+    refs: eventReferences(plan),
+    site: eventSite(plan)
+  });
+}
+function recordDynamicBranchObservation(recorder, branch, call, source, evidence, workspaceId) {
+  const target = dynamicBranchTarget(recorder, branch, workspaceId);
+  recorder.record(branch.edge, {
+    source,
+    target,
+    status: "dynamic",
+    decision: compactDecisionFromEvidence(evidence, {
+      dynamicMode: "candidates",
+      effectiveTarget: branch.operationId === void 0 ? void 0 : { kind: "operation", id: String(branch.operationId) },
+      remediationCode: "provide_runtime_variables"
+    }),
+    refs: compactRefs({
+      graphEdgeId: positiveId(evidence.persistedGraphEdgeId),
+      outboundCallId: call.id,
+      operationId: branch.operationId,
+      symbolId: call.source_symbol_id
+    }),
+    site: compactSite(call)
+  });
+}
+function dynamicBranchTarget(recorder, branch, workspaceId) {
+  if (branch.operationId !== void 0)
+    return { kind: "operation", operationId: branch.operationId };
+  if (branch.servicePath && branch.operationPath) return {
+    kind: "target",
+    workspaceId,
+    repositoryId: branch.repositoryId,
+    targetKind: "dynamic_operation_candidate",
+    targetId: JSON.stringify([branch.servicePath, branch.operationPath])
+  };
+  return recorder.unavailable("target", "dynamic_operation_candidate");
+}
+function eventReferences(plan) {
+  return compactRefs({
+    graphEdgeId: plan.transition.graphEdgeId,
+    subscribeCallId: plan.transition.subscribeCallId,
+    symbolCallId: plan.transition.symbolCallId,
+    symbolId: plan.transition.handler?.symbolId
+  });
+}
+function eventSite(plan) {
+  return compactSite({
+    repository: plan.transition.subscriptionRepoName,
+    sourceFile: plan.transition.sourceFile,
+    sourceLine: plan.transition.sourceLine,
+    startOffset: plan.transition.callSiteStartOffset,
+    endOffset: plan.transition.callSiteEndOffset
+  });
+}
+function safeReasonCode(value, fallback) {
+  return typeof value === "string" && /^[a-z][a-z0-9_.-]{0,79}$/.test(value) ? value : fallback;
+}
+function positiveId(value) {
+  if (typeof value === "number") return Number.isFinite(value) && value > 0 ? value : void 0;
+  if (typeof value !== "string" || value.length === 0) return void 0;
+  const numeric2 = Number(value);
+  if (Number.isSafeInteger(numeric2)) return numeric2 > 0 ? numeric2 : void 0;
+  return value;
+}
+function idArray(...values) {
+  const ids = values.flatMap((value) => {
+    const id = positiveId(value);
+    return id === void 0 ? [] : [id];
+  });
+  return ids.length > 0 ? ids : void 0;
+}
+function decisionTarget(endpoint) {
+  if (endpoint.kind === "symbol")
+    return { kind: "symbol", id: String(endpoint.symbolId) };
+  if (endpoint.kind === "handler_method")
+    return { kind: "handler_method", id: String(endpoint.handlerMethodId) };
+  return void 0;
+}
+
+// src/trace/trace-engine.ts
+var compactObserverKey = /* @__PURE__ */ Symbol("service-flow.compact-trace-observer");
+function compactObserver(options) {
+  const observed = options;
+  return observed[compactObserverKey];
+}
+function normalizeOperation2(value) {
+  if (!value) return void 0;
+  return value.startsWith("/") ? value.slice(1) : value;
+}
+function positiveDepth(value) {
+  return Number.isFinite(value) && value > 0 ? Math.floor(value) : 25;
+}
+function operationStartScope(db, repoId, start, hintOptions, workspaceId) {
+  const requested = normalizeOperation2(start.operationPath ?? start.operation);
+  if (!requested) return void 0;
+  const rows2 = db.prepare(`SELECT o.id operationId,o.operation_name operationName,o.operation_path operationPath,o.source_file sourceFile,o.source_line sourceLine,s.service_path servicePath,r.id repoId,r.name repoName
+    FROM cds_operations o JOIN cds_services s ON s.id=o.service_id JOIN repositories r ON r.id=s.repo_id
+    WHERE (? IS NULL OR r.workspace_id=?) AND (? IS NULL OR r.id=?)
+      AND (? IS NULL OR s.service_path=?) AND (o.operation_name=? OR o.operation_path=? OR o.operation_path=?)
+    ORDER BY r.name,s.service_path,o.operation_name,o.id`).all(workspaceId, workspaceId, repoId, repoId, start.servicePath, start.servicePath, requested, requested, requested.startsWith("/") ? requested : `/${requested}`);
+  if (rows2.length === 0) return void 0;
+  const repoCount = new Set(rows2.map((row) => String(row.repoName))).size;
+  const serviceCount = new Set(rows2.map((row) => `${String(row.repoName)}:${String(row.servicePath)}`)).size;
+  if (!repoId && repoCount > 1)
+    return { diagnostics: [ambiguousStartDiagnostic(requested, rows2, "Operation trace start matched multiple repositories; add --repo to disambiguate")] };
+  if (!start.servicePath && serviceCount > 1)
+    return { diagnostics: [ambiguousStartDiagnostic(requested, rows2, "Operation trace start matched multiple services; add --service to disambiguate")] };
+  if (rows2.length !== 1)
+    return { diagnostics: [ambiguousStartDiagnostic(requested, rows2, "Operation trace start matched multiple indexed operations")] };
+  const operationId = String(rows2[0]?.operationId);
+  const impl = implementationScope(db, operationId);
+  if (impl.edge?.status === "resolved" && impl.files.size > 0) return { files: impl.files, symbols: impl.symbolId ? /* @__PURE__ */ new Set([impl.symbolId]) : void 0, repoId: impl.repoId, operationId, diagnostics: [] };
+  const hinted = hintedImplementationSelection(
+    db,
+    impl.edge,
+    operationId,
+    hintOptions
+  );
+  if (hinted.methodId) {
+    const hintedScope = handlerScope(db, hinted.methodId);
+    if (hintedScope?.files.size) return { files: hintedScope.files, symbols: hintedScope.symbolId ? /* @__PURE__ */ new Set([hintedScope.symbolId]) : void 0, repoId: hintedScope.repoId, operationId, diagnostics: [] };
+  }
+  if (impl.edge) {
+    const evidence = parseTraceEvidence(impl.edge.evidence_json);
+    const hintDiagnostic = implementationHintDiagnostic(hinted, evidence);
+    const diagnostics = [implementationStartDiagnostic(impl.edge, evidence)];
+    return { operationId, diagnostics: hintDiagnostic ? [hintDiagnostic, ...diagnostics] : diagnostics };
+  }
+  return { operationId, diagnostics: [{ severity: "warning", code: "trace_start_implementation_unresolved", message: "Indexed operation matched but no implementation candidate exists", resolutionStage: "implementation", resolutionStatus: "operation_without_implementation" }] };
+}
+function sourceFilesForStart(db, repoId, start, workspaceId) {
+  return sourceScopeForSelector(db, repoId, start, workspaceId);
+}
+function startScope(db, start, hintOptions, workspaceId) {
+  const repos = start.repo ? reposByName(db, start.repo, workspaceId).map((row) => ({
+    id: row.id,
+    name: row.name,
+    packageName: row.package_name ?? void 0
+  })) : [];
+  if (start.repo && repos.length === 0) return {
+    selectorMatched: false,
+    startDiagnostics: [selectorRepoNotFoundDiagnostic(start.repo)]
+  };
+  if (start.repo && repos.length > 1) return {
+    selectorMatched: false,
+    startDiagnostics: [selectorRepoAmbiguousDiagnostic(start.repo, repos)]
+  };
+  const repo = repos[0];
+  const operationScope = operationStartScope(
+    db,
+    repo?.id,
+    start,
+    hintOptions,
+    workspaceId
+  );
+  const terminalOperationScope = operationScope && !operationScope.files && (operationScope.diagnostics ?? []).some((d) => d.resolutionStage === "operation" || d.resolutionStage === "implementation");
+  const sourceScope = operationScope?.files || terminalOperationScope ? operationScope : sourceFilesForStart(db, repo?.id, start, workspaceId);
+  const terminalSelectorScope = Boolean(sourceScope?.diagnostics?.length && !sourceScope.files);
+  const sourceFiles = sourceScope?.files;
+  const hasSelector = Boolean(
+    start.handler ?? start.operation ?? start.operationPath ?? start.servicePath
+  );
+  if (start.servicePath && !start.operation && !start.operationPath && !start.handler)
+    return { repo, selectorMatched: false };
+  return {
+    repo,
+    executionRepoId: sourceScope?.repoId ?? repo?.id,
+    sourceFiles,
+    symbolIds: sourceScope?.symbols,
+    selectorMatched: !terminalOperationScope && !terminalSelectorScope && (!hasSelector || sourceFiles !== void 0),
+    startOperationId: operationScope?.operationId,
+    startDiagnostics: operationScope?.diagnostics?.length ? operationScope.diagnostics : sourceScope?.diagnostics
+  };
+}
+function handlerFilesForOperation(db, operationId) {
+  const op = db.prepare(
+    `SELECT o.operation_name operationName,o.operation_path operationPath,s.repo_id repoId
+    FROM cds_operations o JOIN cds_services s ON s.id=o.service_id WHERE o.id=?`
+  ).get(operationId);
+  if (!op) return /* @__PURE__ */ new Set();
+  const operation = normalizeOperation2(op.operationPath ?? op.operationName);
+  const rows2 = db.prepare(
+    `SELECT DISTINCT hc.source_file sourceFile,sym.id symbolId FROM handler_classes hc
+    JOIN handler_methods hm ON hm.handler_class_id=hc.id
+    LEFT JOIN symbols sym ON sym.repo_id=hc.repo_id
+      AND sym.source_file=hc.source_file
+      AND sym.qualified_name=hc.class_name || '.' || hm.method_name
+      AND sym.start_line=hm.source_line
+    WHERE hc.repo_id=?
+      AND COALESCE(json_extract(hm.decorator_resolution_json,'$.handlerKind'),
+        CASE WHEN hm.decorator_kind='Event' THEN 'event'
+          WHEN hm.decorator_kind IN ('Action','Func','On') THEN 'operation'
+          ELSE 'unsupported' END)='operation'
+      AND COALESCE(json_extract(hm.decorator_resolution_json,'$.executable'),
+        CASE WHEN hm.decorator_kind IN ('Action','Func','On')
+          THEN 1 ELSE 0 END)=1
+      AND (hm.decorator_value=? OR hm.method_name=? OR hm.decorator_value=?)`
+  ).all(op.repoId, operation, operation, op.operationName);
+  return new Set(rows2.map((row) => row.sourceFile).filter(Boolean));
+}
+function implementationEdge(db, operationId) {
+  return db.prepare("SELECT * FROM graph_edges WHERE edge_type='OPERATION_IMPLEMENTED_BY_HANDLER' AND from_kind='operation' AND from_id=? ORDER BY CASE status WHEN 'resolved' THEN 0 WHEN 'ambiguous' THEN 1 ELSE 2 END,id LIMIT 1").get(operationId);
+}
+function implementationScope(db, operationId) {
+  const edge = implementationEdge(db, operationId);
+  if (!edge || edge.status !== "resolved") return { files: /* @__PURE__ */ new Set(), edge };
+  const row = db.prepare("SELECT hc.repo_id repoId,hc.source_file sourceFile,s.id symbolId FROM handler_methods hm JOIN handler_classes hc ON hc.id=hm.handler_class_id LEFT JOIN symbols s ON s.repo_id=hc.repo_id AND s.source_file=hc.source_file AND s.qualified_name=hc.class_name || '.' || hm.method_name AND s.start_line=hm.source_line WHERE hm.id=?").get(edge.to_id);
+  if (!row || typeof row.symbolId !== "number")
+    return { repoId: row?.repoId, files: /* @__PURE__ */ new Set(), edge };
+  return { repoId: row?.repoId, files: new Set(row?.sourceFile ? [row.sourceFile] : []), symbolId: row?.symbolId, edge };
+}
+function handlerScope(db, methodId) {
+  const row = db.prepare("SELECT hc.repo_id repoId,hc.source_file sourceFile,s.id symbolId FROM handler_methods hm JOIN handler_classes hc ON hc.id=hm.handler_class_id LEFT JOIN symbols s ON s.repo_id=hc.repo_id AND s.source_file=hc.source_file AND s.qualified_name=hc.class_name || '.' || hm.method_name AND s.start_line=hm.source_line WHERE hm.id=?").get(methodId);
+  if (!row || typeof row.symbolId !== "number") return void 0;
+  return { repoId: row.repoId, files: new Set(row.sourceFile ? [row.sourceFile] : []), symbolId: row.symbolId };
 }
-function contextForSymbolCall(db, symbolCall, callerBindings) {
-  const next = /* @__PURE__ */ new Map();
-  if (callerBindings.size === 0) return next;
-  const callEvidence = parseEvidence(symbolCall.evidence_json);
-  const callee = db.prepare("SELECT evidence_json evidenceJson,source_file sourceFile,start_line startLine FROM symbols WHERE id=?").get(symbolCall.callee_symbol_id);
-  const calleeEvidence = parseEvidence(callee?.evidenceJson);
-  const params = Array.isArray(calleeEvidence.parameters) ? calleeEvidence.parameters.filter((item) => typeof item === "string") : [];
-  const parameterBindings = Array.isArray(calleeEvidence.parameterBindings) ? calleeEvidence.parameterBindings.filter((item) => Boolean(item && typeof item === "object" && !Array.isArray(item))) : [];
-  const parameterPropertyAliases = Array.isArray(calleeEvidence.parameterPropertyAliases) ? calleeEvidence.parameterPropertyAliases.filter((item) => Boolean(item && typeof item === "object" && !Array.isArray(item))) : [];
-  const args = Array.isArray(callEvidence.callArguments) ? callEvidence.callArguments : [];
-  const provenance = {
-    callerSite: { sourceFile: String(symbolCall.source_file ?? ""), sourceLine: Number(symbolCall.source_line ?? 0) },
-    calleeSite: { sourceFile: callee?.sourceFile, sourceLine: callee?.startLine }
-  };
-  args.forEach((arg, index) => {
-    const paramBinding = parameterBindings.find((binding) => binding.index === index);
-    const param = paramBinding?.kind === "identifier" && typeof paramBinding.name === "string" ? paramBinding.name : params[index];
-    if (arg.kind === "identifier" && typeof arg.name === "string") {
-      const binding = callerBindings.get(arg.name);
-      if (binding && param) next.set(param, { ...binding, ...provenance, source: "local_symbol_argument", callerArgument: arg.name, calleeParameter: param, calleeReceiver: param });
-    }
-    if (arg.kind === "object_literal" && Array.isArray(arg.properties)) {
-      for (const prop of arg.properties) {
-        if (typeof prop.property !== "string" || typeof prop.argument !== "string") continue;
-        const binding = callerBindings.get(prop.argument);
-        if (!binding) continue;
-        const destructured = paramBinding?.kind === "object_pattern" && Array.isArray(paramBinding.properties) ? paramBinding.properties.find((item) => item.property === prop.property && typeof item.local === "string") : void 0;
-        if (destructured && typeof destructured.local === "string") next.set(destructured.local, { ...binding, ...provenance, source: "local_symbol_destructured_object_argument", callerProperty: prop.property, callerArgument: prop.argument, calleeParameter: String(index), calleeReceiver: destructured.local });
-        else if (param) {
-          next.set(`${param}.${prop.property}`, { ...binding, ...provenance, source: "local_symbol_object_argument", callerProperty: prop.property, callerArgument: prop.argument, calleeParameter: param, calleeReceiver: `${param}.${prop.property}` });
-          for (const alias of parameterPropertyAliases) {
-            if (alias.parameter === param && alias.property === prop.property && typeof alias.local === "string") next.set(alias.local, { ...binding, ...provenance, source: "local_symbol_object_parameter_destructure", callerProperty: prop.property, callerArgument: prop.argument, calleeParameter: param, calleeObjectProperty: `${param}.${prop.property}`, calleeReceiver: alias.local, calleeLocalDestructuredIdentifier: alias.local, parameterPropertyAliasKind: alias.kind, parameterPropertyAliasLine: alias.line });
-          }
-        }
-      }
-    }
-    if (arg.kind === "array_literal" && Array.isArray(arg.elements) && paramBinding?.kind === "array_pattern" && Array.isArray(paramBinding.elements)) {
-      for (const element of arg.elements) {
-        const target = paramBinding.elements.find((item) => item.index === element.index);
-        if (element.kind !== "identifier" || typeof element.name !== "string" || typeof target?.local !== "string") continue;
-        const binding = callerBindings.get(element.name);
-        if (binding) next.set(target.local, { ...binding, ...provenance, source: "local_symbol_destructured_array_argument", callerArgument: element.name, calleeParameter: String(index), calleeReceiver: target.local });
-      }
-    }
-  });
-  return next;
+function traceEdgeType(call, row) {
+  if (row.to_kind === "operation" && row.edge_type === "REMOTE_CALL_RESOLVES_TO_OPERATION") return "remote_action";
+  if (row.to_kind === "operation" && row.edge_type === "LOCAL_CALL_RESOLVES_TO_OPERATION") return "local_service_call";
+  return String(call.call_type);
+}
+function includeCall(type, options) {
+  if (!options.includeDb && type === "local_db_query") return false;
+  if (!options.includeExternal && type === "external_http") return false;
+  if (!options.includeAsync && type.startsWith("async_")) return false;
+  return true;
 }
 function trace(db, start, options) {
+  const observer = compactObserver(options);
+  const schemaLifecycle = schemaLifecycleDiagnostic(db);
+  if (schemaLifecycle)
+    return { start, nodes: [], edges: [], diagnostics: [schemaLifecycle] };
   const hintOptions = { implementationRepo: options.implementationRepo, implementationHints: options.implementationHints };
   const scope = startScope(db, start, hintOptions, options.workspaceId);
   const hasSelector = Boolean(start.repo || start.handler || start.operation || start.operationPath || start.servicePath);
   const diagnosticRepoId = scope.executionRepoId ?? scope.repo?.id;
+  const scheduler = new TraversalScopeScheduler();
+  const roots = createTraceRootPlan(db, scheduler, {
+    repoId: diagnosticRepoId,
+    files: scope.sourceFiles,
+    symbolIds: scope.symbolIds,
+    selectorMatched: scope.selectorMatched
+  }, options.workspaceId, Boolean(options.includeAsync));
+  observer?.setWorkspaceId?.(roots.workspaceId);
+  if (roots.diagnostic)
+    return { start, nodes: [], edges: [], diagnostics: [roots.diagnostic] };
+  const { workspaceId, queue, pendingRoots } = roots;
   const diagnostics = loadTraceDiagnostics(
     db,
     diagnosticRepoId,
     !hasSelector,
-    options.workspaceId
+    workspaceId
   );
-  const stale = diagnosticRepoId !== void 0 || !hasSelector ? db.prepare("SELECT name,graph_stale_reason reason FROM repositories WHERE graph_stale_reason IS NOT NULL AND (? IS NULL OR id=?) AND (? IS NULL OR workspace_id=?) ORDER BY name,id").all(diagnosticRepoId, diagnosticRepoId, options.workspaceId, options.workspaceId) : [];
+  const stale = diagnosticRepoId !== void 0 || !hasSelector ? db.prepare("SELECT name,graph_stale_reason reason FROM repositories WHERE graph_stale_reason IS NOT NULL AND (? IS NULL OR id=?) AND (? IS NULL OR workspace_id=?) ORDER BY name,id").all(diagnosticRepoId, diagnosticRepoId, workspaceId, workspaceId) : [];
   for (const row of stale)
     prependTraceDiagnostic(diagnostics, { severity: "warning", code: "graph_stale", message: `Graph is stale for ${row.name ?? "repository"}: ${row.reason ?? "facts_changed"}. Run service-flow link.` });
   for (const diagnostic of scope.startDiagnostics ?? [])
@@ -8783,9 +10709,8 @@ function trace(db, start, options) {
     prependTraceDiagnostic(diagnostics, selectorNotFoundDiagnostic(start));
   const maxDepth = positiveDepth(options.depth);
   const edges = [];
+  const recorder = new TraceEdgeRecorder(edges, observer);
   const nodes = /* @__PURE__ */ new Map();
-  const seenEdges = /* @__PURE__ */ new Set();
-  const queue = scope.selectorMatched ? [{ repoId: scope.executionRepoId, files: scope.sourceFiles, symbolIds: scope.symbolIds, depth: 1, context: /* @__PURE__ */ new Map() }] : [];
   if (scope.startOperationId && scope.selectorMatched) {
     const op = operationNode(db, scope.startOperationId);
     const impl = implementationScope(db, scope.startOperationId);
@@ -8799,7 +10724,7 @@ function trace(db, start, options) {
     if (impl.edge && (impl.edge.status === "resolved" || startSelection.methodId)) {
       const selectedMethodId = impl.edge.status === "resolved" ? impl.edge.to_id : startSelection.methodId;
       const implEvidence = {
-        ...parseEvidence(impl.edge.evidence_json),
+        ...parseTraceEvidence(impl.edge.evidence_json),
         startResolution: {
           strategy: "indexed_operation_graph",
           matchedOperationId: scope.startOperationId,
@@ -8816,39 +10741,109 @@ function trace(db, start, options) {
       ) : { evidence: implEvidence };
       if (selected.diagnostic) prependTraceDiagnostic(diagnostics, selected.diagnostic);
       if (selected.handler) nodes.set(String(selected.handler.id), selected.handler);
-      seenEdges.add(Number(impl.edge.id));
-      edges.push({ step: 1, type: "operation_implemented_by_handler", from: op?.label ? String(op.label) : `operation:${scope.startOperationId}`, to: selected.handler?.label ? String(selected.handler.label) : `${impl.edge.to_kind}:${impl.edge.to_id}`, evidence: selected.evidence, confidence: Number(impl.edge.confidence ?? 0), unresolvedReason: selected.unresolvedReason ?? (impl.edge.status === "resolved" || startSelection.methodId ? void 0 : String(impl.edge.unresolved_reason ?? impl.edge.status)) });
+      const unresolvedReason = selected.unresolvedReason ?? (impl.edge.status === "resolved" || startSelection.methodId ? void 0 : String(impl.edge.unresolved_reason ?? impl.edge.status));
+      const selectedScope = selectedMethodId ? handlerScope(db, selectedMethodId) : void 0;
+      const edge = { step: 1, type: "operation_implemented_by_handler", from: op?.label ? String(op.label) : `operation:${scope.startOperationId}`, to: selected.handler?.label ? String(selected.handler.label) : `${impl.edge.to_kind}:${impl.edge.to_id}`, evidence: selected.evidence, confidence: Number(impl.edge.confidence ?? 0), unresolvedReason };
+      recordImplementationObservation(recorder, edge, {
+        operationId: scope.startOperationId,
+        handlerMethodId: selectedMethodId,
+        handlerSymbolId: selectedScope?.symbolId,
+        graphEdgeId: impl.edge.id,
+        persistedStatus: impl.edge.status,
+        persistedTargetKind: impl.edge.to_kind,
+        persistedTargetId: impl.edge.to_id,
+        effectiveStatus: startSelection.methodId ? "resolved" : String(impl.edge.status ?? "unresolved"),
+        strategy: String(startSelection.evidence.strategy ?? "indexed_operation_graph"),
+        guided: startSelection.evidence.guided === true,
+        unresolvedReason,
+        evidence: selected.evidence,
+        site: op ?? {}
+      });
     }
   }
-  const seenScopes = /* @__PURE__ */ new Set();
-  while (queue.length > 0) {
+  while (queue.length > 0 || pendingRoots.length > 0) {
+    if ((queue[0]?.depth ?? Number.POSITIVE_INFINITY) > 1 && workspaceId !== void 0) {
+      const root = nextPendingRoot(pendingRoots, scheduler, workspaceId);
+      if (root) queue.unshift(root);
+    }
     const current = queue.shift();
     if (!current || current.depth > maxDepth) continue;
-    const contextKey = [...(current.context ?? /* @__PURE__ */ new Map()).keys()].sort().join(",");
-    const key = `${current.repoId ?? "*"}:${[...current.symbolIds ?? /* @__PURE__ */ new Set(["*"])].sort().join(",")}:${[...current.files ?? /* @__PURE__ */ new Set(["*"])].sort().join(",")}:${contextKey}`;
-    if (seenScopes.has(key)) continue;
-    seenScopes.add(key);
+    if (!scheduler.markExpanded(current.state)) continue;
     const calls = db.prepare(
-      `SELECT c.*,r.name repoName FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id WHERE (? IS NULL OR c.repo_id=?) AND (? IS NULL OR r.workspace_id=?) ORDER BY c.source_file,c.source_line`
-    ).all(current.repoId, current.repoId, options.workspaceId, options.workspaceId);
+      `SELECT c.*,r.name repoName,r.workspace_id workspaceId,
+          r.graph_generation graphGeneration
+        FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id
+        WHERE (? IS NULL OR c.repo_id=?) AND (? IS NULL OR r.workspace_id=?)
+        ORDER BY c.source_file COLLATE BINARY,c.call_site_start_offset,
+          c.call_site_end_offset,c.source_line,c.id`
+    ).all(current.repoId, current.repoId, workspaceId, workspaceId);
     const filtered = calls.filter(
-      (c) => (!current.symbolIds || current.symbolIds.has(Number(c.source_symbol_id))) && (!current.files || current.files.has(String(c.source_file))) && includeCall(String(c.call_type), options)
+      (c) => (current.unownedOnly ? c.source_symbol_id == null : !current.symbolIds || current.symbolIds.has(Number(c.source_symbol_id))) && (!current.files || current.files.has(String(c.source_file))) && includeCall(String(c.call_type), options)
     );
-    const callerBindings = new Map([...current.context ?? /* @__PURE__ */ new Map(), ...knownBindingsForScope(db, current.repoId, current.symbolIds, current.files), ...knownBindingsForCalls(db, filtered)]);
-    if (current.symbolIds && current.symbolIds.size > 0 && current.depth < maxDepth) {
-      const symbolRows = db.prepare(`SELECT sc.*,s.repo_id calleeRepoId,s.source_file calleeFile FROM symbol_calls sc LEFT JOIN symbols s ON s.id=sc.callee_symbol_id WHERE sc.caller_symbol_id IN (${[...current.symbolIds].map(() => "?").join(",")}) ORDER BY sc.source_file,sc.source_line`).all(...current.symbolIds);
+    const callerBindings = new Map([...current.context, ...knownBindingsForScope(db, current.repoId, current.symbolIds, current.files), ...knownBindingsForCalls(db, filtered)]);
+    if (!current.rootObservationOnly && current.symbolIds && current.symbolIds.size > 0 && current.depth < maxDepth) {
+      const symbolRows = db.prepare(`SELECT sc.*,s.repo_id calleeRepoId,
+        s.source_file calleeFile FROM symbol_calls sc
+        LEFT JOIN symbols s ON s.id=sc.callee_symbol_id
+        WHERE sc.call_role='ordinary_call'
+          AND sc.caller_symbol_id IN (${[...current.symbolIds].map(() => "?").join(",")})
+        ORDER BY sc.source_file COLLATE BINARY,sc.call_site_start_offset,
+          sc.call_site_end_offset,sc.source_line,sc.id`).all(
+        ...current.symbolIds
+      );
       for (const symbolCall of symbolRows) {
         if (!symbolCall.callee_symbol_id) continue;
         const nextSymbols = /* @__PURE__ */ new Set([Number(symbolCall.callee_symbol_id)]);
         const nextFiles = /* @__PURE__ */ new Set([String(symbolCall.calleeFile)]);
         const nextRepoId = Number(symbolCall.calleeRepoId);
-        const nextKey = `${nextRepoId}:${[...nextSymbols].join(",")}:${[...nextFiles].join(",")}`;
+        const nextContext = contextForSymbolCall(db, symbolCall, callerBindings);
+        const scheduling = scheduler.schedule({
+          workspaceId,
+          repoId: nextRepoId,
+          files: nextFiles,
+          symbolIds: nextSymbols,
+          context: nextContext
+        }, current.state);
         const calleeNode = symbolNode(db, Number(symbolCall.callee_symbol_id));
         if (calleeNode) nodes.set(String(calleeNode.id), calleeNode);
-        const evidence = { ...parseEvidence(symbolCall.evidence_json), sourceFile: symbolCall.source_file, sourceLine: symbolCall.source_line, calleeSymbolId: symbolCall.callee_symbol_id, calleeSymbolName: calleeNode?.symbolName, calleeSymbolFile: calleeNode?.sourceFile, resolutionStatus: symbolCall.status };
-        edges.push({ step: current.depth, type: "local_symbol_call", from: String(symbolCall.callee_expression), to: calleeNode?.label ? String(calleeNode.label) : `symbol:${String(symbolCall.callee_symbol_id)}`, evidence, confidence: Number(symbolCall.confidence ?? 0.8), unresolvedReason: String(symbolCall.status) === "resolved" ? void 0 : symbolCall.unresolved_reason ? String(symbolCall.unresolved_reason) : void 0 });
-        if (seenScopes.has(nextKey)) edges.push({ step: current.depth, type: "cycle", from: String(symbolCall.callee_expression), to: nextKey, evidence: { cycle: true, symbolCallId: symbolCall.id }, confidence: 1, unresolvedReason: "Cycle detected; downstream symbol already visited" });
-        else queue.push({ repoId: nextRepoId, files: nextFiles, symbolIds: nextSymbols, depth: current.depth + 1, context: contextForSymbolCall(db, symbolCall, callerBindings) });
+        const evidence = { ...parseTraceEvidence(symbolCall.evidence_json), sourceFile: symbolCall.source_file, sourceLine: symbolCall.source_line, calleeSymbolId: symbolCall.callee_symbol_id, calleeSymbolName: calleeNode?.symbolName, calleeSymbolFile: calleeNode?.sourceFile, resolutionStatus: symbolCall.status };
+        const unresolvedReason = String(symbolCall.status) === "resolved" ? void 0 : symbolCall.unresolved_reason ? String(symbolCall.unresolved_reason) : void 0;
+        const edge = { step: current.depth, type: "local_symbol_call", from: String(symbolCall.callee_expression), to: calleeNode?.label ? String(calleeNode.label) : `symbol:${String(symbolCall.callee_symbol_id)}`, evidence, confidence: Number(symbolCall.confidence ?? 0.8), unresolvedReason };
+        const target = recordLocalCallObservation(recorder, edge, {
+          symbolCall,
+          evidence,
+          unresolvedReason
+        });
+        if (scheduling.kind === "cycle") {
+          const cycleEvidence = {
+            cycle: true,
+            cycleReason: "structural_ancestry_cycle",
+            symbolCallId: symbolCall.id
+          };
+          const cycleEdge = { step: current.depth, type: "cycle", from: String(symbolCall.callee_expression), to: scheduling.state.structuralKey, evidence: cycleEvidence, confidence: 1, unresolvedReason: "Cycle detected in structural ancestry; downstream symbol was not expanded" };
+          recordCycleObservation(recorder, cycleEdge, target, {
+            workspaceId,
+            repositoryId: nextRepoId,
+            sourceFiles: nextFiles,
+            symbolIds: nextSymbols,
+            structuralKey: scheduling.state.structuralKey
+          }, {
+            symbolCallId: symbolCall.id,
+            symbolId: symbolCall.callee_symbol_id
+          }, symbolCall);
+        }
+        if (scheduling.kind === "scheduled") enqueueCausalScope(
+          queue,
+          pendingRoots,
+          {
+            repoId: nextRepoId,
+            files: nextFiles,
+            symbolIds: nextSymbols,
+            depth: current.depth + 1,
+            context: nextContext,
+            state: scheduling.state
+          }
+        );
       }
     }
     const graph = graphForCalls(
@@ -8866,29 +10861,27 @@ function trace(db, start, options) {
         callType: call.call_type
       });
       const persistedRowsForCall = graph.get(Number(call.id)) ?? [];
-      const contextual = contextualRuntimeResolution(db, call, callerBindings.get(receiverFromEvidence(call.evidence_json) ?? ""), workspaceIdForCall(db, String(call.id)), persistedRowsForCall);
+      const contextual = contextualRuntimeResolution(db, call, callerBindings.get(receiverFromTraceEvidence(call.evidence_json) ?? ""), call.workspaceId, persistedRowsForCall);
       const graphRows = contextual.row ? [contextual.row] : persistedRowsForCall;
       for (const row of graphRows) {
-        if (seenEdges.has(Number(row.id))) continue;
-        seenEdges.add(Number(row.id));
-        const persistedEvidence = parseEvidence(row.evidence_json);
+        const persistedEvidence = parseTraceEvidence(row.evidence_json);
         const rawEvidence = baseTraceEvidence(row, call, persistedEvidence, contextual.evidence);
         const effective = runtimeResolution(db, row, rawEvidence, {
           vars: options.vars,
           dynamicMode: options.dynamicMode ?? "strict",
           maxDynamicCandidates: options.maxDynamicCandidates
-        }, workspaceIdForCall(db, String(call.id)), contextual.state);
+        }, call.workspaceId, contextual.state);
         const evidence = effective.evidence;
         const effectiveRow = effective.row;
-        const targetNode = `${effectiveRow.to_kind}:${effectiveRow.to_id}`;
+        const targetNode2 = `${effectiveRow.to_kind}:${effectiveRow.to_id}`;
         const opNode = effectiveRow.to_kind === "operation" ? operationNode(db, effectiveRow.to_id) : void 0;
-        nodes.set(targetNode, opNode ?? {
-          id: targetNode,
+        nodes.set(targetNode2, opNode ?? {
+          id: targetNode2,
           kind: effectiveRow.to_kind,
           label: effectiveRow.to_kind === "db_entity" ? `Entity: ${effectiveRow.to_id || "unknown"}` : effectiveRow.to_id
         });
         const to = edgeTarget(effectiveRow, evidence);
-        edges.push({
+        const edge = {
           step: current.depth,
           type: traceEdgeType(call, effectiveRow),
           from: `${call.repoName}:${call.source_file}:${call.source_line}`,
@@ -8896,9 +10889,88 @@ function trace(db, start, options) {
           evidence,
           confidence: Number(effectiveRow.confidence ?? call.confidence),
           unresolvedReason: effective.unresolvedReason
+        };
+        const semanticWorkspaceId = workspaceId ?? call.workspaceId;
+        const semantic = recordOutboundObservation(recorder, edge, {
+          call,
+          row: effectiveRow,
+          evidence,
+          workspaceId: semanticWorkspaceId,
+          dynamicMode: options.dynamicMode,
+          unresolvedReason: effective.unresolvedReason
         });
-        if ((options.dynamicMode ?? "strict") === "candidates" && effectiveRow.status !== "resolved")
-          edges.push(...dynamicCandidateBranches(current.depth, call, evidence));
+        if (options.includeAsync && call.call_type === "async_emit" && effectiveRow.edge_type === "HANDLER_EMITS_EVENT" && typeof call.event_name_expr === "string") {
+          const plans = planEventSubscriberTransitions(db, {
+            workspaceId: workspaceId ?? call.workspaceId,
+            graphGeneration: call.graphGeneration,
+            eventName: call.event_name_expr
+          }, scheduler, current.state, current.depth, maxDepth);
+          for (const plan of plans) {
+            const nodeId = String(plan.node.id);
+            const targetLabel = String(plan.node.label ?? nodeId);
+            nodes.set(nodeId, plan.node);
+            const bridgeEdge = {
+              step: current.depth,
+              type: "event_name_matches_subscription_handler",
+              from: plan.transition.eventName,
+              to: targetLabel,
+              evidence: plan.evidence,
+              confidence: plan.transition.confidence,
+              unresolvedReason: plan.transition.unresolvedReason
+            };
+            const handler = plan.transition.handler;
+            const bridgeTarget = recordEventBridgeObservation(
+              recorder,
+              bridgeEdge,
+              plan,
+              semanticWorkspaceId,
+              plans.length
+            );
+            if (plan.bodyExpansion === "cycle_blocked" && plan.state) {
+              const cycleEvidence = {
+                cycle: true,
+                cycleReason: "structural_ancestry_cycle",
+                graphEdgeId: plan.transition.graphEdgeId
+              };
+              const cycleEdge = { step: current.depth, type: "cycle", from: targetLabel, to: plan.state.structuralKey, evidence: cycleEvidence, confidence: 1, unresolvedReason: "Cycle detected across an event subscriber boundary; downstream symbol was not expanded" };
+              recordEventCycleObservation(
+                recorder,
+                cycleEdge,
+                plan,
+                bridgeTarget,
+                semanticWorkspaceId
+              );
+            }
+            if (plan.bodyExpansion === "scheduled" && plan.state && handler) {
+              const files = /* @__PURE__ */ new Set([handler.sourceFile]);
+              const symbolIds = /* @__PURE__ */ new Set([handler.symbolId]);
+              enqueueCausalScope(queue, pendingRoots, {
+                repoId: handler.repoId,
+                files,
+                symbolIds,
+                depth: current.depth + 1,
+                context: /* @__PURE__ */ new Map(),
+                state: plan.state
+              });
+            }
+          }
+        }
+        if ((options.dynamicMode ?? "strict") === "candidates" && effectiveRow.status !== "resolved") {
+          for (const branch of dynamicCandidateBranches(
+            current.depth,
+            call,
+            evidence
+          )) {
+            recordDynamicBranchObservation(
+              recorder,
+              branch,
+              call,
+              semantic.source,
+              evidence,
+              semanticWorkspaceId
+            );
+          }
+        }
         if (effectiveRow.to_kind === "operation") {
           const implementation = implementationScope(db, effectiveRow.to_id);
           const contextSelection = contextualImplementationSelection(
@@ -8912,7 +10984,7 @@ function trace(db, start, options) {
           const contextMethodId = contextSelection.methodId;
           let selectedHandlerAvailable = true;
           if (implementation.edge) {
-            const implEvidence = parseEvidence(implementation.edge.evidence_json);
+            const implEvidence = parseTraceEvidence(implementation.edge.evidence_json);
             const hintDiagnostic = implementationHintDiagnostic(contextSelection, implEvidence);
             if (hintDiagnostic) prependTraceDiagnostic(diagnostics, hintDiagnostic);
             const selectedMethodId = implementation.edge.status === "resolved" ? implementation.edge.to_id : contextMethodId;
@@ -8935,14 +11007,32 @@ function trace(db, start, options) {
             if (selected.diagnostic) prependTraceDiagnostic(diagnostics, selected.diagnostic);
             const implTo = selected.handler?.label ? String(selected.handler.label) : `${implementation.edge.to_kind}:${implementation.edge.to_id}`;
             if (selected.handler) nodes.set(String(selected.handler.id), selected.handler);
-            edges.push({
+            const unresolvedReason = selected.unresolvedReason ?? (implementation.edge.status === "resolved" || contextMethodId ? void 0 : String(implementation.edge.unresolved_reason ?? implementation.edge.status));
+            const implementationTraceEdge = {
               step: current.depth,
               type: "operation_implemented_by_handler",
               from: to,
               to: implTo,
               evidence: selected.evidence,
               confidence: Number(implementation.edge.confidence ?? 0),
-              unresolvedReason: selected.unresolvedReason ?? (implementation.edge.status === "resolved" || contextMethodId ? void 0 : String(implementation.edge.unresolved_reason ?? implementation.edge.status))
+              unresolvedReason
+            };
+            const selectedScope = selectedMethodId ? handlerScope(db, selectedMethodId) : void 0;
+            recordImplementationObservation(recorder, implementationTraceEdge, {
+              operationId: effectiveRow.to_id,
+              handlerMethodId: selectedMethodId,
+              handlerSymbolId: selectedScope?.symbolId,
+              graphEdgeId: implementation.edge.id,
+              persistedStatus: implementation.edge.status,
+              persistedTargetKind: implementation.edge.to_kind,
+              persistedTargetId: implementation.edge.to_id,
+              effectiveStatus: contextMethodId ? "resolved" : String(implementation.edge.status),
+              strategy: String(contextSelection.evidence.strategy ?? (contextMethodId ? "contextual_implementation_selection" : "indexed_operation_graph")),
+              guided: contextSelection.evidence.guided === true,
+              contextual: Boolean(contextMethodId && contextSelection.evidence.strategy !== "implementation_repo_hint"),
+              unresolvedReason,
+              evidence: selected.evidence,
+              site: call
             });
           }
           if (current.depth >= maxDepth) continue;
@@ -8953,24 +11043,53 @@ function trace(db, start, options) {
             const targetRepoId = contextScope?.repoId ?? implementation.repoId ?? db.prepare(
               "SELECT s.repo_id repoId FROM cds_operations o JOIN cds_services s ON s.id=o.service_id WHERE o.id=?"
             ).get(effectiveRow.to_id)?.repoId;
-            const nextKey = `${targetRepoId ?? "*"}:${[...symbolIds ?? /* @__PURE__ */ new Set(["*"])].sort().join(",")}:${[...files].sort().join(",")}`;
-            if (seenScopes.has(nextKey))
-              edges.push({
+            const nextContext = /* @__PURE__ */ new Map();
+            const scheduling = scheduler.schedule({
+              workspaceId: workspaceId ?? call.workspaceId,
+              repoId: targetRepoId,
+              files,
+              symbolIds,
+              context: nextContext
+            }, current.state);
+            if (scheduling.kind === "cycle") {
+              const cycleEvidence = {
+                ...evidence,
+                cycle: true,
+                cycleReason: "structural_ancestry_cycle"
+              };
+              const cycleEdge = {
                 step: current.depth,
                 type: "cycle",
                 from: to,
-                to: nextKey,
-                evidence: { ...evidence, cycle: true },
+                to: scheduling.state.structuralKey,
+                evidence: cycleEvidence,
                 confidence: 1,
-                unresolvedReason: "Cycle detected; downstream scope already visited"
-              });
-            else
-              queue.push({
+                unresolvedReason: "Cycle detected in structural ancestry; downstream scope was not expanded"
+              };
+              recordCycleObservation(recorder, cycleEdge, semantic.target, {
+                workspaceId: semanticWorkspaceId,
+                repositoryId: targetRepoId,
+                sourceFiles: files,
+                symbolIds,
+                structuralKey: scheduling.state.structuralKey
+              }, {
+                graphEdgeId: evidence.persistedGraphEdgeId,
+                outboundCallId: call.id,
+                operationId: effectiveRow.to_id
+              }, call);
+            }
+            if (scheduling.kind === "scheduled") enqueueCausalScope(
+              queue,
+              pendingRoots,
+              {
                 repoId: targetRepoId,
                 files,
                 symbolIds,
-                depth: current.depth + 1
-              });
+                depth: current.depth + 1,
+                context: nextContext,
+                state: scheduling.state
+              }
+            );
           }
         }
       }
@@ -8982,9 +11101,1010 @@ function trace(db, start, options) {
     prependTraceDiagnostic(diagnostics, diagnostic);
   return { start, nodes: [...nodes.values()], edges, diagnostics };
 }
+function traceWithObserver(db, start, options, observer) {
+  const observed = {
+    ...options,
+    [compactObserverKey]: observer
+  };
+  return trace(db, start, observed);
+}
+
+// src/trace/014-compact-contract.ts
+var CompactObservationCollector = class {
+  observations = [];
+  workspaceId;
+  record(observation2) {
+    this.observations.push(observation2);
+  }
+  setWorkspaceId(workspaceId) {
+    this.workspaceId = workspaceId;
+  }
+};
+
+// src/trace/020-compact-field-projection.ts
+var compactNameLimit = 8;
+var compactDiagnosticMessages = {
+  schema_upgrade_required: "The database schema must be upgraded before tracing.",
+  reindex_required: "Current analyzer facts are required before tracing.",
+  trace_workspace_ambiguous: "The trace workspace is ambiguous.",
+  trace_runtime_variables_missing: "Runtime variable names are required to resolve a branch.",
+  implementation_hint_mismatch: "The implementation hint did not select one implementation.",
+  selected_handler_provenance_mismatch: "Selected handler provenance did not match its graph target.",
+  selected_handler_target_not_found: "The selected handler target is not indexed.",
+  trace_start_implementation_unresolved: "The trace start implementation is unresolved."
+};
+function projectCompactDecision(input) {
+  if (!input) return {};
+  const out = resolutionDecision(input);
+  addNameDecision(out, input);
+  addDynamicDecision(out, input);
+  addImplementationDecision(out, input);
+  addEventDecision(out, input);
+  const reasonCode = compactSafeCode(input.reasonCode);
+  if (reasonCode) out.reasonCode = reasonCode;
+  addRemediationDecision(out, input);
+  return out;
+}
+function resolutionDecision(input) {
+  const out = {};
+  const status = compactSafeCode(input.effectiveResolutionStatus);
+  if (status) out.effectiveResolutionStatus = status;
+  if (!persistedResolutionDiffers(input)) return out;
+  const persistedStatus = compactSafeCode(input.persistedResolutionStatus);
+  if (persistedStatus) out.persistedResolutionStatus = persistedStatus;
+  return out;
+}
+function addNameDecision(out, input) {
+  const allNames = safeVariableNames(input.missingVariableNames);
+  const names = allNames.slice(0, compactNameLimit);
+  const total = Math.max(compactCount(input.missingVariableCount), allNames.length);
+  if (names.length > 0) out.missingVariableNames = names;
+  if (total === 0) return;
+  out.missingVariableCount = total;
+  out.shownMissingVariableCount = names.length;
+  out.omittedMissingVariableCount = Math.max(0, total - names.length);
+}
+function addDynamicDecision(out, input) {
+  if (input.dynamicMode) out.dynamicMode = input.dynamicMode;
+  if (input.candidateCount !== void 0) out.candidateCount = compactCount(input.candidateCount);
+  if (input.viableCandidateCount !== void 0)
+    out.viableCandidateCount = compactCount(input.viableCandidateCount);
+  if (input.rejectedCandidateCount !== void 0)
+    out.rejectedCandidateCount = compactCount(input.rejectedCandidateCount);
+  if (input.omittedCandidateCount !== void 0)
+    out.omittedCandidateCount = compactCount(input.omittedCandidateCount);
+}
+function addImplementationDecision(out, input) {
+  const strategy = compactSafeCode(input.implementationStrategy);
+  if (strategy) out.implementationStrategy = strategy;
+  if (input.implementationGuided !== void 0)
+    out.implementationGuided = input.implementationGuided;
+  if (input.implementationContextual !== void 0)
+    out.implementationContextual = input.implementationContextual;
+}
+function addEventDecision(out, input) {
+  addEventCodes(out, input);
+  if (input.eventSubscriptionCount !== void 0)
+    out.eventSubscriptionCount = compactCount(input.eventSubscriptionCount);
+  if (input.roleSiteMatchCount !== void 0)
+    out.roleSiteMatchCount = compactCount(input.roleSiteMatchCount);
+}
+function addEventCodes(out, input) {
+  const values = [
+    ["eventMatchStrategy", compactSafeCode(input.eventMatchStrategy)],
+    ["dispatchCertainty", compactSafeCode(input.dispatchCertainty)],
+    ["associationStatus", compactSafeCode(input.associationStatus)],
+    ["associationBasis", compactSafeCode(input.associationBasis)],
+    ["eventScope", compactSafeCode(input.eventScope)],
+    ["callRole", compactSafeCode(input.callRole)],
+    ["factOrigin", compactSafeCode(input.factOrigin)],
+    ["bodyExpansion", compactSafeCode(input.bodyExpansion)]
+  ];
+  for (const [key, value] of values) {
+    if (value) Object.assign(out, { [key]: value });
+  }
+}
+function addRemediationDecision(out, input) {
+  const hint = input.remediationCode ? compactRemediationHint(input.remediationCode) : void 0;
+  if (!hint) return;
+  out.remediationHint = hint;
+  const total = Math.max(1, compactCount(input.remediationHintCount));
+  out.omittedRemediationHintCount = Math.max(0, total - 1);
+}
+function projectCompactDiagnostics(values) {
+  return values.map((value, index) => compactDiagnostic(value, index)).sort(compareCompactDiagnostic);
+}
+function projectCompactStart(start) {
+  return {
+    repo: start.repo ?? null,
+    servicePath: start.servicePath ?? null,
+    operation: start.operation ?? null,
+    operationPath: start.operationPath ?? null,
+    handler: start.handler ?? null
+  };
+}
+function projectCompactQuery(options) {
+  const hints = (options.implementationHints ?? []).map(projectCompactHint).sort((left, right) => compareBinary(
+    JSON.stringify(left),
+    JSON.stringify(right)
+  ));
+  return {
+    depth: compactPositiveInteger(options.depth) ?? 25,
+    includeAsync: Boolean(options.includeAsync),
+    includeDb: Boolean(options.includeDb),
+    includeExternal: Boolean(options.includeExternal),
+    dynamicMode: options.dynamicMode ?? "strict",
+    maxDynamicCandidates: compactPositiveInteger(options.maxDynamicCandidates) ?? 5,
+    suppliedVariableNames: compactSortedUnique(Object.keys(options.vars ?? {})),
+    runtimeValuesOmitted: true,
+    implementationRepo: options.implementationRepo ?? null,
+    implementationHints: hints
+  };
+}
+function projectCompactHint(hint) {
+  return {
+    servicePath: hint.servicePath ?? null,
+    operationPath: hint.operationPath ?? null,
+    packageName: hint.packageName ?? null,
+    repositoryName: hint.repositoryName ?? null,
+    candidateFamily: hint.candidateFamily ?? null,
+    implementationRepo: hint.implementationRepo ?? null
+  };
+}
+function compactStatusCounts(values) {
+  const counts = {
+    resolved: 0,
+    terminal: 0,
+    inferred: 0,
+    dynamic: 0,
+    ambiguous: 0,
+    unresolved: 0,
+    cycle: 0
+  };
+  for (const value of values) counts[value.status] += 1;
+  return counts;
+}
+function compactCompleteness(counts, diagnostics) {
+  const total = compactStatusTotal(counts);
+  if (total === 0 && diagnostics.some(compactBlockingDiagnostic)) return "blocked";
+  if (counts.dynamic + counts.ambiguous + counts.unresolved > 0) return "partial";
+  if (diagnostics.some((item) => item[1] === "error" || item[1] === "warning"))
+    return "partial";
+  return "complete";
+}
+function compactStatusTotal(counts) {
+  return counts.resolved + counts.terminal + counts.inferred + counts.dynamic + counts.ambiguous + counts.unresolved + counts.cycle;
+}
+function removeEquivalentCompactPersistedDecision(decision) {
+  if (decision.persistedResolutionStatus !== decision.effectiveResolutionStatus) return;
+  if (!decision.persistedTarget || decision.persistedTarget !== decision.effectiveTarget) return;
+  delete decision.persistedResolutionStatus;
+  delete decision.persistedTarget;
+}
+function compactBlockingDiagnostic(item) {
+  if (item[1] === "error") return true;
+  return item[2] === "schema_upgrade_required" || item[2] === "reindex_required" || item[2] === "trace_workspace_ambiguous" || item[2].startsWith("selector_") || item[2].startsWith("trace_start_");
+}
+function compactDiagnostic(value, index) {
+  const code = compactSafeCode(value.code) ?? "unknown_diagnostic";
+  const details = compactDiagnosticDetails(value, code);
+  return {
+    index,
+    severity: compactDiagnosticSeverity(value.severity),
+    code,
+    message: compactDiagnosticMessages[code] ?? `See detailed diagnostic at index ${index}.`,
+    file: compactSafeSourceFile(value.sourceFile) ?? compactSafeSourceFile(value.file),
+    line: compactPositiveInteger(value.sourceLine) ?? compactPositiveInteger(value.line),
+    details: Object.keys(details).length > 0 ? details : void 0
+  };
+}
+function compactDiagnosticDetails(value, code) {
+  const out = {};
+  const reasonCode = compactSafeCode(value.reasonCode);
+  if (reasonCode) out.reasonCode = reasonCode;
+  addDiagnosticNames(out, value);
+  addDiagnosticCounts(out, value);
+  const hint = compactDiagnosticRemediation(code);
+  if (hint) {
+    out.remediationHint = hint;
+    out.omittedHintCount = Math.max(
+      0,
+      compactDiagnosticHintCount(value, code, out) - 1
+    );
+  }
+  return out;
+}
+function addDiagnosticNames(out, value) {
+  const allNames = safeVariableNames(compactStringArray(value.missingVariables));
+  const names = allNames.slice(0, compactNameLimit);
+  const total = Math.max(allNames.length, compactCount(value.missingVariableCount));
+  if (names.length > 0) out.missingVariableNames = names;
+  if (total === 0) return;
+  out.missingVariableCount = total;
+  out.shownMissingVariableCount = names.length;
+  out.omittedMissingVariableCount = Math.max(0, total - names.length);
+}
+function addDiagnosticCounts(out, value) {
+  if (value.candidateCount !== void 0)
+    out.candidateCount = compactCount(value.candidateCount);
+  if (value.viableCandidateCount !== void 0)
+    out.viableCandidateCount = compactCount(value.viableCandidateCount);
+  if (value.rejectedCandidateCount !== void 0)
+    out.rejectedCandidateCount = compactCount(value.rejectedCandidateCount);
+}
+function compareCompactDiagnostic(left, right) {
+  const ranks = { error: 0, warning: 1, info: 2 };
+  return ranks[left.severity] - ranks[right.severity] || compareBinary(left.code, right.code) || compareBinary(left.file ?? "", right.file ?? "") || (left.line ?? Number.MAX_SAFE_INTEGER) - (right.line ?? Number.MAX_SAFE_INTEGER) || compareBinary(left.message, right.message) || left.index - right.index;
+}
+function persistedResolutionDiffers(input) {
+  return input.persistedResolutionStatus !== void 0 && (input.persistedResolutionStatus !== input.effectiveResolutionStatus || JSON.stringify(input.persistedTarget) !== JSON.stringify(input.effectiveTarget));
+}
+function compactDiagnosticSeverity(value) {
+  return value === "error" || value === "warning" ? value : "info";
+}
+function compactDiagnosticRemediation(code) {
+  if (code === "schema_upgrade_required" || code === "reindex_required")
+    return compactRemediationHint("reindex_and_link");
+  if (code === "trace_runtime_variables_missing")
+    return compactRemediationHint("provide_runtime_variables");
+  if (code === "implementation_hint_mismatch")
+    return compactRemediationHint("select_implementation");
+  return void 0;
+}
+function compactDiagnosticHintCount(value, code, details) {
+  const missing = code === "trace_runtime_variables_missing" ? details.missingVariableCount ?? 0 : 0;
+  return Math.max(
+    1,
+    missing,
+    compactArrayLength(value.suggestions),
+    compactArrayLength(value.implementationHintSuggestions),
+    compactArrayLength(value.copyableExamples),
+    compactCount(value.suggestionCount),
+    compactCount(value.implementationHintSuggestionCount),
+    compactCount(value.copyableExampleCount)
+  );
+}
+function compactRemediationHint(code) {
+  if (code === "provide_runtime_variables") return "Provide the missing variable names listed in details.";
+  if (code === "select_implementation") return "Select one implementation with a scoped implementation hint.";
+  if (code === "reindex_and_link") return "Force reindex, then force relink the workspace.";
+  if (code === "inspect_detailed_edge") return "Inspect the correlated detailed trace edge.";
+  return void 0;
+}
+function compactSafeCode(value) {
+  return typeof value === "string" && /^[a-z][a-z0-9_.-]{0,79}$/.test(value) ? value : void 0;
+}
+function projectCompactDecisionTarget(kindValue, id) {
+  const kind = compactSafeCode(kindValue);
+  if (!kind || id.length === 0 || id.length > 240 || /[\r\n]/.test(id)) return void 0;
+  if (/^[a-z]+:\/\//i.test(id) || /\b(?:bearer|token|secret|password|credential|authorization)\b/i.test(id))
+    return void 0;
+  const redacted = redactText(id);
+  return redacted === id ? `${kind}:${redacted}` : void 0;
+}
+function compactSafeSourceFile(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 512 && !/^[a-z]+:\/\//i.test(value) && !/[\r\n]/.test(value) ? value : void 0;
+}
+function safeVariableNames(values) {
+  return compactSortedUnique((values ?? []).filter((value) => /^[A-Za-z_$][\w$]*$/.test(value)));
+}
+function compactCount(value) {
+  return typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
+}
+function compactPositiveInteger(value) {
+  const normalized = compactCount(value);
+  return normalized > 0 ? normalized : void 0;
+}
+function compactStringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function compactArrayLength(value) {
+  return Array.isArray(value) ? value.length : 0;
+}
+function compactSortedUnique(values) {
+  return [...new Set(values)].sort(compareBinary);
+}
+
+// src/trace/016-compact-projector.ts
+var REFERENCE_LIMIT = 5;
+function projectCompactGraph(input) {
+  validateObservationOrdinals(input.observations, input.trace.edges.length);
+  const resolved3 = input.observations.map((item) => resolveObservation(input.db, item));
+  const diagnostics = projectCompactDiagnostics(input.trace.diagnostics);
+  const aggregates = aggregateObservations(resolved3);
+  const nodes = canonicalNodes(resolved3);
+  const repos = sortedUnique(nodes.flatMap((node) => node.repo ? [node.repo] : []));
+  const files = sortedUnique([
+    ...nodes.flatMap((node) => node.file ? [node.file] : []),
+    ...diagnostics.flatMap((item) => item.file ? [item.file] : [])
+  ]);
+  const nodeRows = compactNodeRows(nodes, repos, files);
+  const edgeRows = compactEdgeRows(aggregates, nodes);
+  const diagnosticRows = compactDiagnosticRows(diagnostics, files);
+  const result = compactResult(input, nodes, nodeRows, edgeRows, diagnosticRows, repos, files);
+  validateCompactResult(result);
+  return result;
+}
+function resolveObservation(db, input) {
+  const target = resolveEndpoint(db, input.target, input.ordinal, "target", input.site);
+  return {
+    input,
+    source: resolveEndpoint(db, input.source, input.ordinal, "source", input.site),
+    target,
+    decision: observationDecision(db, input, target)
+  };
+}
+function observationDecision(db, input, target) {
+  const decision = projectCompactDecision(input.decision);
+  if (decision.effectiveResolutionStatus && target.decisionTarget)
+    decision.effectiveTarget = target.decisionTarget;
+  if (decision.persistedResolutionStatus && input.decision?.persistedTarget) {
+    const persisted = persistedDecisionTarget(db, input.decision.persistedTarget);
+    if (persisted) decision.persistedTarget = persisted;
+  }
+  removeEquivalentCompactPersistedDecision(decision);
+  return decision;
+}
+function persistedDecisionTarget(db, target) {
+  const numeric2 = numericId(target.id);
+  if (target.kind === "operation" && numeric2 !== void 0)
+    return operationNode2(db, numeric2)?.decisionTarget;
+  if (target.kind === "symbol" && numeric2 !== void 0)
+    return symbolNode2(db, numeric2)?.decisionTarget;
+  if (target.kind === "handler_method" && numeric2 !== void 0)
+    return handlerNode(db, numeric2)?.decisionTarget;
+  return projectCompactDecisionTarget(target.kind, target.id);
+}
+function resolveEndpoint(db, endpoint, ordinal, side, site) {
+  if (endpoint.kind === "operation")
+    return resolvedOrUnavailable(
+      operationNode2(db, endpoint.operationId),
+      side,
+      "operation",
+      ordinal,
+      site
+    );
+  if (endpoint.kind === "symbol")
+    return resolvedOrUnavailable(
+      symbolNode2(db, endpoint.symbolId),
+      side,
+      "symbol",
+      ordinal,
+      site
+    );
+  if (endpoint.kind === "handler_method")
+    return resolvedOrUnavailable(
+      handlerNode(db, endpoint.handlerMethodId),
+      side,
+      "handler_method",
+      ordinal,
+      site
+    );
+  if (endpoint.kind === "event") return eventNode(endpoint.workspaceId, endpoint.eventName);
+  if (endpoint.kind === "target") return targetNode(db, endpoint, ordinal, side, site);
+  if (endpoint.kind === "call_site") return callSiteNode(db, endpoint);
+  if (endpoint.kind === "scope") return scopeNode(db, endpoint);
+  return unavailableNode(
+    endpoint.side,
+    endpoint.endpointKind,
+    endpoint.detailedEdgeIndex,
+    endpoint.site ?? site
+  );
+}
+function resolvedOrUnavailable(node, side, kind, ordinal, site) {
+  return node ?? unavailableNode(side, kind, ordinal, site);
+}
+function operationNode2(db, operationId) {
+  const row = db.prepare(`SELECT o.id,o.operation_name operationName,
+      o.operation_path operationPath,o.source_file sourceFile,o.source_line sourceLine,
+      s.service_path servicePath,r.workspace_id workspaceId,r.relative_path relativePath,
+      r.name repoName
+    FROM cds_operations o JOIN cds_services s ON s.id=o.service_id
+    JOIN repositories r ON r.id=s.repo_id WHERE o.id=?`).get(operationId);
+  if (!row) return void 0;
+  const operationPath = stringValue15(row.operationPath);
+  const servicePath = stringValue15(row.servicePath);
+  const repo = repositoryLabel(row);
+  const workspaceId = numberValue11(row.workspaceId);
+  if (!operationPath) return void 0;
+  if (!servicePath) return void 0;
+  if (!repo) return void 0;
+  if (workspaceId === void 0) return void 0;
+  const operationName = stringValue15(row.operationName);
+  return {
+    key: canonicalKey("operation", workspaceId, repo, servicePath, operationPath),
+    kind: "operation",
+    label: `${servicePath}:${operationName || operationPath}`,
+    repo,
+    file: stringValue15(row.sourceFile),
+    line: numberValue11(row.sourceLine),
+    synthetic: false,
+    decisionTarget: projectCompactDecisionTarget(
+      "operation",
+      `${repo}:${servicePath}:${operationPath}`
+    )
+  };
+}
+function symbolNode2(db, symbolId) {
+  const row = db.prepare(`SELECT s.id,s.kind,s.qualified_name qualifiedName,
+      s.source_file sourceFile,s.start_line startLine,s.start_offset startOffset,
+      s.end_offset endOffset,r.workspace_id workspaceId,r.relative_path relativePath,
+      r.name repoName FROM symbols s JOIN repositories r ON r.id=s.repo_id
+    WHERE s.id=?`).get(symbolId);
+  return symbolNodeFromRow(row);
+}
+function symbolNodeFromRow(row) {
+  if (!row) return void 0;
+  const name = stringValue15(row.qualifiedName);
+  const repo = repositoryLabel(row);
+  const file = stringValue15(row.sourceFile);
+  const workspaceId = numberValue11(row.workspaceId);
+  if (!name) return void 0;
+  if (!repo) return void 0;
+  if (!file) return void 0;
+  if (workspaceId === void 0) return void 0;
+  const startOffset = numberValue11(row.startOffset);
+  const endOffset = numberValue11(row.endOffset);
+  return {
+    key: canonicalKey(
+      "symbol",
+      workspaceId,
+      repo,
+      file,
+      startOffset,
+      endOffset,
+      name
+    ),
+    kind: "symbol",
+    label: name,
+    repo,
+    file,
+    line: numberValue11(row.startLine),
+    synthetic: false,
+    decisionTarget: projectCompactDecisionTarget(
+      "symbol",
+      `${repo}:${file}:${startOffset ?? ""}:${endOffset ?? ""}:${name}`
+    )
+  };
+}
+function handlerNode(db, handlerMethodId) {
+  const symbol = db.prepare(`SELECT s.kind,s.qualified_name qualifiedName,
+      s.source_file sourceFile,s.start_line startLine,s.start_offset startOffset,
+      s.end_offset endOffset,r.workspace_id workspaceId,r.relative_path relativePath,
+      r.name repoName
+    FROM handler_methods hm JOIN handler_classes hc ON hc.id=hm.handler_class_id
+    JOIN repositories r ON r.id=hc.repo_id LEFT JOIN symbols s
+      ON s.repo_id=hc.repo_id AND s.source_file=hc.source_file
+      AND s.qualified_name=hc.class_name || '.' || hm.method_name
+      AND s.start_line=hm.source_line WHERE hm.id=?
+    ORDER BY s.id LIMIT 1`).get(handlerMethodId);
+  const resolved3 = symbolNodeFromRow(symbol);
+  return resolved3 ?? standaloneHandlerNode(db, handlerMethodId);
+}
+function standaloneHandlerNode(db, handlerMethodId) {
+  const row = db.prepare(`SELECT hm.method_name methodName,hm.source_file sourceFile,
+      hm.source_line sourceLine,hc.class_name className,r.workspace_id workspaceId,
+      r.relative_path relativePath,r.name repoName FROM handler_methods hm
+    JOIN handler_classes hc ON hc.id=hm.handler_class_id
+    JOIN repositories r ON r.id=hc.repo_id WHERE hm.id=?`).get(handlerMethodId);
+  if (!row) return void 0;
+  const methodName2 = stringValue15(row.methodName);
+  const className = stringValue15(row.className);
+  const repo = repositoryLabel(row);
+  const file = stringValue15(row.sourceFile);
+  const workspaceId = numberValue11(row.workspaceId);
+  if (!methodName2) return void 0;
+  if (!className) return void 0;
+  if (!repo) return void 0;
+  if (!file) return void 0;
+  if (workspaceId === void 0) return void 0;
+  const sourceLine2 = numberValue11(row.sourceLine);
+  return {
+    key: canonicalKey(
+      "handler_method",
+      workspaceId,
+      repo,
+      file,
+      sourceLine2,
+      className,
+      methodName2
+    ),
+    kind: "handler_method",
+    label: `${className}.${methodName2}`,
+    repo,
+    file,
+    line: sourceLine2,
+    synthetic: false,
+    decisionTarget: projectCompactDecisionTarget(
+      "handler_method",
+      `${repo}:${file}:${sourceLine2 ?? ""}:${className}.${methodName2}`
+    )
+  };
+}
+function eventNode(workspaceId, eventName) {
+  return {
+    key: canonicalKey("event", workspaceId, eventName),
+    kind: "event",
+    label: eventName,
+    synthetic: false,
+    decisionTarget: projectCompactDecisionTarget("event", eventName)
+  };
+}
+function targetNode(db, endpoint, ordinal, side, site) {
+  const linked = linkedTargetNode(db, endpoint.targetKind, endpoint.targetId);
+  if (linked !== void 0)
+    return linked ?? unavailableNode(side, endpoint.targetKind, ordinal, site);
+  const repo = endpoint.repositoryId === void 0 ? void 0 : repositoryById(db, endpoint.repositoryId);
+  return {
+    key: canonicalKey(
+      "target",
+      endpoint.workspaceId,
+      repo,
+      endpoint.targetKind,
+      endpoint.targetId
+    ),
+    kind: compactTargetKind(endpoint.targetKind),
+    label: endpoint.targetId || endpoint.targetKind,
+    repo,
+    synthetic: false,
+    decisionTarget: projectCompactDecisionTarget(endpoint.targetKind, endpoint.targetId)
+  };
+}
+function linkedTargetNode(db, kind, id) {
+  const numeric2 = numericId(id);
+  if (kind === "operation") {
+    if (numeric2 === void 0) return null;
+    return operationNode2(db, numeric2) ?? null;
+  }
+  if (kind === "symbol") {
+    if (numeric2 === void 0) return null;
+    return symbolNode2(db, numeric2) ?? null;
+  }
+  if (kind === "handler_method") {
+    if (numeric2 === void 0) return null;
+    return handlerNode(db, numeric2) ?? null;
+  }
+  return void 0;
+}
+function callSiteNode(db, endpoint) {
+  const repo = repositoryById(db, endpoint.repositoryId) ?? endpoint.repositoryName;
+  const span = endpoint.startOffset === void 0 || endpoint.endOffset === void 0 ? ["line", endpoint.sourceLine] : [endpoint.startOffset, endpoint.endOffset];
+  return {
+    key: canonicalKey(
+      "call_site",
+      endpoint.workspaceId,
+      repo,
+      endpoint.sourceFile,
+      ...span,
+      endpoint.callId
+    ),
+    kind: "call_site",
+    label: `${repo}:${endpoint.sourceFile}:${endpoint.sourceLine}`,
+    repo,
+    file: endpoint.sourceFile,
+    line: endpoint.sourceLine,
+    synthetic: false,
+    decisionTarget: projectCompactDecisionTarget(
+      "call_site",
+      `${repo}:${endpoint.sourceFile}:${span.join(":")}`
+    )
+  };
+}
+function scopeNode(db, endpoint) {
+  const repo = endpoint.repositoryId === void 0 ? void 0 : repositoryById(db, endpoint.repositoryId);
+  const files = sortedUnique(endpoint.sourceFiles);
+  const symbols = sortedUnique(endpoint.symbolIds.flatMap((id) => {
+    const key = symbolNode2(db, id)?.key;
+    return key ? [key] : [];
+  }));
+  const identity = canonicalKey("scope", endpoint.workspaceId, repo, files, symbols);
+  return {
+    key: symbols.length > 0 || files.length > 0 ? identity : canonicalKey("scope", endpoint.workspaceId, repo, endpoint.structuralKey),
+    kind: "scope",
+    label: repo ? `scope:${repo}` : "scope:workspace",
+    repo,
+    file: files.length === 1 ? files[0] : void 0,
+    synthetic: false,
+    decisionTarget: projectCompactDecisionTarget("scope", identity)
+  };
+}
+function unavailableNode(side, endpointKind, ordinal, site) {
+  return {
+    key: canonicalKey(
+      "unavailable",
+      side,
+      endpointKind,
+      site?.repository,
+      site?.sourceFile,
+      site?.startOffset,
+      site?.endOffset,
+      site?.sourceLine,
+      ordinal
+    ),
+    kind: "synthetic",
+    label: `${side}:${compactSafeCode(endpointKind) ?? "unavailable"}`,
+    repo: site?.repository,
+    file: site?.sourceFile,
+    line: site?.sourceLine,
+    synthetic: true
+  };
+}
+function aggregateObservations(items) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const key = aggregationKey(item);
+    const current = groups.get(key);
+    if (current) appendAggregate(current, item);
+    else groups.set(key, createAggregate(item));
+  }
+  return [...groups.values()].map(finalizeAggregate);
+}
+function aggregationKey(item) {
+  return JSON.stringify([
+    item.input.step,
+    item.input.type,
+    item.source.key,
+    item.target.key,
+    item.input.status,
+    normalizedConfidence(item.input.confidence),
+    item.decision
+  ]);
+}
+function createAggregate(item) {
+  return {
+    source: item.source,
+    target: item.target,
+    step: item.input.step,
+    type: item.input.type,
+    status: item.input.status,
+    confidence: normalizedConfidence(item.input.confidence),
+    decision: item.decision,
+    ordinals: [item.input.ordinal],
+    refs: item.input.refs ? [item.input.refs] : [],
+    site: item.input.site
+  };
+}
+function appendAggregate(group, item) {
+  group.ordinals.push(item.input.ordinal);
+  if (item.input.refs) group.refs.push(item.input.refs);
+  if (compareSite(item.input.site, group.site) < 0) group.site = item.input.site;
+}
+function finalizeAggregate(group) {
+  group.ordinals.sort((left, right) => left - right);
+  return group;
+}
+function canonicalNodes(items) {
+  const nodes = /* @__PURE__ */ new Map();
+  for (const node of items.flatMap((item) => [item.source, item.target])) {
+    const existing = nodes.get(node.key);
+    if (!existing || compareNodeBody(node, existing) < 0) nodes.set(node.key, node);
+  }
+  return [...nodes.values()].sort((left, right) => compareBinary(left.key, right.key));
+}
+function compactNodeRows(nodes, repos, files) {
+  const repoIndexes = indexMap(repos);
+  const fileIndexes = indexMap(files);
+  return nodes.map((node, index) => [
+    `n${index}`,
+    node.kind,
+    redactText(node.label),
+    node.repo === void 0 ? null : repoIndexes.get(node.repo) ?? null,
+    node.file === void 0 ? null : fileIndexes.get(node.file) ?? null,
+    node.line ?? null
+  ]);
+}
+function compactEdgeRows(groups, nodes) {
+  const nodeIndexes = new Map(nodes.map((node, index) => [node.key, index]));
+  const sorted = [...groups].sort((left, right) => compareAggregate(left, right, nodeIndexes));
+  return sorted.map((group, index) => edgeRow(group, index, nodeIndexes));
+}
+function edgeRow(group, index, nodeIndexes) {
+  const source = nodeIndexes.get(group.source.key);
+  const target = nodeIndexes.get(group.target.key);
+  if (source === void 0 || target === void 0) throw compactError("edge_node_missing");
+  return [
+    `e${index}`,
+    group.ordinals,
+    group.step,
+    group.type,
+    `n${source}`,
+    `n${target}`,
+    group.status,
+    group.confidence,
+    group.ordinals.length,
+    edgeDetails(group)
+  ];
+}
+function edgeDetails(group) {
+  const refs = projectReferences(group.refs);
+  if (Object.keys(group.decision).length === 0 && Object.keys(refs).length === 0) return null;
+  return { decision: group.decision, refs };
+}
+function projectReferences(values) {
+  const out = {};
+  setReference(out, "graphEdgeIds", values.flatMap((item) => item.graphEdgeIds ?? []));
+  setReference(out, "outboundCallIds", values.flatMap((item) => item.outboundCallIds ?? []));
+  setReference(out, "subscribeCallIds", values.flatMap((item) => item.subscribeCallIds ?? []));
+  setReference(out, "symbolCallIds", values.flatMap((item) => item.symbolCallIds ?? []));
+  setReference(out, "operationIds", values.flatMap((item) => item.operationIds ?? []));
+  setReference(out, "symbolIds", values.flatMap((item) => item.symbolIds ?? []));
+  setReference(out, "handlerMethodIds", values.flatMap((item) => item.handlerMethodIds ?? []));
+  return out;
+}
+function setReference(out, key, values) {
+  const unique3 = uniqueReferences(values);
+  if (unique3.length === 0) return;
+  const shown = unique3.slice(0, REFERENCE_LIMIT);
+  out[key] = {
+    values: shown,
+    total: unique3.length,
+    shown: shown.length,
+    omitted: unique3.length - shown.length
+  };
+}
+function compactDiagnosticRows(diagnostics, files) {
+  const fileIndexes = indexMap(files);
+  return diagnostics.map((item) => [
+    item.index,
+    item.severity,
+    item.code,
+    item.message,
+    item.file === void 0 ? null : fileIndexes.get(item.file) ?? null,
+    item.line ?? null,
+    item.details ?? null
+  ]);
+}
+function compactResult(input, resolvedNodes, nodes, edges, diagnostics, repos, files) {
+  const statusCounts = compactStatusCounts(input.observations);
+  return {
+    schema: "service-flow/compact-graph@1",
+    start: projectCompactStart(input.start),
+    query: projectCompactQuery(input.options),
+    source: input.source,
+    summary: {
+      completeness: compactCompleteness(statusCounts, diagnostics),
+      fullTraceNodes: input.trace.nodes.length,
+      fullTraceEdges: input.trace.edges.length,
+      fullTraceDiagnostics: input.trace.diagnostics.length,
+      nodes: nodes.length,
+      edges: edges.length,
+      collapsedEdges: input.trace.edges.length - edges.length,
+      statusCounts,
+      projection: {
+        evidence: "summary-only",
+        syntheticEndpoints: resolvedNodes.filter((node) => node.synthetic).length,
+        omittedUnreferencedFullNodes: omittedDetailedNodeCount(input)
+      }
+    },
+    repos,
+    files,
+    nodeColumns: ["id", "kind", "label", "repo", "file", "line"],
+    nodes,
+    edgeColumns: [
+      "id",
+      "traceOrdinals",
+      "step",
+      "type",
+      "from",
+      "to",
+      "status",
+      "confidence",
+      "count",
+      "details"
+    ],
+    edges,
+    diagnosticColumns: [
+      "fullDiagnosticIndex",
+      "severity",
+      "code",
+      "message",
+      "file",
+      "line",
+      "details"
+    ],
+    diagnostics
+  };
+}
+function omittedDetailedNodeCount(input) {
+  const referenced = new Set(input.observations.flatMap((item) => [
+    ...detailedNodeIds(item.source),
+    ...detailedNodeIds(item.target)
+  ]));
+  return input.trace.nodes.filter((node) => {
+    const id = typeof node.id === "string" ? node.id : void 0;
+    return id === void 0 || !referenced.has(id);
+  }).length;
+}
+function detailedNodeIds(endpoint) {
+  if (endpoint.kind === "operation") return [`operation:${endpoint.operationId}`];
+  if (endpoint.kind === "symbol") return [`symbol:${endpoint.symbolId}`];
+  if (endpoint.kind === "handler_method")
+    return [`handler_method:${endpoint.handlerMethodId}`];
+  if (endpoint.kind === "event") return [`event:${endpoint.eventName}`];
+  if (endpoint.kind === "target") return [`${endpoint.targetKind}:${endpoint.targetId}`];
+  if (endpoint.kind === "call_site") return [`call:${endpoint.callId}`];
+  if (endpoint.kind === "scope")
+    return endpoint.symbolIds.map((symbolId) => `symbol:${symbolId}`);
+  return [];
+}
+function validateObservationOrdinals(observations, fullEdgeCount) {
+  const ordinals = observations.map((item) => item.ordinal).sort((left, right) => left - right);
+  if (ordinals.length !== fullEdgeCount) throw compactError("observation_count_mismatch");
+  if (ordinals.some((value, index) => value !== index))
+    throw compactError("trace_ordinal_partition_invalid");
+}
+function validateCompactResult(result) {
+  if (result.summary.nodes !== result.nodes.length) throw compactError("node_count_mismatch");
+  if (result.summary.edges !== result.edges.length) throw compactError("edge_count_mismatch");
+  const statusTotal = compactStatusTotal(result.summary.statusCounts);
+  if (statusTotal !== result.summary.fullTraceEdges) throw compactError("status_count_mismatch");
+  const edgeTotal = result.edges.reduce((sum, edge) => sum + edge[8], 0);
+  if (edgeTotal !== result.summary.fullTraceEdges) throw compactError("edge_member_count_mismatch");
+  if (result.edges.some((edge) => edge.length !== 10 || edge[8] !== edge[1].length))
+    throw compactError("edge_tuple_invalid");
+  if (result.nodes.some((node) => node.length !== 6)) throw compactError("node_tuple_invalid");
+  if (result.diagnostics.some((item) => item.length !== 7)) throw compactError("diagnostic_tuple_invalid");
+  validateResultOrdinals(result);
+}
+function validateResultOrdinals(result) {
+  const ordinals = result.edges.flatMap((edge) => edge[1]).sort((left, right) => left - right);
+  if (ordinals.some((value, index) => value !== index) || ordinals.length !== result.summary.fullTraceEdges)
+    throw compactError("output_trace_ordinal_partition_invalid");
+  if (result.summary.collapsedEdges !== result.summary.fullTraceEdges - result.summary.edges)
+    throw compactError("collapsed_edge_count_mismatch");
+}
+function compareAggregate(left, right, nodeIndexes) {
+  return left.step - right.step || indexFor(nodeIndexes, left.source.key) - indexFor(nodeIndexes, right.source.key) || indexFor(nodeIndexes, left.target.key) - indexFor(nodeIndexes, right.target.key) || compareBinary(left.type, right.type) || compareBinary(left.status, right.status) || compareSite(left.site, right.site) || (left.ordinals[0] ?? 0) - (right.ordinals[0] ?? 0);
+}
+function compareSite(left, right) {
+  return compareBinary(siteSortKey(left), siteSortKey(right));
+}
+function siteSortKey(site) {
+  return JSON.stringify([
+    site?.repository ?? "",
+    site?.sourceFile ?? "",
+    sortableNumber(site?.startOffset),
+    sortableNumber(site?.endOffset),
+    sortableNumber(site?.sourceLine)
+  ]);
+}
+function sortableNumber(value) {
+  return value === void 0 ? "z" : `n${String(value).padStart(16, "0")}`;
+}
+function compareNodeBody(left, right) {
+  return compareBinary(JSON.stringify([
+    left.kind,
+    left.label,
+    left.repo,
+    left.file,
+    left.line
+  ]), JSON.stringify([
+    right.kind,
+    right.label,
+    right.repo,
+    right.file,
+    right.line
+  ]));
+}
+function compactTargetKind(kind) {
+  if (kind === "db_entity") return "database_entity";
+  if (kind === "operation_candidate") return "dynamic_target";
+  if (kind === "symbol_reference" || kind === "subscription_handler")
+    return "unresolved_target";
+  return compactSafeCode(kind) ?? "target";
+}
+function repositoryById(db, repositoryId) {
+  const row = db.prepare("SELECT relative_path relativePath,name repoName FROM repositories WHERE id=?").get(repositoryId);
+  return repositoryLabel(row);
+}
+function repositoryLabel(row) {
+  return stringValue15(row?.relativePath) ?? stringValue15(row?.repoName);
+}
+function normalizedConfidence(value) {
+  return Number.isFinite(value) ? Math.max(0, Math.min(1, value)) : 0;
+}
+function numericId(value) {
+  return /^\d+$/.test(value) ? Number(value) : void 0;
+}
+function numberValue11(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function stringValue15(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function uniqueReferences(values) {
+  const unique3 = new Map(values.map((value) => [`${typeof value}:${String(value)}`, value]));
+  return [...unique3.values()].sort((left, right) => {
+    if (typeof left === "number" && typeof right === "number") return left - right;
+    return compareBinary(`${typeof left}:${String(left)}`, `${typeof right}:${String(right)}`);
+  });
+}
+function sortedUnique(values) {
+  return [...new Set(values)].sort(compareBinary);
+}
+function canonicalKey(...parts) {
+  return JSON.stringify(parts);
+}
+function indexMap(values) {
+  return new Map(values.map((value, index) => [value, index]));
+}
+function indexFor(values, key) {
+  const value = values.get(key);
+  if (value === void 0) throw compactError("canonical_node_index_missing");
+  return value;
+}
+function compactError(code) {
+  return new Error(`compact_graph_invariant:${code}`);
+}
+
+// src/trace/018-compact-trace.ts
+function compactTrace(db, start, options) {
+  return traceAndCompact(db, start, options).compact;
+}
+function traceAndCompact(db, start, options) {
+  const collector = new CompactObservationCollector();
+  const trace2 = traceWithObserver(db, start, options, collector);
+  const source = compactSourceContext(db, options, collector.workspaceId);
+  const compact = projectCompactGraph({
+    db,
+    start,
+    options,
+    source,
+    trace: trace2,
+    observations: collector.observations
+  });
+  return { trace: trace2, compact };
+}
+function compactSourceContext(db, options, traversalWorkspaceId) {
+  return {
+    schemaVersion: schemaVersion2(db),
+    analyzerVersion: sourceAnalyzerVersion(
+      db,
+      traversalWorkspaceId ?? options.workspaceId
+    ),
+    graphGeneration: graphGeneration(
+      db,
+      traversalWorkspaceId ?? options.workspaceId
+    )
+  };
+}
+function sourceAnalyzerVersion(db, workspaceId) {
+  const rows2 = db.prepare(`SELECT DISTINCT
+      COALESCE(fact_analyzer_version,'legacy_unknown') analyzerVersion
+    FROM repositories WHERE (? IS NULL OR workspace_id=?)
+    ORDER BY analyzerVersion COLLATE BINARY LIMIT 2`).all(
+    workspaceId,
+    workspaceId
+  );
+  if (rows2.length === 0) return "none";
+  if (rows2.length > 1) return "mixed";
+  return stringValue16(rows2[0]?.analyzerVersion) ?? "legacy_unknown";
+}
+function graphGeneration(db, workspaceId) {
+  if (workspaceId === void 0) return 0;
+  const rows2 = db.prepare(`SELECT DISTINCT graph_generation generation
+    FROM repositories WHERE workspace_id=?
+    ORDER BY graph_generation LIMIT 2`).all(workspaceId);
+  return rows2.length === 1 ? numberValue12(rows2[0]?.generation) ?? 0 : 0;
+}
+function schemaVersion2(db) {
+  const row = db.pragma("user_version")[0];
+  return numberValue12(row?.user_version) ?? CURRENT_SCHEMA_VERSION;
+}
+function numberValue12(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function stringValue16(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
 
 export {
+  migrate,
+  VERSION,
+  ANALYZER_VERSION,
   projectBoundedInOrder,
+  insertSymbolCalls,
+  insertCalls,
   upsertWorkspace,
   getWorkspace,
   upsertRepository,
@@ -8998,8 +12118,6 @@ export {
   insertRegistrations,
   insertBindings,
   insertExecutableSymbols,
-  insertSymbolCalls,
-  insertCalls,
   normalizePath,
   stripQuotes,
   discoverRepositories,
@@ -9014,6 +12132,7 @@ export {
   normalizeODataOperationInvocationPath,
   classifyODataPathIntent,
   parseServiceBindings,
+  classifyOutboundCallsInSource,
   containsSupportedOutboundCall,
   parseOutboundCalls,
   applyVariables,
@@ -9021,9 +12140,12 @@ export {
   substituteVariables,
   parseImplementationHint,
   implementationHintSuggestions,
+  factLifecycleDiagnostic,
   linkWorkspace,
   parseVars,
   selectorRepoAmbiguousDiagnostic,
-  trace
+  trace,
+  compactTrace,
+  traceAndCompact
 };
-//# sourceMappingURL=chunk-TBH33OYC.js.map
+//# sourceMappingURL=chunk-TOVX4WYH.js.map