@saptools/service-flow 0.1.52 → 0.1.54

package/dist/{chunk-PTLDSHRC.js → chunk-ERIZHM5C.js}

@@ -1,5 +1,128 @@
 #!/usr/bin/env node
 
+// src/utils/000-bounded-projection.ts
+var DEFAULT_EVIDENCE_CANDIDATE_LIMIT = 5;
+function projectBounded(values, compare, limit = DEFAULT_EVIDENCE_CANDIDATE_LIMIT) {
+  const normalizedLimit = positiveLimit(limit);
+  const sorted = [...values].sort(compare);
+  const items = sorted.slice(0, normalizedLimit);
+  return {
+    totalCount: sorted.length,
+    shownCount: items.length,
+    omittedCount: Math.max(0, sorted.length - items.length),
+    items
+  };
+}
+function projectBoundedInOrder(values, limit = DEFAULT_EVIDENCE_CANDIDATE_LIMIT) {
+  const normalizedLimit = positiveLimit(limit);
+  const items = values.slice(0, normalizedLimit);
+  return {
+    totalCount: values.length,
+    shownCount: items.length,
+    omittedCount: Math.max(0, values.length - items.length),
+    items
+  };
+}
+function positiveLimit(value) {
+  return Number.isFinite(value) && Number(value) > 0 ? Math.floor(Number(value)) : DEFAULT_EVIDENCE_CANDIDATE_LIMIT;
+}
+var candidateLikeCollections = /* @__PURE__ */ new Set([
+  "candidates",
+  "candidateScores",
+  "candidateFamilies",
+  "candidateEvidence",
+  "candidatePaths",
+  "candidateRawPaths",
+  "candidateNormalizedOperationPaths",
+  "normalizedCandidateOperations",
+  "candidateLiterals",
+  "bindingCandidates",
+  "bindingAlternatives",
+  "implementationHintSuggestions",
+  "selectableImplementationRepositories",
+  "matchedHints",
+  "candidateSuggestions",
+  "dynamicTargetCandidates",
+  "dynamicTargetCandidateSuggestions",
+  "rejectedCandidates",
+  "suggestedVarSets",
+  "copyableExamples",
+  "selectorSuggestions",
+  "serviceSuggestions",
+  "repositories",
+  "examples",
+  "expandedExamples",
+  "registrations"
+]);
+function boundCandidateLikeEvidence(evidence, limit = DEFAULT_EVIDENCE_CANDIDATE_LIMIT) {
+  const output = {};
+  for (const [key, value] of Object.entries(evidence)) {
+    if (!Array.isArray(value) || !candidateLikeCollections.has(key)) {
+      output[key] = boundNestedEvidence(value, limit);
+      continue;
+    }
+    const projection = projectBoundedInOrder(value, limit);
+    output[key] = projection.items.map((item) => boundNestedEvidence(item, limit));
+    addCollectionCounts(output, evidence, key, projection);
+  }
+  return output;
+}
+function boundNestedEvidence(value, limit) {
+  if (Array.isArray(value)) return value.map((item) => boundNestedEvidence(item, limit));
+  if (!isEvidenceRecord(value)) return value;
+  return boundCandidateLikeEvidence(value, limit);
+}
+function isEvidenceRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function addCollectionCounts(output, input, key, projection) {
+  const stem = collectionStem(key);
+  const countName = `${stem}Count`;
+  const shownName = `shown${upperFirst(stem)}Count`;
+  const omittedName = `omitted${upperFirst(stem)}Count`;
+  const total = Math.max(numericValue(input[countName]), projection.totalCount);
+  output[countName] = total;
+  output[shownName] = projection.shownCount;
+  output[omittedName] = Math.max(0, total - projection.shownCount);
+}
+function collectionStem(key) {
+  const stems = {
+    candidates: "candidate",
+    candidateScores: "candidateScore",
+    candidateFamilies: "candidateFamily",
+    candidateEvidence: "candidateEvidence",
+    candidatePaths: "candidatePath",
+    candidateRawPaths: "candidateRawPath",
+    candidateNormalizedOperationPaths: "candidateNormalizedOperationPath",
+    normalizedCandidateOperations: "normalizedCandidateOperation",
+    candidateLiterals: "candidateLiteral",
+    bindingCandidates: "bindingCandidate",
+    bindingAlternatives: "bindingAlternative",
+    implementationHintSuggestions: "implementationHintSuggestion",
+    selectableImplementationRepositories: "selectableImplementationRepository",
+    matchedHints: "matchedHint",
+    candidateSuggestions: "candidateSuggestion",
+    dynamicTargetCandidates: "dynamicTargetCandidate",
+    dynamicTargetCandidateSuggestions: "dynamicTargetCandidateSuggestion",
+    rejectedCandidates: "rejectedCandidate",
+    suggestedVarSets: "suggestedVarSet",
+    copyableExamples: "copyableExample",
+    selectorSuggestions: "selectorSuggestion",
+    serviceSuggestions: "serviceSuggestion",
+    repositories: "repository",
+    examples: "example",
+    expandedExamples: "expandedExample",
+    registrations: "registration"
+  };
+  return stems[key] ?? "candidate";
+}
+function numericValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function upperFirst(value) {
+  return value ? `${value[0]?.toUpperCase() ?? ""}${value.slice(1)}` : value;
+}
+
 // src/db/repositories.ts
 function upsertWorkspace(db, rootPath, dbPath) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -337,8 +460,8 @@ function insertCalls(db, repoId, rows2) {
 function resolvePersistedBinding(db, repoId, call) {
   if (!call.serviceVariableName)
     return { bindingId: null, evidence: { status: "not_applicable", candidateCount: 0 } };
-  const candidates = bindingCandidates(db, repoId, call);
-  const prior = candidates.filter((candidate) => candidate.sourceLine <= call.sourceLine);
+  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);
@@ -354,11 +477,11 @@ function resolvePersistedBinding(db, repoId, call) {
       evidence: bindingEvidence("ambiguous", prior)
     };
   }
-  if (candidates.length > 0) {
+  if (candidates2.length > 0) {
     return {
       bindingId: null,
       unresolvedReason: "service_binding_declared_after_call",
-      evidence: bindingEvidence("rejected_future_binding", candidates)
+      evidence: bindingEvidence("rejected_future_binding", candidates2)
     };
   }
   return {
@@ -426,13 +549,16 @@ function callSymbolId(db, repoId, call) {
   );
   return typeof row?.id === "number" ? row.id : void 0;
 }
-function bindingEvidence(status, candidates, selected) {
+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: candidates.length,
+    candidateCount: projection.totalCount,
+    shownCandidateCount: projection.shownCount,
+    omittedCandidateCount: projection.omittedCount,
     selectedBindingId: selected?.id,
     sourceOrderRule: "binding_source_line_must_not_follow_call",
-    candidates: candidates.map((candidate) => ({
+    candidates: projection.items.map((candidate) => ({
       bindingId: candidate.id,
       symbolId: candidate.symbolId,
       variableName: candidate.variableName,
@@ -2208,8 +2334,20 @@ function externalHttpTarget(call) {
   const expression = typeof target.expression === "string" ? target.expression : void 0;
   if (kind === "destination" && target.dynamic === true) {
     const shape = typeof target.expressionShape === "string" ? target.expressionShape : "expression";
-    const candidates = Array.isArray(target.candidateLiterals) ? target.candidateLiterals.filter((item) => typeof item === "string") : [];
-    return { kind, toKind: "external_destination", toId: `destination:dynamic:${hash(`${shape}:${candidates.join("|")}`)}`, label: "External destination: dynamic destination", method, dynamic: true, expression: candidates.length ? `candidates:${candidates.join("|")}` : `shape:${shape}` };
+    const candidates2 = staticDestinationCandidates(target.candidateLiterals);
+    const projection = projectBounded(candidates2, (left, right) => left.localeCompare(right));
+    return {
+      kind,
+      toKind: "external_destination",
+      toId: `destination:dynamic:${hash(`${shape}:${candidates2.join("|")}`)}`,
+      label: "External destination: dynamic destination",
+      method,
+      dynamic: true,
+      expression: projection.items.length ? `candidates:${projection.items.join("|")}` : `shape:${shape}`,
+      candidateLiteralCount: projection.totalCount,
+      shownCandidateLiteralCount: projection.shownCount,
+      omittedCandidateLiteralCount: projection.omittedCount
+    };
   }
   if (kind === "destination" && expression) return { kind, toKind: "external_destination", toId: `destination:${expression}`, label: `External destination: ${expression}`, method, dynamic: false, expression };
   if (kind === "static_url" && expression) {
@@ -2219,6 +2357,10 @@ function externalHttpTarget(call) {
   if (kind === "url_expression" && expression) return { kind, toKind: "external_endpoint", toId: `dynamic:${hash(expression)}`, label: `External endpoint: ${methodPrefix(method)}dynamic URL`, method, dynamic: true, expression: `expr:${hash(expression)}` };
   return { kind: "unknown", toKind: "external_endpoint", toId: "unknown", label: "External endpoint: unknown", method, dynamic: false };
 }
+function staticDestinationCandidates(value) {
+  const candidates2 = Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+  return [...new Set(candidates2)].sort();
+}
 function safeParse(value) {
   try {
     const parsed = JSON.parse(value);
@@ -3115,8 +3257,8 @@ function destinationTargetFromExpression(expr, use) {
   const resolved3 = resolveExpression(expr, use, "external");
   const text = resolved3.value;
   if (resolved3.status === "static" && text && !hasTemplatePlaceholder(text)) return { kind: "destination", expression: text, dynamic: false, sourceKind: resolved3.sourceKind };
-  const candidates = staticConditionalCandidates(expr, /* @__PURE__ */ new Map());
-  if (candidates) return { kind: "destination", dynamic: true, expressionShape: "conditional", candidateLiterals: candidates };
+  const candidates2 = staticConditionalCandidates(expr, /* @__PURE__ */ new Map());
+  if (candidates2) return { kind: "destination", dynamic: true, expressionShape: "conditional", candidateLiterals: candidates2 };
   const shape = destinationExpressionShape(expr);
   if (shape) return { kind: "destination", dynamic: true, expressionShape: shape };
   return void 0;
@@ -3448,6 +3590,22 @@ function applyVariables(template, vars) {
 function extractPlaceholders(template) {
   return [...(template ?? "").matchAll(PLACEHOLDER)].map((m) => (m[1] ?? "").trim()).filter(Boolean);
 }
+function matchRuntimeTemplate(template, concrete) {
+  if (!template || !concrete) return void 0;
+  const keys = extractPlaceholders(template);
+  if (keys.length === 0) return template === concrete ? {} : void 0;
+  const match = new RegExp(`^${runtimeTemplatePattern(template)}$`).exec(concrete);
+  if (!match) return void 0;
+  const values = {};
+  for (let index = 0; index < keys.length; index += 1) {
+    const key = keys[index];
+    const value = match[index + 1];
+    if (!key || value === void 0) return void 0;
+    if (values[key] !== void 0 && values[key] !== value) return void 0;
+    values[key] = value;
+  }
+  return values;
+}
 function substituteVariables(template, vars) {
   if (!template) return { placeholders: [], missing: [], supplied: [], changed: false };
   const placeholders3 = [...new Set(extractPlaceholders(template))];
@@ -3466,6 +3624,19 @@ function substituteVariables(template, vars) {
     changed: effective !== template
   };
 }
+function runtimeTemplatePattern(template) {
+  let pattern = "";
+  let lastIndex = 0;
+  for (const match of template.matchAll(PLACEHOLDER)) {
+    pattern += escapeRegex(template.slice(lastIndex, match.index));
+    pattern += "([^/]+?)";
+    lastIndex = (match.index ?? 0) + match[0].length;
+  }
+  return `${pattern}${escapeRegex(template.slice(lastIndex))}`;
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 
 // src/trace/implementation-hints.ts
 function parseImplementationHint(value) {
@@ -3478,8 +3649,8 @@ function parseImplementationHint(value) {
   if (!hint.implementationRepo) throw new Error("Scoped implementation hint requires an implementation repo selection");
   return { ...hint, implementationRepo: hint.implementationRepo };
 }
-function selectImplementation(rawEvidence, hints, legacyRepo) {
-  const evidence = asEvidence(rawEvidence);
+function selectImplementation(rawEvidence, hints, legacyRepo, canonicalEvidence) {
+  const evidence = asEvidence(canonicalEvidence ?? rawEvidence);
   const scoped = hints ?? [];
   const matchingHints = scoped.filter((hint2) => hintMatchesEdge(hint2, evidence));
   if (matchingHints.length === 0) {
@@ -3488,38 +3659,60 @@ function selectImplementation(rawEvidence, hints, legacyRepo) {
     return { blocksAutomatic: false, evidence: { status: "not_matched", reason, strategy: "scoped_implementation_hint" } };
   }
   if (matchingHints.length > 1) {
+    const projection = projectBounded(matchingHints, compareHints);
     return {
       blocksAutomatic: true,
       evidence: {
         status: "tied",
         reason: "multiple_scoped_hints_matched_edge",
         strategy: "scoped_implementation_hint",
-        matchedHints: matchingHints,
-        candidateCount: matchingHints.length
+        matchedHints: projection.items,
+        candidateCount: matchingHints.length,
+        matchedHintCount: projection.totalCount,
+        shownMatchedHintCount: projection.shownCount,
+        omittedMatchedHintCount: projection.omittedCount
       }
     };
   }
   const hint = matchingHints[0];
   return hint ? selectCandidate(evidence, hint, "scoped_implementation_hint") : { blocksAutomatic: false, evidence: { status: "not_matched" } };
 }
-function implementationHintDiagnostic(selection, suggestions) {
+function implementationHintDiagnostic(selection, suggestionEvidence) {
   if (!selection.blocksAutomatic || selection.methodId) return void 0;
+  const suggestions = projectedSuggestions(suggestionEvidence);
   return {
     severity: "warning",
     code: "implementation_hint_mismatch",
     message: "Implementation hint did not select exactly one viable candidate",
     hintStatus: selection.evidence.status,
     candidateCount: selection.evidence.candidateCount,
-    implementationHintSuggestions: Array.isArray(suggestions) && suggestions.length > 0 ? suggestions : void 0,
+    implementationHintSuggestions: suggestions.suggestions.length > 0 ? suggestions.suggestions : void 0,
+    implementationHintSuggestionCount: suggestions.suggestionCount,
+    shownImplementationHintSuggestionCount: suggestions.shownSuggestionCount,
+    omittedImplementationHintSuggestionCount: suggestions.omittedSuggestionCount,
     implementationSelection: selection.evidence
   };
 }
 function implementationHintSuggestions(rawEvidence) {
+  return implementationHintSuggestionProjection(rawEvidence).suggestions;
+}
+function implementationHintSuggestionProjection(rawEvidence) {
   const evidence = asEvidence(rawEvidence);
   const accepted = (evidence.candidates ?? []).filter((candidate) => candidate.accepted);
-  if (accepted.length < 2) return [];
+  if (accepted.length < 2) {
+    return {
+      suggestions: [],
+      suggestionCount: 0,
+      shownSuggestionCount: 0,
+      omittedSuggestionCount: 0
+    };
+  }
   const repos = selectableRepositories(accepted);
-  return accepted.flatMap((candidate) => {
+  const repositoryProjection = projectBounded(
+    repos,
+    (left, right) => left.localeCompare(right)
+  );
+  const suggestions = accepted.flatMap((candidate) => {
     const repo = candidate.handlerPackage?.name;
     if (!repo || !repos.includes(repo)) return [];
     const hint = suggestionHint(evidence, candidate, repo);
@@ -3528,16 +3721,58 @@ function implementationHintSuggestions(rawEvidence) {
       operationPath: hint.operationPath,
       ambiguityReason: evidence.ambiguityReasons?.[0],
       candidateFamily: hint.candidateFamily,
-      selectableImplementationRepositories: repos,
+      selectableImplementationRepositories: repositoryProjection.items,
+      selectableImplementationRepositoryCount: repositoryProjection.totalCount,
+      shownSelectableImplementationRepositoryCount: repositoryProjection.shownCount,
+      omittedSelectableImplementationRepositoryCount: repositoryProjection.omittedCount,
       implementationRepo: repo,
       hint,
       cli: `--implementation-hint ${hintString(hint)}`
     }];
   });
+  const projection = projectBounded(suggestions, compareSuggestion);
+  return {
+    suggestions: projection.items,
+    suggestionCount: projection.totalCount,
+    shownSuggestionCount: projection.shownCount,
+    omittedSuggestionCount: projection.omittedCount
+  };
+}
+function projectedSuggestions(value) {
+  const evidence = objectRecord(value);
+  const values = Array.isArray(value) ? recordSuggestions(value) : recordSuggestions(evidence.implementationHintSuggestions);
+  const projection = projectBounded(values, compareSuggestion);
+  const total = Math.max(
+    numericValue2(evidence.implementationHintSuggestionCount),
+    projection.totalCount
+  );
+  return {
+    suggestions: projection.items,
+    suggestionCount: total,
+    shownSuggestionCount: projection.shownCount,
+    omittedSuggestionCount: Math.max(0, total - projection.shownCount)
+  };
+}
+function compareHints(left, right) {
+  return hintString(left).localeCompare(hintString(right));
+}
+function compareSuggestion(left, right) {
+  return String(left.cli ?? "").localeCompare(String(right.cli ?? "")) || String(left.implementationRepo ?? "").localeCompare(
+    String(right.implementationRepo ?? "")
+  );
+}
+function objectRecord(value) {
+  return isRecord(value) ? value : {};
+}
+function recordSuggestions(value) {
+  return Array.isArray(value) ? value.filter((item) => Boolean(item && typeof item === "object" && !Array.isArray(item))) : [];
 }
-function selectableRepositories(candidates) {
-  const repos = new Set(candidates.flatMap((candidate) => candidate.handlerPackage?.name ? [candidate.handlerPackage.name] : []));
-  return [...repos].filter((repo) => candidates.filter((candidate) => candidateMatchesRepo(candidate, repo)).length === 1).sort();
+function numericValue2(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function selectableRepositories(candidates2) {
+  const repos = new Set(candidates2.flatMap((candidate) => candidate.handlerPackage?.name ? [candidate.handlerPackage.name] : []));
+  return [...repos].filter((repo) => candidates2.filter((candidate) => candidateMatchesRepo(candidate, repo)).length === 1).sort();
 }
 function assignHintField(hint, key, value) {
   if (key === "service" || key === "servicePath") hint.servicePath = value;
@@ -3629,7 +3864,45 @@ function legacyHint(implementationRepo) {
   return { implementationRepo };
 }
 function asEvidence(value) {
-  return value;
+  return {
+    servicePath: stringValue3(value.servicePath),
+    operationPath: stringValue3(value.operationPath),
+    ambiguityReasons: stringArray(value.ambiguityReasons),
+    candidateFamilies: candidateFamilies(value.candidateFamilies),
+    candidates: candidates(value.candidates),
+    modelPackage: packageValue(value.modelPackage)
+  };
+}
+function candidates(value) {
+  return recordSuggestions(value).map((candidate) => ({
+    accepted: candidate.accepted === true,
+    methodId: numericValue2(candidate.methodId) || void 0,
+    sourceFile: stringValue3(candidate.sourceFile),
+    handlerPackage: packageValue(candidate.handlerPackage),
+    modelPackage: packageValue(candidate.modelPackage),
+    servicePath: stringValue3(candidate.servicePath),
+    operationPath: stringValue3(candidate.operationPath)
+  }));
+}
+function candidateFamilies(value) {
+  return recordSuggestions(value).map((family) => ({
+    packageName: stringValue3(family.packageName)
+  }));
+}
+function packageValue(value) {
+  const candidate = objectRecord(value);
+  const name = stringValue3(candidate.name);
+  const packageName = stringValue3(candidate.packageName);
+  return name || packageName ? { name, packageName } : void 0;
+}
+function stringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function stringValue3(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
 // src/linker/remote-query-target.ts
@@ -3656,198 +3929,889 @@ function buildRemoteQueryTarget(input) {
   };
 }
 
-// src/linker/service-resolver.ts
-function rows(db, operationPath, workspaceId) {
-  const names = operationLookupNames(operationPath);
-  const result = db.prepare(
-    `SELECT o.id operationId,r.id repoId,r.name repoName,r.package_name packageName,s.service_name serviceName,s.qualified_name qualifiedName,s.service_path servicePath,o.operation_path operationPath,o.operation_name operationName,o.source_file sourceFile,o.source_line sourceLine,0 score
-       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 (o.operation_path IN (?,?) OR o.operation_name IN (?,?)) ORDER BY r.name,s.service_path,o.operation_name`
-  ).all(
-    workspaceId,
-    workspaceId,
-    names.path,
-    names.simplePath,
-    names.name,
-    names.simpleName
-  );
-  return result.map((row) => ({
-    ...row,
-    score: Number(row.score ?? 0),
-    reasons: []
+// src/linker/001-implementation-evidence-projection.ts
+function selectedHandlerProvenance(source) {
+  return {
+    status: "selected",
+    accepted: true,
+    graphTargetId: String(source.methodId),
+    methodId: source.methodId,
+    className: source.className,
+    methodName: source.methodName,
+    repository: {
+      id: source.repositoryId,
+      name: source.repositoryName,
+      packageName: source.repositoryPackageName
+    },
+    sourceFile: source.sourceFile,
+    sourceLine: source.sourceLine
+  };
+}
+function displayImplementationCandidates(candidates2, selectedMethodId) {
+  return [...candidates2].sort((left, right) => compareDisplayCandidate(
+    left,
+    right,
+    selectedMethodId
+  )).map((candidate, index) => ({
+    ...candidate,
+    discoveryRank: candidate.rank,
+    displayRank: index + 1,
+    selected: selectedMethodId !== void 0 && Number(candidate.methodId) === selectedMethodId
   }));
 }
-function operationLookupNames(operationPath) {
-  const name = operationPath.replace(/^\//, "");
-  const simpleName = name.split(".").at(-1) ?? name;
-  return { path: operationPath, simplePath: `/${simpleName}`, name, simpleName };
+function compareDisplayCandidate(left, right, selectedMethodId) {
+  return Number(Number(right.methodId) === selectedMethodId) - Number(Number(left.methodId) === selectedMethodId) || Number(right.accepted === true) - Number(left.accepted === true) || numberValue(left.rank) - numberValue(right.rank) || compareTargetCandidates(left, right);
+}
+function boundedImplementationEvidence(evidence, targetCandidateCount) {
+  const candidates2 = recordArray(evidence.candidates);
+  const candidateProjection = projectBoundedInOrder(candidates2);
+  const families = recordArray(evidence.candidateFamilies);
+  const familyProjection = projectBounded(families, compareFamilies);
+  const hints = recordArray(evidence.implementationHintSuggestions);
+  const hintProjection = projectBounded(hints, compareHints2);
+  const hintCount = Math.max(
+    numberValue(evidence.implementationHintSuggestionCount),
+    hintProjection.totalCount
+  );
+  const targets = Math.max(0, targetCandidateCount);
+  return {
+    ...evidence,
+    candidates: candidateProjection.items.map(boundedCandidateEvidence),
+    candidateCount: candidateProjection.totalCount,
+    shownCandidateCount: candidateProjection.shownCount,
+    omittedCandidateCount: candidateProjection.omittedCount,
+    candidateFamilies: familyProjection.items.map(boundedFamilyEvidence),
+    candidateFamilyCount: familyProjection.totalCount,
+    shownCandidateFamilyCount: familyProjection.shownCount,
+    omittedCandidateFamilyCount: familyProjection.omittedCount,
+    implementationHintSuggestions: hintProjection.items,
+    implementationHintSuggestionCount: hintCount,
+    shownImplementationHintSuggestionCount: hintProjection.shownCount,
+    omittedImplementationHintSuggestionCount: Math.max(0, hintCount - hintProjection.shownCount),
+    candidateTargetCount: targets,
+    shownCandidateTargetCount: Math.min(targets, candidateProjection.shownCount),
+    omittedCandidateTargetCount: Math.max(0, targets - candidateProjection.shownCount)
+  };
 }
-function operationMatches(candidate, operationPath) {
-  if (!operationPath) return false;
-  const names = operationLookupNames(operationPath);
-  return candidate.operationPath === names.path || candidate.operationPath === names.simplePath || candidate.operationName === names.name || candidate.operationName === names.simpleName;
+function boundedImplementationTargetIds(candidates2) {
+  const projection = projectBounded(candidates2, compareTargetCandidates);
+  return {
+    totalCount: projection.totalCount,
+    shownCount: projection.shownCount,
+    omittedCount: projection.omittedCount,
+    items: projection.items.map((candidate) => String(candidate.methodId ?? ""))
+  };
 }
-function resolveOperation(db, signals, workspaceId) {
-  const missing = [signals.servicePath, signals.alias, signals.destination, signals.operationPath].flatMap((value) => [...(value ?? "").matchAll(/\$\{([^}]*)\}/g)].map((match) => (match[1] ?? "").trim())).filter(Boolean);
-  if (missing.length > 0)
-    return {
-      status: "dynamic",
-      candidates: signals.operationPath ? rows(db, signals.operationPath, workspaceId).map((candidate) => ({
-        ...candidate,
-        score: 0.2,
-        reasons: ["operation_path_match"]
-      })) : [],
-      reasons: [...new Set(missing)].map((name) => `missing_variable:${name}`)
-    };
-  if (!signals.operationPath)
-    return {
-      status: "unresolved",
-      candidates: [],
-      reasons: ["missing_operation_path"]
-    };
-  const allCandidates = rows(db, signals.operationPath, workspaceId).map((c) => ({
-    ...c,
-    score: 0.2,
-    reasons: ["operation_path_match"]
-  }));
-  let candidates = allCandidates.filter((c) => matchesLocalRepo(db, c.operationId, signals.repoId));
-  if (candidates.length === 0 && signals.repoId !== void 0 && signals.serviceName) {
-    candidates = implementationContextCandidates(db, allCandidates, signals.repoId, signals.serviceName);
-    if (candidates.length === 0)
-      return {
-        status: "unresolved",
-        candidates: allCandidates.filter((c) => serviceMatches(c, signals.serviceName)),
-        reasons: allCandidates.some((c) => serviceMatches(c, signals.serviceName)) ? ["local_service_candidate_without_caller_ownership"] : ["no_operation_candidates"]
-      };
-  }
-  if (candidates.length === 0)
-    return {
-      status: "unresolved",
-      candidates: [],
-      reasons: ["no_operation_candidates"]
-    };
-  const hasStrongSignal = Boolean(
-    signals.servicePath || signals.serviceName || signals.alias || signals.destination || signals.hasExplicitOverride
-  );
-  for (const c of candidates) {
-    if (signals.servicePath && c.servicePath === signals.servicePath) {
-      c.score += 0.75;
-      c.reasons.push("exact_service_path");
-    }
-    if (signals.servicePath && c.servicePath !== signals.servicePath) {
-      c.score -= 0.1;
-      c.reasons.push("service_path_mismatch");
-    }
-    if (signals.serviceName) {
-      const simple = signals.serviceName.split(".").at(-1) ?? signals.serviceName;
-      if (c.qualifiedName === signals.serviceName) {
-        c.score += 0.8;
-        c.reasons.push("exact_local_qualified_service_name");
-      } else if (c.serviceName === signals.serviceName || c.serviceName === simple) {
-        c.score += 0.75;
-        c.reasons.push("exact_local_simple_service_name");
-      } else if (c.servicePath === signals.serviceName || c.servicePath === `/${signals.serviceName}` || c.servicePath === `/${simple}`) {
-        c.score += 0.7;
-        c.reasons.push("exact_local_service_path");
-      } else if (c.servicePath.endsWith(`/${simple}`)) {
-        c.score += candidates.filter((candidate) => candidate.servicePath.endsWith(`/${simple}`)).length === 1 ? 0.65 : 0.2;
-        c.reasons.push("suffix_local_service_path");
-      } else c.reasons.push("local_service_name_mismatch");
-    }
-    if (signals.hasExplicitOverride) {
-      c.score += 0.2;
-      c.reasons.push(signals.repoId !== void 0 ? "explicit_local_service_call" : "explicit_dynamic_override");
-    }
-    if (signals.repoId !== void 0 && candidates.length === 1 && signals.serviceName && c.reasons.includes("local_service_name_mismatch") && operationMatches(c, signals.operationPath)) {
-      c.score = Math.max(c.score, 0.9);
-      c.reasons.push("same_repo_unique_operation_path_with_lookup_mismatch");
-    }
-  }
-  for (const c of candidates) c.score = Math.max(0, Math.min(1, c.score));
-  candidates.sort(
-    (a, b) => b.score - a.score || a.repoName.localeCompare(b.repoName)
-  );
-  const best = candidates[0];
-  const second = candidates[1];
-  if (signals.isDynamic && !signals.hasExplicitOverride && !signals.servicePath)
-    return {
-      status: "dynamic",
-      candidates,
-      reasons: ["dynamic_target_without_override"]
-    };
-  if (!hasStrongSignal)
-    return {
-      status: candidates.length > 1 ? "ambiguous" : "unresolved",
-      candidates,
-      reasons: ["operation_path_only_has_no_strong_target_signal"]
-    };
-  if (best && best.score >= 0.9 && (best.servicePath === signals.servicePath || Boolean(signals.serviceName && (!best.reasons.includes("local_service_name_mismatch") || best.reasons.includes("same_repo_unique_operation_path_with_lookup_mismatch")))) && operationMatches(best, signals.operationPath) && (!second || best.score - second.score >= 0.25))
-    return {
-      status: "resolved",
-      target: best,
-      candidates,
-      reasons: best.reasons
-    };
+function boundedCandidateEvidence(candidate) {
+  const registrations = recordArray(candidate.registrations);
+  const projection = projectBounded(registrations, compareRegistrations);
   return {
-    status: candidates.length > 1 ? "ambiguous" : "unresolved",
-    candidates,
-    reasons: ["candidate_score_below_resolution_threshold"]
+    ...candidate,
+    registrations: projection.items,
+    registrationCount: projection.totalCount,
+    shownRegistrationCount: projection.shownCount,
+    omittedRegistrationCount: projection.omittedCount
   };
 }
-function serviceMatches(candidate, serviceName) {
-  if (!serviceName) return false;
-  const simple = serviceName.split(".").at(-1) ?? serviceName;
-  return candidate.qualifiedName === serviceName || candidate.serviceName === serviceName || candidate.serviceName === simple || candidate.servicePath === serviceName || candidate.servicePath === `/${serviceName}` || candidate.servicePath === `/${simple}` || candidate.servicePath.endsWith(`/${simple}`);
+function boundedFamilyEvidence(family) {
+  const repositories = stringArray2(family.repositories);
+  const projection = projectBounded(repositories, (left, right) => left.localeCompare(right));
+  return {
+    ...family,
+    repositories: projection.items,
+    repositoryCount: projection.totalCount,
+    shownRepositoryCount: projection.shownCount,
+    omittedRepositoryCount: projection.omittedCount
+  };
 }
-function implementationContextCandidates(db, candidates, callerRepoId, serviceName) {
-  const matching = candidates.filter((candidate) => serviceMatches(candidate, serviceName));
-  const owned = matching.map((candidate) => ownershipReason(db, candidate, callerRepoId)).filter((item) => Boolean(item));
-  if (owned.length === 0) return [];
-  const direct = owned.filter((item) => item.reason !== "caller_depends_on_model_package");
-  const chosen = direct.length > 0 ? direct : owned.length === 1 ? owned : [];
-  return chosen.map((item) => ({ ...item.candidate, score: 0.95, reasons: [...item.candidate.reasons, "implementation_context_caller_ownership", item.reason] }));
+function compareTargetCandidates(left, right) {
+  return Number(right.score ?? 0) - Number(left.score ?? 0) || String(left.className ?? "").localeCompare(String(right.className ?? "")) || Number(left.methodId ?? 0) - Number(right.methodId ?? 0);
 }
-function ownershipReason(db, candidate, callerRepoId) {
-  const edge = db.prepare("SELECT status,evidence_json,to_id 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 LIMIT 1").get(String(candidate.operationId));
-  if (edge?.status === "resolved") {
-    const row = db.prepare("SELECT hc.repo_id repoId FROM handler_methods hm JOIN handler_classes hc ON hc.id=hm.handler_class_id WHERE hm.id=?").get(edge.to_id);
-    if (row?.repoId === callerRepoId) return { candidate, reason: "resolved_implementation_handler_repo_matches_caller" };
-  }
-  if (edge?.evidence_json) {
-    const evidence = JSON.parse(edge.evidence_json);
-    const hit = evidence.candidates?.find((item) => item.accepted && (Number(item.handlerPackage?.id) === callerRepoId || Number(item.applicationPackage?.id) === callerRepoId));
-    if (hit) return { candidate, reason: edge.status === "ambiguous" ? "ambiguous_implementation_candidate_repo_matches_caller" : "registration_package_matches_caller" };
-  }
-  const dep = db.prepare("SELECT 1 FROM graph_edges WHERE edge_type='REPO_IMPORTS_HELPER_PACKAGE' AND status='resolved' AND from_kind='repo' AND from_id=? AND to_id=?").get(String(callerRepoId), String(candidate.repoId));
-  if (dep) return { candidate, reason: "caller_depends_on_model_package" };
-  return void 0;
+function compareFamilies(left, right) {
+  return String(left.packageName ?? "").localeCompare(String(right.packageName ?? "")) || String(left.reason ?? "").localeCompare(String(right.reason ?? ""));
 }
-function matchesLocalRepo(db, operationId, repoId) {
-  if (repoId === void 0) return true;
-  const row = 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(operationId);
-  return row?.repoId === repoId;
+function compareHints2(left, right) {
+  return String(left.cli ?? "").localeCompare(String(right.cli ?? "")) || String(left.implementationRepo ?? "").localeCompare(String(right.implementationRepo ?? ""));
 }
-
-// src/linker/helper-package-linker.ts
-function normalizeName(value) {
-  return value.toLowerCase().replace(/^@[^/]+\//, "").replace(/[^a-z0-9]+/g, "");
+function compareRegistrations(left, right) {
+  return String(left.file ?? "").localeCompare(String(right.file ?? "")) || Number(left.line ?? 0) - Number(right.line ?? 0) || Number(left.id ?? 0) - Number(right.id ?? 0);
 }
-function candidatesForDependency(repos, dep, sourceId) {
-  const exact = repos.filter((repo) => repo.id !== sourceId && repo.package_name === dep);
-  if (exact.length > 0) return { candidates: exact, strategy: "exact_package_name" };
-  const normalized = normalizeName(dep);
-  return { candidates: repos.filter((repo) => repo.id !== sourceId && normalizeName(repo.name) === normalized), strategy: "normalized_directory" };
+function recordArray(value) {
+  return Array.isArray(value) ? value.filter((item) => Boolean(item && typeof item === "object" && !Array.isArray(item))) : [];
 }
-function linkHelperPackages(db, workspaceId, generation) {
-  const repos = db.prepare("SELECT id,name,package_name,dependencies_json FROM repositories WHERE workspace_id=?").all(workspaceId);
-  const summary = { edgeCount: 0, resolvedCount: 0, ambiguousCount: 0 };
-  for (const repo of repos) {
-    const deps = JSON.parse(repo.dependencies_json);
-    for (const dep of Object.keys(deps)) {
+function stringArray2(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+
+// src/linker/000-implementation-candidates.ts
+function linkImplementations(db, workspaceId, generation) {
+  const operations = workspaceOperations(db, workspaceId);
+  let edgeCount = 0;
+  let resolvedCount = 0;
+  let ambiguousCount = 0;
+  let unresolvedCount = 0;
+  for (const operation of operations) {
+    const decision = implementationDecision(db, workspaceId, operation, true);
+    if (decision.candidates.length === 0) continue;
+    const status = decision.unique ? "resolved" : decision.accepted.length > 0 ? "ambiguous" : "unresolved";
+    insertImplementationEdge(db, workspaceId, generation, operation, decision, status);
+    edgeCount += 1;
+    if (status === "resolved") resolvedCount += 1;
+    else if (status === "ambiguous") ambiguousCount += 1;
+    else unresolvedCount += 1;
+  }
+  return { edgeCount, resolvedCount, ambiguousCount, unresolvedCount };
+}
+function canonicalImplementationEvidence(db, operationId) {
+  const operation = operationById(db, operationId);
+  const workspaceId = numberValue2(operation?.workspaceId);
+  if (!operation || workspaceId === void 0) return void 0;
+  return implementationDecision(db, workspaceId, operation, false).evidenceWithHints;
+}
+function workspaceOperations(db, workspaceId) {
+  const rows2 = db.prepare(`SELECT o.id operationId,o.operation_path operationPath,
+      o.operation_name operationName,o.provenance provenance,o.base_operation_id baseOperationId,
+      s.service_path servicePath,s.repo_id modelRepoId,r.name modelRepo,
+      r.package_name modelPackage,r.kind modelKind
+    FROM cds_operations o JOIN cds_services s ON s.id=o.service_id
+    JOIN repositories r ON r.id=s.repo_id WHERE r.workspace_id=?`).all(workspaceId);
+  return rows2;
+}
+function operationById(db, operationId) {
+  const row = db.prepare(`SELECT o.id operationId,o.operation_path operationPath,
+      o.operation_name operationName,o.provenance provenance,o.base_operation_id baseOperationId,
+      s.service_path servicePath,s.repo_id modelRepoId,r.name modelRepo,
+      r.package_name modelPackage,r.kind modelKind,r.workspace_id workspaceId
+    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);
+  return row;
+}
+function implementationDecision(db, workspaceId, operation, recordDiagnostics) {
+  const implementationContext = implementationContextForOperation(db, operation);
+  const candidates2 = rankedImplementationCandidates(
+    db,
+    workspaceId,
+    implementationContext,
+    recordDiagnostics
+  );
+  const accepted = candidates2.filter((candidate) => candidate.accepted);
+  const topScore = accepted[0]?.score ?? 0;
+  const winners = accepted.filter((candidate) => candidate.score === topScore);
+  const duplicateFamilies = duplicatePackageFamilies(accepted);
+  const duplicatePackageAmbiguous = duplicateFamilies.length > 0 && !accepted.some(hasDirectOwnershipEvidence);
+  const selected = duplicatePackageAmbiguous ? accepted : winners;
+  const unique3 = !duplicatePackageAmbiguous && winners.length === 1 ? winners[0] : void 0;
+  const ambiguityReasons = duplicatePackageAmbiguous ? ["duplicate_package_name_candidates"] : winners.length > 1 ? ["multiple_equal_score_implementation_candidates"] : [];
+  const evidence = implementationEvidence(
+    operation,
+    implementationContext,
+    candidates2,
+    duplicateFamilies,
+    ambiguityReasons,
+    unique3
+  );
+  const hintProjection = implementationHintSuggestionProjection(evidence);
+  return {
+    candidates: candidates2,
+    accepted,
+    selected,
+    unique: unique3,
+    evidence,
+    evidenceWithHints: unique3 ? evidence : {
+      ...evidence,
+      implementationHintSuggestions: hintProjection.suggestions,
+      implementationHintSuggestionCount: hintProjection.suggestionCount,
+      shownImplementationHintSuggestionCount: hintProjection.shownSuggestionCount,
+      omittedImplementationHintSuggestionCount: hintProjection.omittedSuggestionCount
+    }
+  };
+}
+function insertImplementationEdge(db, workspaceId, generation, operation, decision, status) {
+  const targetCandidates = status === "unresolved" ? decision.candidates : decision.selected;
+  const targetProjection = boundedImplementationTargetIds(targetCandidates);
+  const targetIds = targetProjection.items;
+  const toId = status === "resolved" ? graphId(decision.unique?.methodId) : targetIds.join(",");
+  const reason = status === "unresolved" ? "No implementation candidate passed policy" : status === "ambiguous" ? "Ambiguous registered handler implementation candidates" : null;
+  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,
+    "OPERATION_IMPLEMENTED_BY_HANDLER",
+    status,
+    "operation",
+    graphId(operation.operationId),
+    status === "resolved" ? "handler_method" : "handler_method_candidates",
+    toId,
+    status === "resolved" ? 0.95 : status === "ambiguous" ? 0.5 : 0,
+    JSON.stringify(boundedImplementationEvidence(
+      decision.evidenceWithHints,
+      targetProjection.totalCount
+    )),
+    0,
+    reason,
+    generation
+  );
+}
+function implementationEvidence(operation, context, candidates2, duplicateFamilies, ambiguityReasons, selected) {
+  return {
+    servicePath: operation.servicePath,
+    operationPath: operation.operationPath,
+    operationName: operation.operationName,
+    modelPackage: {
+      id: operation.modelRepoId,
+      name: operation.modelRepo,
+      packageName: operation.modelPackage
+    },
+    implementationSource: context.operationId === operation.operationId ? "direct_or_concrete_override" : "inherited_from_base_operation",
+    baseOperationId: operation.baseOperationId,
+    implementationOperationId: context.operationId,
+    ambiguityReasons,
+    candidateFamilies: duplicateFamilies,
+    selectedHandler: selected ? selectedHandlerProvenance(selectedHandlerSource(selected)) : void 0,
+    candidates: displayImplementationCandidates(
+      candidates2.map((candidate, index) => candidateEvidence(candidate, index + 1)),
+      selected?.methodId
+    )
+  };
+}
+function implementationContextForOperation(db, operation) {
+  if (operation.provenance !== "inherited" || !operation.baseOperationId) return operation;
+  const base = db.prepare(`SELECT o.id operationId,o.operation_path operationPath,
+      o.operation_name operationName,o.provenance provenance,o.base_operation_id baseOperationId,
+      s.service_path servicePath,s.repo_id modelRepoId,r.name modelRepo,
+      r.package_name modelPackage,r.kind modelKind
+    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(operation.baseOperationId);
+  return base ? {
+    ...base,
+    effectiveOperationId: operation.operationId,
+    effectiveServicePath: operation.servicePath,
+    effectiveOperationPath: operation.operationPath
+  } : operation;
+}
+function rankedImplementationCandidates(db, workspaceId, operation, recordDiagnostics) {
+  const rows2 = implementationCandidates(db, workspaceId, operation);
+  if (recordDiagnostics) recordRegistrationInvariantDiagnostics(
+    db,
+    rows2.filter((row) => !validRegistrationPair(row))
+  );
+  return deduplicateCandidates(rows2.filter(validRegistrationPair).map((row) => scoreImplementationCandidate(row, operation))).sort((left, right) => right.score - left.score || String(left.className).localeCompare(String(right.className)) || left.methodId - right.methodId);
+}
+function validRegistrationPair(row) {
+  if (row.registrationHandlerClassId === null || row.registrationHandlerClassId === void 0)
+    return registrationPairingStrategy(row) !== "unproven";
+  return Number(row.registrationHandlerClassId) === Number(row.classId);
+}
+function registrationPairingStrategy(row) {
+  if (row.registrationHandlerClassId !== null && row.registrationHandlerClassId !== void 0)
+    return "exact_handler_class_id";
+  if (Number(row.applicationRepoId) === Number(row.handlerRepoId))
+    return "same_repository_class_name_fallback";
+  const source = stringValue4(row.importSource);
+  const separator = source?.lastIndexOf("#") ?? -1;
+  if (!source || separator <= 0) return "unproven";
+  const moduleName = source.slice(0, separator);
+  const importedName = source.slice(separator + 1);
+  const matchesClass = importedName === row.className || importedName === "default" && row.registrationClassName === row.className;
+  return moduleName === row.handlerPackage && matchesClass ? "explicit_package_import" : "unproven";
+}
+function recordRegistrationInvariantDiagnostics(db, rows2) {
+  const insert = db.prepare(`INSERT INTO diagnostics(repo_id,severity,code,message,
+      source_file,source_line)
+    SELECT ?,'error','handler_registration_class_mismatch',
+      'Implementation candidate registration did not match its persisted handler class id',?,?
+    WHERE NOT EXISTS (SELECT 1 FROM diagnostics WHERE repo_id=?
+      AND code='handler_registration_class_mismatch' AND source_file=? AND source_line=?)`);
+  for (const row of rows2) insert.run(
+    row.applicationRepoId,
+    row.registrationFile,
+    row.registrationLine,
+    row.applicationRepoId,
+    row.registrationFile,
+    row.registrationLine
+  );
+}
+function deduplicateCandidates(rows2) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const row of rows2) {
+    const key = [row.methodId, row.classId, row.handlerRepoId].join(":");
+    const registration = registrationEvidence(row);
+    const existing = merged.get(key);
+    if (!existing) {
+      merged.set(key, { ...row, registrations: [registration] });
+      continue;
+    }
+    existing.registrations = uniqueRegistrations([
+      ...existing.registrations ?? [],
+      registration
+    ]);
+    existing.score = Math.max(existing.score, row.score);
+    existing.accepted = existing.accepted || row.accepted;
+    existing.acceptedReasons = [.../* @__PURE__ */ new Set([...existing.acceptedReasons, ...row.acceptedReasons])];
+    existing.rejectedReasons = [.../* @__PURE__ */ new Set([...existing.rejectedReasons, ...row.rejectedReasons])];
+  }
+  return [...merged.values()];
+}
+function registrationEvidence(row) {
+  return {
+    id: row.registrationId,
+    handlerClassId: row.registrationHandlerClassId,
+    file: row.registrationFile,
+    line: row.registrationLine,
+    kind: row.registrationKind,
+    importSource: row.importSource,
+    pairingStrategy: registrationPairingStrategy(row)
+  };
+}
+function uniqueRegistrations(rows2) {
+  const seen = /* @__PURE__ */ new Set();
+  return rows2.filter((row) => {
+    const key = JSON.stringify(row);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function duplicatePackageFamilies(candidates2) {
+  const byPackage = /* @__PURE__ */ new Map();
+  for (const candidate of candidates2) {
+    const packageName = stringValue4(candidate.handlerPackage);
+    if (packageName) byPackage.set(packageName, [
+      ...byPackage.get(packageName) ?? [],
+      candidate
+    ]);
+  }
+  return [...byPackage.entries()].filter(([, rows2]) => new Set(rows2.map((row) => Number(row.handlerRepoId))).size > 1).map(([packageName, rows2]) => ({
+    reason: "duplicate_package_name_candidates",
+    packageName,
+    count: rows2.length,
+    repositories: rows2.map((row) => row.handlerRepo).sort()
+  }));
+}
+function hasDirectOwnershipEvidence(candidate) {
+  return candidate.acceptedReasons.some((reason) => [
+    "model package equals registration package",
+    "model package equals handler package",
+    "registration package contains exact local service path"
+  ].includes(reason));
+}
+function implementationCandidates(db, workspaceId, operation) {
+  const modelRepoGraphId = graphId(operation.modelRepoId);
+  return db.prepare(`SELECT DISTINCT
+      hm.id methodId,hm.method_name methodName,hm.decorator_value decoratorValue,
+      hm.decorator_raw_expression decoratorRawExpression,
+      hm.decorator_resolution_json decoratorResolutionJson,hc.id classId,
+      hc.class_name className,hc.source_file sourceFile,hm.source_line sourceLine,
+      hr.id registrationId,hr.handler_class_id registrationHandlerClassId,
+      hr.class_name registrationClassName,hr.repo_id applicationRepoId,
+      hr.registration_file registrationFile,hr.registration_line registrationLine,
+      hr.registration_kind registrationKind,hr.import_source importSource,
+      handlerRepo.id handlerRepoId,handlerRepo.name handlerRepo,
+      handlerRepo.package_name handlerPackage,appRepo.name applicationRepo,
+      appRepo.package_name applicationPackage,? modelRepoId,? modelRepo,? modelPackage,
+      ? modelKind,? servicePath,? operationPath,? operationName,
+      CASE WHEN appRepo.id=? THEN 1 ELSE 0 END modelIsApplicationRepo,
+      CASE WHEN handlerRepo.id=? THEN 1 ELSE 0 END modelIsHandlerRepo,
+      CASE WHEN appRepo.id=handlerRepo.id THEN 1 ELSE 0 END sameRepoRegistration,
+      CASE WHEN EXISTS (SELECT 1 FROM cds_services localService
+        WHERE localService.repo_id=appRepo.id AND localService.service_path=?)
+        THEN 1 ELSE 0 END localServicePathMatch,
+      CASE WHEN EXISTS (SELECT 1 FROM cds_services localService
+        WHERE localService.repo_id=appRepo.id) THEN 1 ELSE 0 END applicationHasLocalServices,
+      CASE WHEN EXISTS (SELECT 1 FROM handler_registrations localReg
+        JOIN handler_classes localClass ON ((localReg.handler_class_id IS NOT NULL
+          AND localClass.id=localReg.handler_class_id) OR (localReg.handler_class_id IS NULL
+          AND localClass.class_name=localReg.class_name AND localClass.repo_id=localReg.repo_id))
+        JOIN handler_methods localMethod ON localMethod.handler_class_id=localClass.id
+        WHERE localReg.repo_id=appRepo.id
+          AND COALESCE(json_extract(localMethod.decorator_resolution_json,'$.handlerKind'),
+            CASE WHEN localMethod.decorator_kind='Event' THEN 'event'
+              WHEN localMethod.decorator_kind IN ('Action','Func','On') THEN 'operation'
+              ELSE 'unsupported' END)='operation'
+          AND COALESCE(json_extract(localMethod.decorator_resolution_json,'$.executable'),
+            CASE WHEN localMethod.decorator_kind IN ('Action','Func','On') THEN 1 ELSE 0 END)=1
+          AND (localMethod.decorator_value=? OR localMethod.decorator_value=?
+            OR localMethod.method_name=? OR localMethod.decorator_raw_expression LIKE ?))
+        THEN 1 ELSE 0 END applicationHasLocalRegistrationForOperation,
+      CASE WHEN EXISTS (SELECT 1 FROM graph_edges dep
+        WHERE dep.edge_type='REPO_IMPORTS_HELPER_PACKAGE' AND dep.status='resolved'
+          AND dep.from_kind='repo' AND dep.from_id=CAST(appRepo.id AS TEXT)
+          AND dep.to_id=?) THEN 1 ELSE 0 END appDependsOnModel,
+      CASE WHEN EXISTS (SELECT 1 FROM graph_edges dep
+        WHERE dep.edge_type='REPO_IMPORTS_HELPER_PACKAGE' AND dep.status='resolved'
+          AND dep.from_kind='repo' AND dep.from_id=CAST(appRepo.id AS TEXT)
+          AND dep.to_id=CAST(handlerRepo.id AS TEXT)) THEN 1 ELSE 0 END appDependsOnHandler,
+      CASE WHEN EXISTS (SELECT 1 FROM graph_edges dep
+        WHERE dep.edge_type='REPO_IMPORTS_HELPER_PACKAGE' AND dep.status='resolved'
+          AND dep.from_kind='repo' AND dep.from_id=CAST(handlerRepo.id AS TEXT)
+          AND dep.to_id=?) THEN 1 ELSE 0 END handlerDependsOnModel
+    FROM handler_methods hm JOIN handler_classes hc ON hc.id=hm.handler_class_id
+    JOIN repositories handlerRepo ON handlerRepo.id=hc.repo_id
+    JOIN handler_registrations hr ON ((hr.handler_class_id IS NOT NULL
+      AND hr.handler_class_id=hc.id) OR (hr.handler_class_id IS NULL AND
+      ((hr.class_name=hc.class_name AND hr.repo_id=hc.repo_id) OR
+        (instr(hr.import_source,'#')>1 AND substr(hr.import_source,1,
+          instr(hr.import_source,'#')-1)=handlerRepo.package_name AND
+          (substr(hr.import_source,instr(hr.import_source,'#')+1)=hc.class_name OR
+            (substr(hr.import_source,instr(hr.import_source,'#')+1)='default'
+              AND hr.class_name=hc.class_name))))))
+    JOIN repositories appRepo ON appRepo.id=hr.repo_id
+    WHERE appRepo.workspace_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.decorator_value=? OR hm.method_name=?
+        OR hm.decorator_raw_expression LIKE ?)`).all(
+    operation.modelRepoId,
+    operation.modelRepo,
+    operation.modelPackage,
+    operation.modelKind,
+    operation.servicePath,
+    operation.operationPath,
+    operation.operationName,
+    operation.modelRepoId,
+    operation.modelRepoId,
+    operation.servicePath,
+    normalizedOperation(String(operation.operationPath ?? "")),
+    operation.operationName,
+    operation.operationName,
+    `%${upperFirst2(normalizedOperation(String(operation.operationPath ?? operation.operationName ?? "")))}%`,
+    modelRepoGraphId,
+    modelRepoGraphId,
+    workspaceId,
+    normalizedOperation(String(operation.operationPath ?? "")),
+    operation.operationName,
+    operation.operationName,
+    `%${upperFirst2(normalizedOperation(String(operation.operationPath ?? operation.operationName ?? "")))}%`
+  );
+}
+function scoreImplementationCandidate(row, operation) {
+  const acceptedReasons = [];
+  const rejectedReasons = [];
+  const methodSignal = implementationMethodSignal(row, operation);
+  acceptedReasons.push(...methodSignal.acceptedReasons);
+  rejectedReasons.push(...methodSignal.rejectedReasons);
+  const signals = implementationOwnershipSignals(row, methodSignal.matches);
+  acceptedReasons.push(...signals.acceptedReasons);
+  rejectedReasons.push(...signals.rejectedReasons);
+  const accepted = methodSignal.matches && !methodSignal.contradicted && !signals.contradicted && signals.hasOwnership;
+  if (!accepted && rejectedReasons.length === 0)
+    rejectedReasons.push("candidate did not meet implementation ownership policy");
+  return {
+    ...row,
+    methodId: Number(row.methodId),
+    score: signals.score,
+    accepted,
+    acceptedReasons,
+    rejectedReasons
+  };
+}
+function implementationOwnershipSignals(row, methodMatches) {
+  const acceptedReasons = [];
+  const rejectedReasons = [];
+  const modelIsApplicationRepo = flag(row.modelIsApplicationRepo);
+  const modelIsHandlerRepo = flag(row.modelIsHandlerRepo);
+  const localServicePathMatch = flag(row.localServicePathMatch);
+  const applicationHasLocalServices = flag(row.applicationHasLocalServices);
+  const appDependsOnModel = flag(row.appDependsOnModel);
+  const appDependsOnHandler = flag(row.appDependsOnHandler);
+  const handlerDependsOnModel = flag(row.handlerDependsOnModel);
+  const importSource = Boolean(stringValue4(row.importSource));
+  const sameRepoRegistration = flag(row.sameRepoRegistration);
+  const modelOriented = row.modelKind === "cap-db-model" || !flag(row.applicationHasLocalRegistrationForOperation);
+  const helperOwned = modelOriented && methodMatches && sameRepoRegistration && importSource && !applicationHasLocalServices && !modelIsApplicationRepo && !modelIsHandlerRepo && !localServicePathMatch && !appDependsOnModel && !appDependsOnHandler && !handlerDependsOnModel;
+  const score = ownershipScore({
+    modelIsApplicationRepo,
+    modelIsHandlerRepo,
+    localServicePathMatch,
+    appDependsOnModel,
+    appDependsOnHandler,
+    handlerDependsOnModel,
+    helperOwned,
+    importSource
+  }, acceptedReasons);
+  const hasOwnership = modelIsApplicationRepo || modelIsHandlerRepo;
+  const hasCrossPackage = appDependsOnModel && (modelIsHandlerRepo || appDependsOnHandler || !importSource);
+  const contradicted = applicationHasLocalServices && !localServicePathMatch && !appDependsOnModel && !hasOwnership;
+  if (applicationHasLocalServices && !localServicePathMatch && !appDependsOnModel && !modelIsApplicationRepo)
+    rejectedReasons.push(`registration package has local services but none match ${String(row.servicePath ?? "")}`);
+  if (!hasOwnership && !localServicePathMatch && !hasCrossPackage && !helperOwned)
+    rejectedReasons.push("missing direct ownership, exact local service path, or validated cross-package dependency evidence");
+  return {
+    score,
+    hasOwnership: hasOwnership || localServicePathMatch || hasCrossPackage || handlerDependsOnModel || helperOwned,
+    contradicted,
+    acceptedReasons,
+    rejectedReasons
+  };
+}
+function ownershipScore(signals, acceptedReasons) {
+  let score = 0;
+  const values = [
+    ["modelIsApplicationRepo", 100, "model package equals registration package"],
+    ["modelIsHandlerRepo", 100, "model package equals handler package"],
+    ["localServicePathMatch", 80, "registration package contains exact local service path"],
+    ["appDependsOnModel", 70, "registration package depends on model package"],
+    ["appDependsOnHandler", 30, "registration package depends on handler package"],
+    ["handlerDependsOnModel", 20, "handler package depends on model package"],
+    ["helperOwned", 60, "unique registered helper implementation for model-only operation"],
+    ["importSource", 10, "registration imports handler class"]
+  ];
+  for (const [key, amount, reason] of values) {
+    if (!signals[key]) continue;
+    score += amount;
+    acceptedReasons.push(reason);
+  }
+  return score;
+}
+function candidateEvidence(candidate, rank) {
+  return {
+    rank,
+    rankKind: "discovery_score",
+    score: candidate.score,
+    accepted: candidate.accepted,
+    acceptedReasons: candidate.acceptedReasons,
+    rejectedReasons: candidate.rejectedReasons,
+    methodId: candidate.methodId,
+    classId: candidate.classId,
+    className: candidate.className,
+    sourceFile: candidate.sourceFile,
+    sourceLine: candidate.sourceLine,
+    decoratorResolution: objectJson(candidate.decoratorResolutionJson),
+    registration: registrationEvidence(candidate),
+    registrations: candidate.registrations ?? [],
+    registrationPairing: {
+      strategy: registrationPairingStrategy(candidate),
+      registrationId: candidate.registrationId,
+      registrationHandlerClassId: candidate.registrationHandlerClassId,
+      candidateHandlerClassId: candidate.classId,
+      invariantStatus: validRegistrationPair(candidate) ? "valid" : "invalid"
+    },
+    applicationPackage: {
+      id: candidate.applicationRepoId,
+      name: candidate.applicationRepo,
+      packageName: candidate.applicationPackage
+    },
+    handlerPackage: {
+      id: candidate.handlerRepoId,
+      name: candidate.handlerRepo,
+      packageName: candidate.handlerPackage
+    },
+    modelPackage: {
+      id: candidate.modelRepoId,
+      name: candidate.modelRepo,
+      packageName: candidate.modelPackage
+    },
+    servicePath: candidate.servicePath,
+    operationPath: candidate.operationPath,
+    operationName: candidate.operationName,
+    signals: {
+      directOwnership: {
+        modelIsApplicationRepo: flag(candidate.modelIsApplicationRepo),
+        modelIsHandlerRepo: flag(candidate.modelIsHandlerRepo)
+      },
+      localServicePathMatch: flag(candidate.localServicePathMatch),
+      applicationHasLocalServices: flag(candidate.applicationHasLocalServices),
+      applicationHasLocalRegistrationForOperation: flag(candidate.applicationHasLocalRegistrationForOperation),
+      appDependsOnModel: flag(candidate.appDependsOnModel),
+      appDependsOnHandler: flag(candidate.appDependsOnHandler),
+      handlerDependsOnModel: flag(candidate.handlerDependsOnModel),
+      sameRepoRegistration: flag(candidate.sameRepoRegistration)
+    }
+  };
+}
+function selectedHandlerSource(candidate) {
+  return {
+    methodId: candidate.methodId,
+    className: stringValue4(candidate.className),
+    methodName: stringValue4(candidate.methodName),
+    repositoryId: numberValue2(candidate.handlerRepoId),
+    repositoryName: stringValue4(candidate.handlerRepo),
+    repositoryPackageName: stringValue4(candidate.handlerPackage),
+    sourceFile: stringValue4(candidate.sourceFile),
+    sourceLine: numberValue2(candidate.sourceLine)
+  };
+}
+function implementationMethodSignal(row, operation) {
+  const resolution = objectJson(row.decoratorResolutionJson) ?? {};
+  if (resolution.handlerKind && resolution.handlerKind !== "operation")
+    return { matches: false, contradicted: true, acceptedReasons: [], rejectedReasons: ["non_operation_handler_kind"] };
+  if (resolution.executable === false)
+    return { matches: false, contradicted: true, acceptedReasons: [], rejectedReasons: ["handler_method_not_executable"] };
+  const operationName = normalizedOperationName(String(
+    operation.operationPath ?? operation.operationName ?? ""
+  ));
+  const decorator = normalizeDecoratorOperationSignal(
+    stringValue4(row.decoratorValue),
+    stringValue4(row.decoratorRawExpression),
+    operationName
+  );
+  if (decorator.status === "resolved" && decorator.operationName === operationName)
+    return { matches: true, contradicted: false, acceptedReasons: ["decorator targets operation"], rejectedReasons: [] };
+  if (decorator.status === "resolved")
+    return { matches: false, contradicted: true, acceptedReasons: [], rejectedReasons: ["method_name_matches_but_decorator_targets_different_operation"] };
+  return String(row.methodName ?? "") === operationName ? { matches: true, contradicted: false, acceptedReasons: ["method name fallback matched operation"], rejectedReasons: [] } : { matches: false, contradicted: false, acceptedReasons: [], rejectedReasons: ["method name does not match operation"] };
+}
+function objectJson(value) {
+  if (typeof value !== "string" || value.length === 0) return void 0;
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function upperFirst2(value) {
+  return value ? `${value[0]?.toUpperCase() ?? ""}${value.slice(1)}` : value;
+}
+function flag(value) {
+  return Boolean(Number(value ?? 0));
+}
+function graphId(value) {
+  return String(value ?? "");
+}
+function normalizedOperation(value) {
+  return value.startsWith("/") ? value.slice(1) : value;
+}
+function stringValue4(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function numberValue2(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+
+// src/linker/service-resolver.ts
+function rows(db, operationPath, workspaceId) {
+  const names = operationLookupNames(operationPath);
+  const result = db.prepare(
+    `SELECT o.id operationId,r.id repoId,r.name repoName,r.package_name packageName,s.service_name serviceName,s.qualified_name qualifiedName,s.service_path servicePath,o.operation_path operationPath,o.operation_name operationName,o.source_file sourceFile,o.source_line sourceLine,0 score
+       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 (o.operation_path IN (?,?) OR o.operation_name IN (?,?)) ORDER BY r.name,s.service_path,o.operation_name`
+  ).all(
+    workspaceId,
+    workspaceId,
+    names.path,
+    names.simplePath,
+    names.name,
+    names.simpleName
+  );
+  return result.map((row) => ({
+    ...row,
+    score: Number(row.score ?? 0),
+    reasons: []
+  }));
+}
+function operationLookupNames(operationPath) {
+  const name = operationPath.replace(/^\//, "");
+  const simpleName = name.split(".").at(-1) ?? name;
+  return { path: operationPath, simplePath: `/${simpleName}`, name, simpleName };
+}
+function operationMatches(candidate, operationPath) {
+  if (!operationPath) return false;
+  const names = operationLookupNames(operationPath);
+  return candidate.operationPath === names.path || candidate.operationPath === names.simplePath || candidate.operationName === names.name || candidate.operationName === names.simpleName;
+}
+function resolveOperation(db, signals, workspaceId) {
+  const missing = [signals.servicePath, signals.alias, signals.destination, signals.operationPath].flatMap((value) => [...(value ?? "").matchAll(/\$\{([^}]*)\}/g)].map((match) => (match[1] ?? "").trim())).filter(Boolean);
+  if (missing.length > 0)
+    return {
+      status: "dynamic",
+      candidates: signals.operationPath ? rows(db, signals.operationPath, workspaceId).map((candidate) => ({
+        ...candidate,
+        score: 0.2,
+        reasons: ["operation_path_match"]
+      })) : [],
+      reasons: [...new Set(missing)].map((name) => `missing_variable:${name}`)
+    };
+  if (!signals.operationPath)
+    return {
+      status: "unresolved",
+      candidates: [],
+      reasons: ["missing_operation_path"]
+    };
+  const allCandidates = rows(db, signals.operationPath, workspaceId).map((c) => ({
+    ...c,
+    score: 0.2,
+    reasons: ["operation_path_match"]
+  }));
+  let candidates2 = allCandidates.filter((c) => matchesLocalRepo(db, c.operationId, signals.repoId));
+  if (candidates2.length === 0 && signals.repoId !== void 0 && signals.serviceName) {
+    candidates2 = implementationContextCandidates(db, allCandidates, signals.repoId, signals.serviceName);
+    if (candidates2.length === 0)
+      return {
+        status: "unresolved",
+        candidates: allCandidates.filter((c) => serviceMatches(c, signals.serviceName)),
+        reasons: allCandidates.some((c) => serviceMatches(c, signals.serviceName)) ? ["local_service_candidate_without_caller_ownership"] : ["no_operation_candidates"]
+      };
+  }
+  if (candidates2.length === 0)
+    return {
+      status: "unresolved",
+      candidates: [],
+      reasons: ["no_operation_candidates"]
+    };
+  const hasStrongSignal = Boolean(
+    signals.servicePath || signals.serviceName || signals.alias || signals.destination || signals.hasExplicitOverride
+  );
+  for (const c of candidates2) {
+    if (signals.servicePath && c.servicePath === signals.servicePath) {
+      c.score += 0.75;
+      c.reasons.push("exact_service_path");
+    }
+    if (signals.servicePath && c.servicePath !== signals.servicePath) {
+      c.score -= 0.1;
+      c.reasons.push("service_path_mismatch");
+    }
+    if (signals.serviceName) {
+      const simple = signals.serviceName.split(".").at(-1) ?? signals.serviceName;
+      if (c.qualifiedName === signals.serviceName) {
+        c.score += 0.8;
+        c.reasons.push("exact_local_qualified_service_name");
+      } else if (c.serviceName === signals.serviceName || c.serviceName === simple) {
+        c.score += 0.75;
+        c.reasons.push("exact_local_simple_service_name");
+      } else if (c.servicePath === signals.serviceName || c.servicePath === `/${signals.serviceName}` || c.servicePath === `/${simple}`) {
+        c.score += 0.7;
+        c.reasons.push("exact_local_service_path");
+      } else if (c.servicePath.endsWith(`/${simple}`)) {
+        c.score += candidates2.filter((candidate) => candidate.servicePath.endsWith(`/${simple}`)).length === 1 ? 0.65 : 0.2;
+        c.reasons.push("suffix_local_service_path");
+      } else c.reasons.push("local_service_name_mismatch");
+    }
+    if (signals.hasExplicitOverride) {
+      c.score += 0.2;
+      c.reasons.push(signals.repoId !== void 0 ? "explicit_local_service_call" : "explicit_dynamic_override");
+    }
+    if (signals.repoId !== void 0 && candidates2.length === 1 && signals.serviceName && c.reasons.includes("local_service_name_mismatch") && operationMatches(c, signals.operationPath)) {
+      c.score = Math.max(c.score, 0.9);
+      c.reasons.push("same_repo_unique_operation_path_with_lookup_mismatch");
+    }
+  }
+  for (const c of candidates2) c.score = Math.max(0, Math.min(1, c.score));
+  candidates2.sort(
+    (a, b) => b.score - a.score || a.repoName.localeCompare(b.repoName)
+  );
+  const best = candidates2[0];
+  const second = candidates2[1];
+  if (signals.isDynamic && !signals.hasExplicitOverride && !signals.servicePath)
+    return {
+      status: "dynamic",
+      candidates: candidates2,
+      reasons: ["dynamic_target_without_override"]
+    };
+  if (!hasStrongSignal)
+    return {
+      status: candidates2.length > 1 ? "ambiguous" : "unresolved",
+      candidates: candidates2,
+      reasons: ["operation_path_only_has_no_strong_target_signal"]
+    };
+  if (best && best.score >= 0.9 && (best.servicePath === signals.servicePath || Boolean(signals.serviceName && (!best.reasons.includes("local_service_name_mismatch") || best.reasons.includes("same_repo_unique_operation_path_with_lookup_mismatch")))) && operationMatches(best, signals.operationPath) && (!second || best.score - second.score >= 0.25))
+    return {
+      status: "resolved",
+      target: best,
+      candidates: candidates2,
+      reasons: best.reasons
+    };
+  return {
+    status: candidates2.length > 1 ? "ambiguous" : "unresolved",
+    candidates: candidates2,
+    reasons: ["candidate_score_below_resolution_threshold"]
+  };
+}
+function serviceMatches(candidate, serviceName) {
+  if (!serviceName) return false;
+  const simple = serviceName.split(".").at(-1) ?? serviceName;
+  return candidate.qualifiedName === serviceName || candidate.serviceName === serviceName || candidate.serviceName === simple || candidate.servicePath === serviceName || candidate.servicePath === `/${serviceName}` || candidate.servicePath === `/${simple}` || candidate.servicePath.endsWith(`/${simple}`);
+}
+function implementationContextCandidates(db, candidates2, callerRepoId, serviceName) {
+  const matching = candidates2.filter((candidate) => serviceMatches(candidate, serviceName));
+  const owned = matching.map((candidate) => ownershipReason(db, candidate, callerRepoId)).filter((item) => Boolean(item));
+  if (owned.length === 0) return [];
+  const direct = owned.filter((item) => item.reason !== "caller_depends_on_model_package");
+  const chosen = direct.length > 0 ? direct : owned.length === 1 ? owned : [];
+  return chosen.map((item) => ({ ...item.candidate, score: 0.95, reasons: [...item.candidate.reasons, "implementation_context_caller_ownership", item.reason] }));
+}
+function ownershipReason(db, candidate, callerRepoId) {
+  const edge = db.prepare("SELECT status,evidence_json,to_id 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 LIMIT 1").get(String(candidate.operationId));
+  if (edge?.status === "resolved") {
+    const row = db.prepare("SELECT hc.repo_id repoId FROM handler_methods hm JOIN handler_classes hc ON hc.id=hm.handler_class_id WHERE hm.id=?").get(edge.to_id);
+    if (row?.repoId === callerRepoId) return { candidate, reason: "resolved_implementation_handler_repo_matches_caller" };
+  }
+  if (edge?.evidence_json) {
+    const stored = parsedRecord(edge.evidence_json);
+    const evidence = canonicalImplementationEvidence(db, candidate.operationId) ?? stored;
+    const hit = implementationEvidenceCandidates(evidence).find((item) => item.accepted && (item.handlerRepoId === callerRepoId || item.applicationRepoId === callerRepoId));
+    if (hit) return { candidate, reason: edge.status === "ambiguous" ? "ambiguous_implementation_candidate_repo_matches_caller" : "registration_package_matches_caller" };
+  }
+  const dep = db.prepare("SELECT 1 FROM graph_edges WHERE edge_type='REPO_IMPORTS_HELPER_PACKAGE' AND status='resolved' AND from_kind='repo' AND from_id=? AND to_id=?").get(String(callerRepoId), String(candidate.repoId));
+  if (dep) return { candidate, reason: "caller_depends_on_model_package" };
+  return void 0;
+}
+function implementationEvidenceCandidates(evidence) {
+  const candidates2 = evidence.candidates;
+  if (!Array.isArray(candidates2)) return [];
+  return candidates2.flatMap((candidate) => {
+    if (!isRecord2(candidate)) return [];
+    const row = candidate;
+    const handler = recordValue(row.handlerPackage);
+    const application = recordValue(row.applicationPackage);
+    return [{
+      accepted: row.accepted === true,
+      handlerRepoId: numberValue3(handler.id),
+      applicationRepoId: numberValue3(application.id)
+    }];
+  });
+}
+function recordValue(value) {
+  return isRecord2(value) ? value : {};
+}
+function parsedRecord(value) {
+  try {
+    const parsed = JSON.parse(value);
+    return recordValue(parsed);
+  } catch {
+    return {};
+  }
+}
+function isRecord2(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function numberValue3(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function matchesLocalRepo(db, operationId, repoId) {
+  if (repoId === void 0) return true;
+  const row = 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(operationId);
+  return row?.repoId === repoId;
+}
+
+// src/linker/helper-package-linker.ts
+function normalizeName(value) {
+  return value.toLowerCase().replace(/^@[^/]+\//, "").replace(/[^a-z0-9]+/g, "");
+}
+function candidatesForDependency(repos, dep, sourceId) {
+  const exact = repos.filter((repo) => repo.id !== sourceId && repo.package_name === dep);
+  if (exact.length > 0) return { candidates: exact, strategy: "exact_package_name" };
+  const normalized = normalizeName(dep);
+  return { candidates: repos.filter((repo) => repo.id !== sourceId && normalizeName(repo.name) === normalized), strategy: "normalized_directory" };
+}
+function linkHelperPackages(db, workspaceId, generation) {
+  const repos = db.prepare("SELECT id,name,package_name,dependencies_json FROM repositories WHERE workspace_id=?").all(workspaceId);
+  const summary = { edgeCount: 0, resolvedCount: 0, ambiguousCount: 0 };
+  for (const repo of repos) {
+    const deps = JSON.parse(repo.dependencies_json);
+    for (const dep of Object.keys(deps)) {
       const result = candidatesForDependency(repos, dep, repo.id);
       if (result.candidates.length === 0) continue;
       const status = result.candidates.length === 1 ? "resolved" : "ambiguous";
       const helper = status === "resolved" ? result.candidates[0] : void 0;
+      const projection = projectBounded(result.candidates, (left, right) => left.name.localeCompare(right.name) || String(left.package_name ?? "").localeCompare(String(right.package_name ?? "")) || left.id - right.id);
       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,
         "REPO_IMPORTS_HELPER_PACKAGE",
@@ -3855,9 +4819,20 @@ function linkHelperPackages(db, workspaceId, generation) {
         "repo",
         String(repo.id),
         helper ? "repo" : "repo_candidates",
-        helper ? String(helper.id) : result.candidates.map((candidate) => candidate.id).join(","),
+        helper ? String(helper.id) : projection.items.map((candidate) => candidate.id).join(","),
         helper ? 1 : 0.5,
-        JSON.stringify({ dependency: dep, candidates: result.candidates.map((candidate) => ({ id: candidate.id, name: candidate.name, packageName: candidate.package_name })), match: result.strategy }),
+        JSON.stringify({
+          dependency: dep,
+          candidates: projection.items.map((candidate) => ({
+            id: candidate.id,
+            name: candidate.name,
+            packageName: candidate.package_name
+          })),
+          candidateCount: projection.totalCount,
+          shownCandidateCount: projection.shownCount,
+          omittedCandidateCount: projection.omittedCount,
+          match: result.strategy
+        }),
         0,
         helper ? null : "Ambiguous dependency package candidates",
         generation
@@ -3867,7 +4842,145 @@ function linkHelperPackages(db, workspaceId, generation) {
       else summary.ambiguousCount += 1;
     }
   }
-  return summary;
+  return summary;
+}
+
+// src/linker/002-call-evidence.ts
+function linkedCallEvidence(call, resolution, servicePath, operationPath, destination, normalized, intent) {
+  const candidates2 = boundedCallCandidates(resolution.candidates);
+  return {
+    ...callLocationEvidence(call),
+    ...selectedBindingEvidence(call),
+    ...routingEvidence(call, servicePath, operationPath, destination, normalized, intent),
+    ...candidateEvidence2(candidates2, resolution),
+    outboundEvidence: boundCandidateLikeEvidence(objectJson2(call.evidence_json) ?? {}),
+    analysisCompleteness: call.unresolved_reason ? "partial" : "complete",
+    parserWarning: call.unresolved_reason ? { code: "parser_warning", message: call.unresolved_reason } : void 0
+  };
+}
+function ambiguousPathCandidates(pathAnalysis) {
+  const values = Array.isArray(pathAnalysis.candidateRawPaths) ? pathAnalysis.candidateRawPaths.filter((value) => typeof value === "string") : [];
+  return projectBounded(values, (left, right) => left.localeCompare(right));
+}
+function objectJson2(value) {
+  const parsed = parseJson(value);
+  return isRecord3(parsed) ? parsed : void 0;
+}
+function objectValue(value) {
+  return isRecord3(value) ? value : void 0;
+}
+function callLocationEvidence(call) {
+  return {
+    sourceFile: call.source_file,
+    sourceLine: call.source_line,
+    file: call.source_file,
+    line: call.source_line,
+    callId: call.id,
+    repo: call.repoName
+  };
+}
+function selectedBindingEvidence(call) {
+  if (!call.selectedBindingId) return {};
+  return {
+    selectedBindingId: call.selectedBindingId,
+    selectedBinding: {
+      bindingId: call.selectedBindingId,
+      alias: call.alias,
+      aliasExpr: call.aliasExpr,
+      destinationExpr: call.destinationExpr,
+      servicePathExpr: call.servicePathExpr,
+      sourceFile: call.bindingSourceFile,
+      sourceLine: call.bindingSourceLine,
+      helperChain: parseJson(call.helperChainJson)
+    }
+  };
+}
+function routingEvidence(call, servicePath, operationPath, destination, normalized, intent) {
+  const routingPlaceholderKeys = placeholderKeys([
+    servicePath,
+    destination,
+    stringValue5(call.aliasExpr),
+    stringValue5(call.alias)
+  ]);
+  return {
+    serviceAlias: call.alias,
+    serviceAliasExpr: call.aliasExpr,
+    destination,
+    servicePath,
+    operationPath,
+    rawOperationPath: normalized?.wasInvocation ? normalized.rawOperationPath : intent?.rawPath,
+    normalizedOperationPath: normalized?.wasInvocation ? normalized.normalizedOperationPath : void 0,
+    invocationArguments: normalized?.wasInvocation ? normalized.invocationArguments : void 0,
+    invocationArgumentPlaceholderKeys: normalized?.invocationArgumentPlaceholderKeys.length ? normalized.invocationArgumentPlaceholderKeys : void 0,
+    routingPlaceholderKeys: routingPlaceholderKeys.length ? routingPlaceholderKeys : void 0,
+    odataOperationNormalizationReason: normalized?.normalizationReason,
+    odataOperationNormalizationRejectedReason: normalized?.normalizationRejectedReason,
+    localServiceName: call.local_service_name,
+    localServiceLookup: call.local_service_lookup,
+    aliasChain: parseJson(call.alias_chain_json),
+    transport: call.call_type === "local_service_call" ? "local" : void 0,
+    helperChain: parseJson(call.helperChainJson),
+    odataPathIntent: intent,
+    queryStringPresent: intent?.hasQueryString || void 0,
+    queryPlaceholderKeys: intent?.placeholderKeys.length ? intent.placeholderKeys : void 0,
+    bindingHasDynamicExpression: Boolean(Number(call.isDynamic ?? 0)) || void 0
+  };
+}
+function candidateEvidence2(candidates2, resolution) {
+  return {
+    targetRepo: resolution.target?.repoName,
+    targetServicePath: resolution.target?.servicePath,
+    targetOperationPath: resolution.target?.operationPath,
+    targetOperation: resolution.target?.operationName,
+    candidates: candidates2.items,
+    candidateScores: compactCandidateScores(candidates2.items),
+    candidateCount: candidates2.totalCount,
+    shownCandidateCount: candidates2.shownCount,
+    omittedCandidateCount: candidates2.omittedCount,
+    candidateScoreCount: candidates2.totalCount,
+    shownCandidateScoreCount: candidates2.shownCount,
+    omittedCandidateScoreCount: candidates2.omittedCount,
+    resolutionStatus: resolution.status,
+    resolutionReasons: resolution.reasons
+  };
+}
+function boundedCallCandidates(candidates2) {
+  const rows2 = candidates2.flatMap((candidate) => {
+    const row = objectValue(candidate);
+    return row ? [row] : [];
+  });
+  return projectBounded(rows2, compareCallCandidate);
+}
+function compareCallCandidate(left, right) {
+  return Number(right.score ?? 0) - Number(left.score ?? 0) || String(left.repoName ?? "").localeCompare(String(right.repoName ?? "")) || String(left.servicePath ?? "").localeCompare(String(right.servicePath ?? "")) || String(left.operationPath ?? "").localeCompare(String(right.operationPath ?? "")) || Number(left.operationId ?? 0) - Number(right.operationId ?? 0);
+}
+function compactCandidateScores(candidates2) {
+  return candidates2.map((candidate) => ({
+    repo: candidate.repoName,
+    servicePath: candidate.servicePath,
+    operationPath: candidate.operationPath,
+    score: candidate.score,
+    reasons: Array.isArray(candidate.reasons) ? candidate.reasons.filter((reason) => typeof reason === "string") : ["operation_path_match"]
+  }));
+}
+function placeholderKeys(values) {
+  const keys = values.flatMap((value) => [...(value ?? "").matchAll(/\$\{([^}]*)\}/g)].map((match) => (match[1] ?? "").trim()).filter(Boolean));
+  return [...new Set(keys)].sort();
+}
+function parseJson(value) {
+  if (!value) return void 0;
+  try {
+    const parsed = JSON.parse(String(value));
+    return parsed;
+  } catch {
+    return void 0;
+  }
+}
+function stringValue5(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function isRecord3(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 
 // src/linker/cross-repo-linker.ts
@@ -3895,7 +5008,7 @@ function linkCalls(db, workspaceId, vars, generation) {
   let ambiguousCount = 0;
   let dynamicCount = 0;
   let terminalCount = 0;
-  const calls = db.prepare(`SELECT c.*,r.name repoName,b.alias,b.alias_expr aliasExpr,b.destination_expr destinationExpr,b.service_path_expr servicePathExpr,b.is_dynamic isDynamic,b.placeholders_json placeholdersJson,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);
+  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;
@@ -3928,7 +5041,15 @@ function insertCallEdge(db, workspaceId, call, vars, generation) {
   const isOperationCall = operationLikeRemoteEntity || (callType === "remote_action" || callType === "local_service_call" || callType === "remote_query" && Boolean(op));
   const resolution = isOperationCall ? resolveOperation(db, { servicePath, operationPath: op, serviceName: call.local_service_name, repoId: callType === "local_service_call" ? Number(call.repo_id) : void 0, alias: applyVariables(call.aliasExpr ?? call.alias, vars), destination: destination ? applyVariables(destination, vars) : void 0, isDynamic, hasExplicitOverride: Object.keys(vars).length > 0 || callType === "local_service_call" }, workspaceId) : { status: "unresolved", candidates: [], reasons: [] };
   const evidence = {
-    ...callEvidence(call, resolution, servicePath, op, destination ? applyVariables(destination, vars) : void 0, normalized, intent),
+    ...linkedCallEvidence(
+      call,
+      resolution,
+      servicePath,
+      op,
+      destination ? applyVariables(destination, vars) : void 0,
+      normalized,
+      intent
+    ),
     indexedOperationCandidateCount,
     parserCallType: callType,
     entityOperationPrecedence: operationPrecedence(
@@ -3938,9 +5059,9 @@ function insertCallEdge(db, workspaceId, call, vars, generation) {
       Boolean(resolution.target)
     )
   };
-  const pathAnalysis = objectValue(objectJson(call.evidence_json)?.pathAnalysis);
+  const pathAnalysis = objectValue(objectJson2(call.evidence_json)?.pathAnalysis);
   if (callType === "remote_action" && pathAnalysis?.status === "ambiguous") {
-    const candidatePaths = Array.isArray(pathAnalysis.candidateRawPaths) ? pathAnalysis.candidateRawPaths : [];
+    const candidatePaths = ambiguousPathCandidates(pathAnalysis);
     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,
       "UNRESOLVED_EDGE",
@@ -3948,9 +5069,14 @@ function insertCallEdge(db, workspaceId, call, vars, generation) {
       "call",
       String(call.id),
       "operation_candidates",
-      candidatePaths.join(","),
+      candidatePaths.items.join(","),
       Number(call.confidence ?? 0.5),
-      JSON.stringify(evidence),
+      JSON.stringify({
+        ...evidence,
+        ambiguousOperationPathCandidateCount: candidatePaths.totalCount,
+        shownAmbiguousOperationPathCandidateCount: candidatePaths.shownCount,
+        omittedAmbiguousOperationPathCandidateCount: candidatePaths.omittedCount
+      }),
       0,
       "Ambiguous operation path candidates require explicit disambiguation",
       generation
@@ -4023,433 +5149,20 @@ function operationPrecedence(callType, intent, indexedOperationCandidateCount, r
       rejectionReason: indexedOperationCandidateCount > 0 ? "entity_shape_has_precedence_without_resolved_operation_context" : "entity_shape_has_no_indexed_operation_evidence",
       indexedOperationCandidateCount
     };
-  }
-  return {
-    decision: "unresolved",
-    rejectionReason: "path_has_no_safe_entity_or_operation_precedence",
-    indexedOperationCandidateCount
-  };
-}
-function unresolvedOperationReason(resolution) {
-  if (resolution.status === "dynamic") return `Dynamic target requires runtime variable overrides: ${(resolution.reasons.length ? resolution.reasons : ["missing runtime variables"]).join(", ")}`;
-  if (resolution.candidates.length === 0) return "No indexed target operation matched";
-  if (resolution.reasons.includes("operation_path_only_has_no_strong_target_signal")) return "Operation candidates found but no strong service signal is available";
-  if (resolution.reasons.includes("candidate_score_below_resolution_threshold")) return "Operation candidates found but resolution score is below threshold";
-  if (resolution.status === "ambiguous") return "Ambiguous operation candidates require a strong service signal";
-  return "Operation candidates found but resolution could not select a target";
-}
-function parseJson(value) {
-  if (!value) return void 0;
-  try {
-    return JSON.parse(String(value));
-  } catch {
-    return void 0;
-  }
-}
-function objectJson(value) {
-  const parsed = parseJson(value);
-  return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
-}
-function callEvidence(call, resolution, servicePath, op, destination, normalized, odataPathIntent) {
-  const bindingHasDynamicExpression = Boolean(Number(call.isDynamic ?? 0));
-  const routingPlaceholderKeys = placeholderKeys([servicePath, destination, stringValue3(call.aliasExpr), stringValue3(call.alias)]);
-  return { sourceFile: call.source_file, sourceLine: call.source_line, file: call.source_file, line: call.source_line, callId: call.id, repo: call.repoName, serviceAlias: call.alias, serviceAliasExpr: call.aliasExpr, destination, servicePath, operationPath: op, rawOperationPath: normalized?.wasInvocation ? normalized.rawOperationPath : odataPathIntent?.rawPath, normalizedOperationPath: normalized?.wasInvocation ? normalized.normalizedOperationPath : void 0, invocationArguments: normalized?.wasInvocation ? normalized.invocationArguments : void 0, invocationArgumentPlaceholderKeys: normalized?.invocationArgumentPlaceholderKeys.length ? normalized.invocationArgumentPlaceholderKeys : void 0, routingPlaceholderKeys: routingPlaceholderKeys.length ? routingPlaceholderKeys : void 0, odataOperationNormalizationReason: normalized?.normalizationReason, odataOperationNormalizationRejectedReason: normalized?.normalizationRejectedReason, localServiceName: call.local_service_name, localServiceLookup: call.local_service_lookup, aliasChain: parseJson(call.alias_chain_json), transport: call.call_type === "local_service_call" ? "local" : void 0, targetRepo: resolution.target?.repoName, targetServicePath: resolution.target?.servicePath, targetOperationPath: resolution.target?.operationPath, targetOperation: resolution.target?.operationName, helperChain: parseJson(call.helperChainJson), candidates: resolution.candidates, candidateScores: compactCandidateScores(resolution.candidates), candidateCount: resolution.candidates.length, resolutionStatus: resolution.status, resolutionReasons: resolution.reasons, odataPathIntent, queryStringPresent: odataPathIntent?.hasQueryString || void 0, queryPlaceholderKeys: odataPathIntent?.placeholderKeys.length ? odataPathIntent.placeholderKeys : void 0, bindingHasDynamicExpression: bindingHasDynamicExpression || void 0, outboundEvidence: objectJson(call.evidence_json), analysisCompleteness: call.unresolved_reason ? "partial" : "complete", parserWarning: call.unresolved_reason ? { code: "parser_warning", message: call.unresolved_reason } : void 0 };
-}
-function compactCandidateScores(candidates) {
-  return candidates.flatMap((candidate) => {
-    const row = objectValue(candidate);
-    if (!row) return [];
-    return [{
-      repo: row.repoName,
-      servicePath: row.servicePath,
-      operationPath: row.operationPath,
-      score: row.score,
-      reasons: Array.isArray(row.reasons) ? row.reasons.filter((reason) => typeof reason === "string") : ["operation_path_match"]
-    }];
-  });
-}
-function placeholderKeys(values) {
-  const keys = values.flatMap((value) => [...(value ?? "").matchAll(/\$\{([^}]*)\}/g)].map((match) => (match[1] ?? "").trim()).filter(Boolean));
-  return [...new Set(keys)].sort();
-}
-function objectValue(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
-}
-function stringValue3(value) {
-  return typeof value === "string" ? value : void 0;
-}
-function linkImplementations(db, workspaceId, generation) {
-  const operations = db.prepare(`SELECT o.id operationId,o.operation_path operationPath,o.operation_name operationName,o.provenance provenance,o.base_operation_id baseOperationId,s.service_path servicePath,s.repo_id modelRepoId,r.name modelRepo,r.package_name modelPackage,r.kind modelKind FROM cds_operations o JOIN cds_services s ON s.id=o.service_id JOIN repositories r ON r.id=s.repo_id WHERE r.workspace_id=?`).all(workspaceId);
-  let edgeCount = 0;
-  let resolvedCount = 0;
-  let ambiguousCount = 0;
-  let unresolvedCount = 0;
-  for (const operation of operations) {
-    const implementationContext = implementationContextForOperation(db, operation);
-    const candidates = rankedImplementationCandidates(db, workspaceId, implementationContext);
-    if (candidates.length === 0) continue;
-    const accepted = candidates.filter((candidate) => candidate.accepted);
-    const topScore = accepted[0]?.score ?? 0;
-    const winners = accepted.filter((candidate) => candidate.score === topScore);
-    const duplicateFamilies = duplicatePackageFamilies(accepted);
-    const duplicatePackageAmbiguous = duplicateFamilies.length > 0 && !accepted.some(hasDirectOwnershipEvidence);
-    const selected = duplicatePackageAmbiguous ? accepted : winners;
-    const unique3 = !duplicatePackageAmbiguous && winners.length === 1 ? winners[0] : void 0;
-    const ambiguityReasons = duplicatePackageAmbiguous ? ["duplicate_package_name_candidates"] : winners.length > 1 ? ["multiple_equal_score_implementation_candidates"] : [];
-    const evidence = {
-      servicePath: operation.servicePath,
-      operationPath: operation.operationPath,
-      operationName: operation.operationName,
-      modelPackage: { id: operation.modelRepoId, name: operation.modelRepo, packageName: operation.modelPackage },
-      implementationSource: implementationContext.operationId === operation.operationId ? "direct_or_concrete_override" : "inherited_from_base_operation",
-      baseOperationId: operation.baseOperationId,
-      implementationOperationId: implementationContext.operationId,
-      ambiguityReasons,
-      candidateFamilies: duplicateFamilies,
-      candidates: candidates.map((candidate, index) => candidateEvidence(candidate, index + 1))
-    };
-    const evidenceWithHints = unique3 ? evidence : { ...evidence, implementationHintSuggestions: implementationHintSuggestions(evidence) };
-    if (accepted.length === 0) {
-      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, "OPERATION_IMPLEMENTED_BY_HANDLER", "unresolved", "operation", graphId(operation.operationId), "handler_method_candidates", candidates.map((row) => graphId(row.methodId)).join(","), 0, JSON.stringify(evidenceWithHints), 0, "No implementation candidate passed policy", generation);
-      edgeCount += 1;
-      unresolvedCount += 1;
-      continue;
-    }
-    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, "OPERATION_IMPLEMENTED_BY_HANDLER", unique3 ? "resolved" : "ambiguous", "operation", graphId(operation.operationId), unique3 ? "handler_method" : "handler_method_candidates", unique3 ? graphId(unique3.methodId) : selected.map((row) => graphId(row.methodId)).join(","), unique3 ? 0.95 : 0.5, JSON.stringify(evidenceWithHints), 0, unique3 ? null : "Ambiguous registered handler implementation candidates", generation);
-    edgeCount += 1;
-    if (unique3) resolvedCount += 1;
-    else ambiguousCount += 1;
-  }
-  return { edgeCount, resolvedCount, ambiguousCount, unresolvedCount };
-}
-function implementationContextForOperation(db, operation) {
-  if (operation.provenance !== "inherited" || !operation.baseOperationId) return operation;
-  const base = db.prepare(`SELECT o.id operationId,o.operation_path operationPath,o.operation_name operationName,o.provenance provenance,o.base_operation_id baseOperationId,s.service_path servicePath,s.repo_id modelRepoId,r.name modelRepo,r.package_name modelPackage,r.kind modelKind 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(operation.baseOperationId);
-  if (!base) return operation;
-  return { ...base, effectiveOperationId: operation.operationId, effectiveServicePath: operation.servicePath, effectiveOperationPath: operation.operationPath };
-}
-function rankedImplementationCandidates(db, workspaceId, operation) {
-  const rows2 = implementationCandidates(db, workspaceId, operation);
-  const invalid = rows2.filter((row) => !validRegistrationPair(row));
-  recordRegistrationInvariantDiagnostics(db, invalid);
-  return deduplicateCandidates(
-    rows2.filter(validRegistrationPair).map((row) => scoreImplementationCandidate(row, operation))
-  ).sort((a, b) => b.score - a.score || String(a.className).localeCompare(String(b.className)) || a.methodId - b.methodId);
-}
-function validRegistrationPair(row) {
-  if (row.registrationHandlerClassId === null || row.registrationHandlerClassId === void 0)
-    return registrationPairingStrategy(row) !== "unproven";
-  return Number(row.registrationHandlerClassId) === Number(row.classId);
-}
-function registrationPairingStrategy(row) {
-  if (row.registrationHandlerClassId !== null && row.registrationHandlerClassId !== void 0)
-    return "exact_handler_class_id";
-  if (Number(row.applicationRepoId) === Number(row.handlerRepoId))
-    return "same_repository_class_name_fallback";
-  const source = stringValue3(row.importSource);
-  const separator = source?.lastIndexOf("#") ?? -1;
-  if (!source || separator <= 0) return "unproven";
-  const moduleName = source.slice(0, separator);
-  const importedName = source.slice(separator + 1);
-  const matchesClass = importedName === row.className || importedName === "default" && row.registrationClassName === row.className;
-  return moduleName === row.handlerPackage && matchesClass ? "explicit_package_import" : "unproven";
-}
-function recordRegistrationInvariantDiagnostics(db, rows2) {
-  const insert = db.prepare(`INSERT INTO diagnostics(repo_id,severity,code,message,source_file,source_line)
-    SELECT ?,'error','handler_registration_class_mismatch',
-      'Implementation candidate registration did not match its persisted handler class id',?,?
-    WHERE NOT EXISTS (
-      SELECT 1 FROM diagnostics
-      WHERE repo_id=? AND code='handler_registration_class_mismatch'
-        AND source_file=? AND source_line=?
-    )`);
-  for (const row of rows2)
-    insert.run(
-      row.applicationRepoId,
-      row.registrationFile,
-      row.registrationLine,
-      row.applicationRepoId,
-      row.registrationFile,
-      row.registrationLine
-    );
-}
-function deduplicateCandidates(rows2) {
-  const merged = /* @__PURE__ */ new Map();
-  for (const row of rows2) {
-    const key = [row.methodId, row.classId, row.handlerRepoId].join(":");
-    const registration = registrationEvidence(row);
-    const existing = merged.get(key);
-    if (!existing) {
-      merged.set(key, { ...row, registrations: [registration] });
-      continue;
-    }
-    existing.registrations = uniqueRegistrations([...existing.registrations ?? [], registration]);
-    existing.score = Math.max(existing.score, row.score);
-    existing.accepted = existing.accepted || row.accepted;
-    existing.acceptedReasons = [.../* @__PURE__ */ new Set([...existing.acceptedReasons, ...row.acceptedReasons])];
-    existing.rejectedReasons = [.../* @__PURE__ */ new Set([...existing.rejectedReasons, ...row.rejectedReasons])];
-  }
-  return [...merged.values()];
-}
-function registrationEvidence(row) {
-  return {
-    id: row.registrationId,
-    handlerClassId: row.registrationHandlerClassId,
-    file: row.registrationFile,
-    line: row.registrationLine,
-    kind: row.registrationKind,
-    importSource: row.importSource,
-    pairingStrategy: registrationPairingStrategy(row)
-  };
-}
-function uniqueRegistrations(rows2) {
-  const seen = /* @__PURE__ */ new Set();
-  return rows2.filter((row) => {
-    const key = JSON.stringify(row);
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
-}
-function duplicatePackageFamilies(candidates) {
-  const byPackage = /* @__PURE__ */ new Map();
-  for (const candidate of candidates) {
-    const packageName = typeof candidate.handlerPackage === "string" ? candidate.handlerPackage : void 0;
-    if (!packageName) continue;
-    byPackage.set(packageName, [...byPackage.get(packageName) ?? [], candidate]);
-  }
-  return [...byPackage.entries()].filter(([, rows2]) => new Set(rows2.map((row) => Number(row.handlerRepoId))).size > 1).map(([packageName, rows2]) => ({ reason: "duplicate_package_name_candidates", packageName, count: rows2.length, repositories: rows2.map((row) => row.handlerRepo).sort() }));
-}
-function hasDirectOwnershipEvidence(candidate) {
-  return candidate.acceptedReasons.some((reason) => reason === "model package equals registration package" || reason === "model package equals handler package" || reason === "registration package contains exact local service path");
-}
-function implementationCandidates(db, workspaceId, operation) {
-  const modelRepoGraphId = graphId(operation.modelRepoId);
-  return db.prepare(`SELECT DISTINCT
-      hm.id methodId,
-      hm.method_name methodName,
-      hm.decorator_value decoratorValue,
-      hm.decorator_raw_expression decoratorRawExpression,
-      hm.decorator_resolution_json decoratorResolutionJson,
-      hc.id classId,
-      hc.class_name className,
-      hc.source_file sourceFile,
-      hc.source_line sourceLine,
-      hr.id registrationId,
-      hr.handler_class_id registrationHandlerClassId,
-      hr.class_name registrationClassName,
-      hr.repo_id applicationRepoId,
-      hr.registration_file registrationFile,
-      hr.registration_line registrationLine,
-      hr.registration_kind registrationKind,
-      hr.import_source importSource,
-      handlerRepo.id handlerRepoId,
-      handlerRepo.name handlerRepo,
-      handlerRepo.package_name handlerPackage,
-      appRepo.name applicationRepo,
-      appRepo.package_name applicationPackage,
-      ? modelRepoId,
-      ? modelRepo,
-      ? modelPackage,
-      ? modelKind,
-      ? servicePath,
-      ? operationPath,
-      ? operationName,
-      CASE WHEN appRepo.id=? THEN 1 ELSE 0 END modelIsApplicationRepo,
-      CASE WHEN handlerRepo.id=? THEN 1 ELSE 0 END modelIsHandlerRepo,
-      CASE WHEN appRepo.id=handlerRepo.id THEN 1 ELSE 0 END sameRepoRegistration,
-      CASE WHEN EXISTS (SELECT 1 FROM cds_services localService WHERE localService.repo_id=appRepo.id AND localService.service_path=?) THEN 1 ELSE 0 END localServicePathMatch,
-      CASE WHEN EXISTS (SELECT 1 FROM cds_services localService WHERE localService.repo_id=appRepo.id) THEN 1 ELSE 0 END applicationHasLocalServices,
-      CASE WHEN EXISTS (SELECT 1 FROM handler_registrations localReg JOIN handler_classes localClass ON ((localReg.handler_class_id IS NOT NULL AND localClass.id=localReg.handler_class_id) OR (localReg.handler_class_id IS NULL AND localClass.class_name=localReg.class_name AND localClass.repo_id=localReg.repo_id)) JOIN handler_methods localMethod ON localMethod.handler_class_id=localClass.id WHERE localReg.repo_id=appRepo.id AND COALESCE(json_extract(localMethod.decorator_resolution_json,'$.handlerKind'),CASE WHEN localMethod.decorator_kind='Event' THEN 'event' WHEN localMethod.decorator_kind IN ('Action','Func','On') THEN 'operation' ELSE 'unsupported' END)='operation' AND COALESCE(json_extract(localMethod.decorator_resolution_json,'$.executable'),CASE WHEN localMethod.decorator_kind IN ('Action','Func','On') THEN 1 ELSE 0 END)=1 AND (localMethod.decorator_value=? OR localMethod.decorator_value=? OR localMethod.method_name=? OR localMethod.decorator_raw_expression LIKE ?)) THEN 1 ELSE 0 END applicationHasLocalRegistrationForOperation,
-      CASE WHEN EXISTS (SELECT 1 FROM graph_edges dep WHERE dep.edge_type='REPO_IMPORTS_HELPER_PACKAGE' AND dep.status='resolved' AND dep.from_kind='repo' AND dep.from_id=CAST(appRepo.id AS TEXT) AND dep.to_id=?) THEN 1 ELSE 0 END appDependsOnModel,
-      CASE WHEN EXISTS (SELECT 1 FROM graph_edges dep WHERE dep.edge_type='REPO_IMPORTS_HELPER_PACKAGE' AND dep.status='resolved' AND dep.from_kind='repo' AND dep.from_id=CAST(appRepo.id AS TEXT) AND dep.to_id=CAST(handlerRepo.id AS TEXT)) THEN 1 ELSE 0 END appDependsOnHandler,
-      CASE WHEN EXISTS (SELECT 1 FROM graph_edges dep WHERE dep.edge_type='REPO_IMPORTS_HELPER_PACKAGE' AND dep.status='resolved' AND dep.from_kind='repo' AND dep.from_id=CAST(handlerRepo.id AS TEXT) AND dep.to_id=?) THEN 1 ELSE 0 END handlerDependsOnModel
-    FROM handler_methods hm
-    JOIN handler_classes hc ON hc.id=hm.handler_class_id
-    JOIN repositories handlerRepo ON handlerRepo.id=hc.repo_id
-    JOIN handler_registrations hr ON (
-      (hr.handler_class_id IS NOT NULL AND hr.handler_class_id=hc.id)
-      OR (
-        hr.handler_class_id IS NULL
-        AND (
-          (hr.class_name=hc.class_name AND hr.repo_id=hc.repo_id)
-          OR (
-            instr(hr.import_source,'#')>1
-            AND substr(hr.import_source,1,instr(hr.import_source,'#')-1)
-              =handlerRepo.package_name
-            AND (
-              substr(hr.import_source,instr(hr.import_source,'#')+1)
-                =hc.class_name
-              OR (
-                substr(hr.import_source,instr(hr.import_source,'#')+1)
-                  ='default'
-                AND hr.class_name=hc.class_name
-              )
-            )
-          )
-        )
-      )
-    )
-    JOIN repositories appRepo ON appRepo.id=hr.repo_id
-    WHERE appRepo.workspace_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.decorator_value=? OR hm.method_name=? OR hm.decorator_raw_expression LIKE ?)`).all(
-    operation.modelRepoId,
-    operation.modelRepo,
-    operation.modelPackage,
-    operation.modelKind,
-    operation.servicePath,
-    operation.operationPath,
-    operation.operationName,
-    operation.modelRepoId,
-    operation.modelRepoId,
-    operation.servicePath,
-    normalizedOperation(String(operation.operationPath ?? "")),
-    operation.operationName,
-    operation.operationName,
-    `%${upperFirst(normalizedOperation(String(operation.operationPath ?? operation.operationName ?? "")))}%`,
-    modelRepoGraphId,
-    modelRepoGraphId,
-    workspaceId,
-    normalizedOperation(String(operation.operationPath ?? "")),
-    operation.operationName,
-    operation.operationName,
-    `%${upperFirst(normalizedOperation(String(operation.operationPath ?? operation.operationName ?? "")))}%`
-  );
-}
-function scoreImplementationCandidate(row, operation) {
-  const acceptedReasons = [];
-  const rejectedReasons = [];
-  let score = 0;
-  const modelIsApplicationRepo = flag(row.modelIsApplicationRepo);
-  const modelIsHandlerRepo = flag(row.modelIsHandlerRepo);
-  const localServicePathMatch = flag(row.localServicePathMatch);
-  const applicationHasLocalServices = flag(row.applicationHasLocalServices);
-  const appDependsOnModel = flag(row.appDependsOnModel);
-  const applicationHasLocalRegistrationForOperation = flag(row.applicationHasLocalRegistrationForOperation);
-  const appDependsOnHandler = flag(row.appDependsOnHandler);
-  const handlerDependsOnModel = flag(row.handlerDependsOnModel);
-  const importSource = typeof row.importSource === "string" && row.importSource.length > 0;
-  const sameRepoRegistration = flag(row.sameRepoRegistration);
-  const modelOriented = row.modelKind === "cap-db-model" || !applicationHasLocalRegistrationForOperation;
-  const methodSignal = implementationMethodSignal(row, operation);
-  const methodMatches = methodSignal.matches;
-  acceptedReasons.push(...methodSignal.acceptedReasons);
-  rejectedReasons.push(...methodSignal.rejectedReasons);
-  const registeredAndLinked = sameRepoRegistration && importSource;
-  const helperOwned = modelOriented && methodMatches && registeredAndLinked && sameRepoRegistration && !applicationHasLocalServices && !modelIsApplicationRepo && !modelIsHandlerRepo && !localServicePathMatch && !appDependsOnModel && !appDependsOnHandler && !handlerDependsOnModel;
-  if (modelIsApplicationRepo) {
-    score += 100;
-    acceptedReasons.push("model package equals registration package");
-  }
-  if (modelIsHandlerRepo) {
-    score += 100;
-    acceptedReasons.push("model package equals handler package");
-  }
-  if (localServicePathMatch) {
-    score += 80;
-    acceptedReasons.push("registration package contains exact local service path");
-  } else if (applicationHasLocalServices && !appDependsOnModel && !modelIsApplicationRepo) {
-    rejectedReasons.push(`registration package has local services but none match ${String(operation.servicePath ?? "")}`);
-  }
-  if (appDependsOnModel) {
-    score += 70;
-    acceptedReasons.push("registration package depends on model package");
-  }
-  if (appDependsOnHandler) {
-    score += 30;
-    acceptedReasons.push("registration package depends on handler package");
-  }
-  if (handlerDependsOnModel) {
-    score += 20;
-    acceptedReasons.push("handler package depends on model package");
-  }
-  if (helperOwned) {
-    score += 60;
-    acceptedReasons.push("unique registered helper implementation for model-only operation");
-  }
-  if (importSource) {
-    score += 10;
-    acceptedReasons.push("registration imports handler class");
-  }
-  const hasOwnership = modelIsApplicationRepo || modelIsHandlerRepo;
-  const hasCrossPackage = appDependsOnModel && (modelIsHandlerRepo || appDependsOnHandler || !importSource);
-  const contradicted = applicationHasLocalServices && !localServicePathMatch && !appDependsOnModel && !hasOwnership;
-  if (!hasOwnership && !localServicePathMatch && !hasCrossPackage && !helperOwned) rejectedReasons.push("missing direct ownership, exact local service path, or validated cross-package dependency evidence");
-  const accepted = methodMatches && !methodSignal.contradicted && !contradicted && (hasOwnership || localServicePathMatch || hasCrossPackage || handlerDependsOnModel || helperOwned);
-  if (!accepted && rejectedReasons.length === 0) rejectedReasons.push("candidate did not meet implementation ownership policy");
-  return { ...row, methodId: Number(row.methodId), score, accepted, acceptedReasons, rejectedReasons };
-}
-function candidateEvidence(candidate, rank) {
-  return {
-    rank,
-    score: candidate.score,
-    accepted: candidate.accepted,
-    acceptedReasons: candidate.acceptedReasons,
-    rejectedReasons: candidate.rejectedReasons,
-    methodId: candidate.methodId,
-    classId: candidate.classId,
-    className: candidate.className,
-    sourceFile: candidate.sourceFile,
-    sourceLine: candidate.sourceLine,
-    decoratorResolution: objectJson(candidate.decoratorResolutionJson),
-    registration: registrationEvidence(candidate),
-    registrations: candidate.registrations ?? [],
-    registrationPairing: {
-      strategy: registrationPairingStrategy(candidate),
-      registrationId: candidate.registrationId,
-      registrationHandlerClassId: candidate.registrationHandlerClassId,
-      candidateHandlerClassId: candidate.classId,
-      invariantStatus: validRegistrationPair(candidate) ? "valid" : "invalid"
-    },
-    applicationPackage: { id: candidate.applicationRepoId, name: candidate.applicationRepo, packageName: candidate.applicationPackage },
-    handlerPackage: { id: candidate.handlerRepoId, name: candidate.handlerRepo, packageName: candidate.handlerPackage },
-    modelPackage: { id: candidate.modelRepoId, name: candidate.modelRepo, packageName: candidate.modelPackage },
-    servicePath: candidate.servicePath,
-    operationPath: candidate.operationPath,
-    operationName: candidate.operationName,
-    signals: {
-      directOwnership: { modelIsApplicationRepo: flag(candidate.modelIsApplicationRepo), modelIsHandlerRepo: flag(candidate.modelIsHandlerRepo) },
-      localServicePathMatch: flag(candidate.localServicePathMatch),
-      applicationHasLocalServices: flag(candidate.applicationHasLocalServices),
-      applicationHasLocalRegistrationForOperation: flag(candidate.applicationHasLocalRegistrationForOperation),
-      appDependsOnModel: flag(candidate.appDependsOnModel),
-      appDependsOnHandler: flag(candidate.appDependsOnHandler),
-      handlerDependsOnModel: flag(candidate.handlerDependsOnModel),
-      sameRepoRegistration: flag(candidate.sameRepoRegistration)
-    }
+  }
+  return {
+    decision: "unresolved",
+    rejectionReason: "path_has_no_safe_entity_or_operation_precedence",
+    indexedOperationCandidateCount
   };
 }
-function implementationMethodSignal(row, operation) {
-  const resolution = objectJson(row.decoratorResolutionJson) ?? {};
-  if (resolution.handlerKind && resolution.handlerKind !== "operation")
-    return { matches: false, contradicted: true, acceptedReasons: [], rejectedReasons: ["non_operation_handler_kind"] };
-  if (resolution.executable === false)
-    return { matches: false, contradicted: true, acceptedReasons: [], rejectedReasons: ["handler_method_not_executable"] };
-  const op = normalizedOperationName(String(operation.operationPath ?? operation.operationName ?? ""));
-  const decorator = normalizeDecoratorOperationSignal(typeof row.decoratorValue === "string" ? row.decoratorValue : void 0, typeof row.decoratorRawExpression === "string" ? row.decoratorRawExpression : void 0, op);
-  if (decorator.status === "resolved" && decorator.operationName === op) return { matches: true, contradicted: false, acceptedReasons: ["decorator targets operation"], rejectedReasons: [] };
-  if (decorator.status === "resolved" && decorator.operationName !== op) return { matches: false, contradicted: true, acceptedReasons: [], rejectedReasons: ["method_name_matches_but_decorator_targets_different_operation"] };
-  if (String(row.methodName ?? "") === op) return { matches: true, contradicted: false, acceptedReasons: ["method name fallback matched operation"], rejectedReasons: [] };
-  return { matches: false, contradicted: false, acceptedReasons: [], rejectedReasons: ["method name does not match operation"] };
-}
-function upperFirst(value) {
-  return value ? `${value[0]?.toUpperCase() ?? ""}${value.slice(1)}` : value;
-}
-function flag(value) {
-  return Boolean(Number(value ?? 0));
-}
-function graphId(value) {
-  return String(value);
-}
-function normalizedOperation(value) {
-  return value.startsWith("/") ? value.slice(1) : value;
+function unresolvedOperationReason(resolution) {
+  if (resolution.status === "dynamic") return `Dynamic target requires runtime variable overrides: ${(resolution.reasons.length ? resolution.reasons : ["missing runtime variables"]).join(", ")}`;
+  if (resolution.candidates.length === 0) return "No indexed target operation matched";
+  if (resolution.reasons.includes("operation_path_only_has_no_strong_target_signal")) return "Operation candidates found but no strong service signal is available";
+  if (resolution.reasons.includes("candidate_score_below_resolution_threshold")) return "Operation candidates found but resolution score is below threshold";
+  if (resolution.status === "ambiguous") return "Ambiguous operation candidates require a strong service signal";
+  return "Operation candidates found but resolution could not select a target";
 }
 
 // src/trace/selectors.ts
@@ -4470,23 +5183,34 @@ function selectorRepoNotFoundDiagnostic(requested) {
     requestedRepository: requested
   };
 }
-function selectorRepoAmbiguousDiagnostic(requested, candidates) {
-  const uniqueName = (value) => candidates.filter((candidate) => candidate.name === value).length === 1;
-  const uniquePackage = (value) => candidates.filter((candidate) => candidate.packageName === value).length === 1;
-  const suggestions = candidates.flatMap((candidate) => {
+function selectorRepoAmbiguousDiagnostic(requested, candidates2) {
+  const uniqueName = (value) => candidates2.filter((candidate) => candidate.name === value).length === 1;
+  const uniquePackage = (value) => candidates2.filter((candidate) => candidate.packageName === value).length === 1;
+  const suggestions = candidates2.flatMap((candidate) => {
     if (uniqueName(candidate.name)) return [`--repo ${candidate.name}`];
     if (candidate.packageName && uniquePackage(candidate.packageName))
       return [`--repo ${candidate.packageName}`];
     return [];
   });
+  const candidateProjection = projectBounded(candidates2, (left, right) => left.name.localeCompare(right.name) || String(left.packageName ?? "").localeCompare(String(right.packageName ?? "")) || left.id - right.id);
+  const suggestionProjection = projectBounded(
+    [...new Set(suggestions)],
+    (left, right) => left.localeCompare(right)
+  );
   return {
     severity: "warning",
     code: "selector_repo_ambiguous",
     message: `Repository selector matched multiple indexed repositories: ${requested}`,
     selectorKind: "repo",
     requestedRepository: requested,
-    candidates,
-    selectorSuggestions: [...new Set(suggestions)].sort(),
+    candidates: candidateProjection.items,
+    candidateCount: candidateProjection.totalCount,
+    shownCandidateCount: candidateProjection.shownCount,
+    omittedCandidateCount: candidateProjection.omittedCount,
+    selectorSuggestions: suggestionProjection.items,
+    selectorSuggestionCount: suggestionProjection.totalCount,
+    shownSelectorSuggestionCount: suggestionProjection.shownCount,
+    omittedSelectorSuggestionCount: suggestionProjection.omittedCount,
     remediation: suggestions.length > 0 ? "Use one of the unique --repo selectors shown." : "Repository names and package names must be unique before this selector can be traced safely."
   };
 }
@@ -4628,21 +5352,23 @@ function operationHandlerRows(db, repoId, operation, servicePath, workspaceId) {
   );
 }
 function operationHandlerScope(rows2, fallbackRepoId, requested) {
-  const candidates = handlerSelectorCandidates(rows2, "method");
-  if (candidates.length < 2) return executableScope(rows2, fallbackRepoId);
+  const candidates2 = handlerSelectorCandidates(rows2, "method");
+  if (candidates2.length < 2) return executableScope(rows2, fallbackRepoId);
   const classes = /* @__PURE__ */ new Map();
-  for (const candidate of candidates) {
+  for (const candidate of candidates2) {
     const key = `${String(candidate.repoName)}:${String(candidate.className)}`;
     classes.set(key, /* @__PURE__ */ new Set([
       ...classes.get(key) ?? [],
       String(candidate.handlerClassId)
     ]));
   }
-  const suggestions = candidates.flatMap((candidate) => {
+  const suggestions = candidates2.flatMap((candidate) => {
     if (typeof candidate.repoName !== "string" || typeof candidate.className !== "string") return [];
     const key = `${candidate.repoName}:${candidate.className}`;
     return classes.get(key)?.size === 1 ? [`--repo ${candidate.repoName} --handler ${candidate.className}`] : [];
   });
+  const projection = boundedSelectorCandidates(candidates2);
+  const suggestionProjection = boundedSelectorSuggestions(suggestions);
   return { diagnostics: [{
     severity: "warning",
     code: "trace_start_ambiguous",
@@ -4651,8 +5377,14 @@ function operationHandlerScope(rows2, fallbackRepoId, requested) {
     normalizedSelectorValue: requested,
     resolutionStage: "handler",
     resolutionStatus: "ambiguous_handler_operation",
-    candidates,
-    selectorSuggestions: [...new Set(suggestions)].sort(),
+    candidates: projection.items,
+    candidateCount: projection.totalCount,
+    shownCandidateCount: projection.shownCount,
+    omittedCandidateCount: projection.omittedCount,
+    selectorSuggestions: suggestionProjection.items,
+    selectorSuggestionCount: suggestionProjection.totalCount,
+    shownSelectorSuggestionCount: suggestionProjection.shownCount,
+    omittedSelectorSuggestionCount: suggestionProjection.omittedCount,
     remediation: "Select one handler class explicitly; no operation was chosen automatically."
   }] };
 }
@@ -4694,7 +5426,7 @@ function handlerClassScope(rows2, requested) {
   const ambiguity = handlerSelectorAmbiguity(rows2, requested, "class");
   if (ambiguity) return { diagnostics: [ambiguity] };
   const executable = rows2.filter((row) => typeof row.symbolId === "number");
-  const repoId = numericValue(rows2[0]?.repoId);
+  const repoId = numericValue3(rows2[0]?.repoId);
   if (executable.length > 0) {
     const scope = executableScope(executable, repoId);
     const warning = executable.some((row) => typeof row.methodId === "number") ? handlerDecoratorsNotIndexedDiagnostic(rows2[0]) : handlerMethodsNotIndexedDiagnostic(rows2[0]);
@@ -4711,17 +5443,17 @@ function handlerMethodScope(rows2, fallbackRepoId, requested) {
   return ambiguity ? { diagnostics: [ambiguity] } : executableScope(rows2, fallbackRepoId);
 }
 function handlerSelectorAmbiguity(rows2, requested, matchKind) {
-  const candidates = handlerSelectorCandidates(rows2, matchKind);
-  if (candidates.length < 2) return void 0;
+  const candidates2 = handlerSelectorCandidates(rows2, matchKind);
+  if (candidates2.length < 2) return void 0;
   const repoCounts = /* @__PURE__ */ new Map();
-  for (const candidate of candidates) {
+  for (const candidate of candidates2) {
     if (typeof candidate.repoName !== "string") continue;
     repoCounts.set(
       candidate.repoName,
       (repoCounts.get(candidate.repoName) ?? 0) + 1
     );
   }
-  const suggestions = candidates.flatMap((candidate) => {
+  const suggestions = candidates2.flatMap((candidate) => {
     const repoName = typeof candidate.repoName === "string" ? candidate.repoName : void 0;
     if (repoName && repoCounts.get(repoName) === 1)
       return [`--repo ${repoName} --handler ${requested}`];
@@ -4729,6 +5461,8 @@ function handlerSelectorAmbiguity(rows2, requested, matchKind) {
       return [`${repoName ? `--repo ${repoName} ` : ""}--handler ${candidate.className}`];
     return [];
   });
+  const projection = boundedSelectorCandidates(candidates2);
+  const suggestionProjection = boundedSelectorSuggestions(suggestions);
   return {
     severity: "warning",
     code: "trace_start_ambiguous",
@@ -4737,16 +5471,22 @@ function handlerSelectorAmbiguity(rows2, requested, matchKind) {
     requestedHandler: requested,
     resolutionStage: "handler",
     resolutionStatus: "ambiguous_handler",
-    candidates,
-    selectorSuggestions: [...new Set(suggestions)].sort(),
+    candidates: projection.items,
+    candidateCount: projection.totalCount,
+    shownCandidateCount: projection.shownCount,
+    omittedCandidateCount: projection.omittedCount,
+    selectorSuggestions: suggestionProjection.items,
+    selectorSuggestionCount: suggestionProjection.totalCount,
+    shownSelectorSuggestionCount: suggestionProjection.shownCount,
+    omittedSelectorSuggestionCount: suggestionProjection.omittedCount,
     remediation: suggestions.length > 0 ? "Use one of the scoped handler selectors shown." : "No current CLI selector uniquely identifies these duplicate handler classes."
   };
 }
 function handlerSelectorCandidates(rows2, matchKind) {
-  const candidates = /* @__PURE__ */ new Map();
+  const candidates2 = /* @__PURE__ */ new Map();
   for (const row of rows2) {
     const identity = matchKind === "class" ? `class:${String(row.handlerClassId)}` : `method:${String(row.repoId)}:${String(row.symbolId ?? row.methodId)}`;
-    candidates.set(identity, {
+    candidates2.set(identity, {
       handlerClassId: row.handlerClassId,
       repoId: row.repoId,
       repoName: row.repoName,
@@ -4756,7 +5496,7 @@ function handlerSelectorCandidates(rows2, matchKind) {
       matchKind
     });
   }
-  return [...candidates.values()].sort((left, right) => String(left.repoName ?? "").localeCompare(String(right.repoName ?? "")) || String(left.className ?? "").localeCompare(String(right.className ?? "")) || String(left.sourceFile ?? "").localeCompare(String(right.sourceFile ?? "")));
+  return [...candidates2.values()].sort((left, right) => String(left.repoName ?? "").localeCompare(String(right.repoName ?? "")) || String(left.className ?? "").localeCompare(String(right.className ?? "")) || String(left.sourceFile ?? "").localeCompare(String(right.sourceFile ?? "")));
 }
 function executableScope(rows2, fallbackRepoId) {
   const files = rows2.flatMap((row) => row.sourceFile ? [row.sourceFile] : []);
@@ -4765,7 +5505,7 @@ function executableScope(rows2, fallbackRepoId) {
   return {
     files: new Set(files),
     symbols: new Set(symbols),
-    repoId: numericValue(rows2[0]?.repoId) ?? fallbackRepoId
+    repoId: numericValue3(rows2[0]?.repoId) ?? fallbackRepoId
   };
 }
 function handlerMethodsNotIndexedDiagnostic(row) {
@@ -4825,15 +5565,18 @@ function arrayEvidence(evidenceJson, key) {
   const value = evidenceRecord(evidenceJson)[key];
   return Array.isArray(value) ? value.filter((item) => Boolean(item && typeof item === "object" && !Array.isArray(item))) : [];
 }
-function numericValue(value) {
+function numericValue3(value) {
   return typeof value === "number" ? value : void 0;
 }
 function normalizeOperation(value) {
   if (!value) return void 0;
   return value.startsWith("/") ? value.slice(1) : value;
 }
-function ambiguousStartDiagnostic(requested, candidates, message) {
-  const serviceSuggestions = [...new Set(candidates.flatMap((row) => typeof row.servicePath === "string" ? [`--service ${row.servicePath}`] : []))].sort();
+function ambiguousStartDiagnostic(requested, candidates2, message) {
+  const serviceSuggestions = [...new Set(candidates2.flatMap((row) => typeof row.servicePath === "string" ? [`--service ${row.servicePath}`] : []))].sort();
+  const projection = boundedSelectorCandidates(candidates2);
+  const serviceProjection = boundedSelectorSuggestions(serviceSuggestions);
+  const selectorProjection = boundedSelectorSuggestions(fullSelectorSuggestions(candidates2));
   return {
     severity: "warning",
     code: "trace_start_ambiguous",
@@ -4841,14 +5584,29 @@ function ambiguousStartDiagnostic(requested, candidates, message) {
     normalizedSelectorValue: requested,
     resolutionStage: "operation",
     resolutionStatus: "ambiguous_operation",
-    candidates,
-    serviceSuggestions,
-    selectorSuggestions: fullSelectorSuggestions(candidates)
+    candidates: projection.items,
+    candidateCount: projection.totalCount,
+    shownCandidateCount: projection.shownCount,
+    omittedCandidateCount: projection.omittedCount,
+    serviceSuggestions: serviceProjection.items,
+    serviceSuggestionCount: serviceProjection.totalCount,
+    shownServiceSuggestionCount: serviceProjection.shownCount,
+    omittedServiceSuggestionCount: serviceProjection.omittedCount,
+    selectorSuggestions: selectorProjection.items,
+    selectorSuggestionCount: selectorProjection.totalCount,
+    shownSelectorSuggestionCount: selectorProjection.shownCount,
+    omittedSelectorSuggestionCount: selectorProjection.omittedCount
   };
 }
-function fullSelectorSuggestions(candidates) {
-  const includeRepo = new Set(candidates.map((row) => row.repoName)).size > 1;
-  return [...new Set(candidates.flatMap((row) => {
+function boundedSelectorCandidates(candidates2) {
+  return projectBounded(candidates2, (left, right) => String(left.repoName ?? "").localeCompare(String(right.repoName ?? "")) || String(left.servicePath ?? "").localeCompare(String(right.servicePath ?? "")) || String(left.className ?? "").localeCompare(String(right.className ?? "")) || String(left.sourceFile ?? "").localeCompare(String(right.sourceFile ?? "")) || Number(left.sourceLine ?? 0) - Number(right.sourceLine ?? 0) || Number(left.handlerClassId ?? left.operationId ?? 0) - Number(right.handlerClassId ?? right.operationId ?? 0));
+}
+function boundedSelectorSuggestions(suggestions) {
+  return projectBounded([...new Set(suggestions)], (left, right) => left.localeCompare(right));
+}
+function fullSelectorSuggestions(candidates2) {
+  const includeRepo = new Set(candidates2.map((row) => row.repoName)).size > 1;
+  return [...new Set(candidates2.flatMap((row) => {
     if (typeof row.servicePath !== "string" || typeof row.operationPath !== "string") return [];
     const repoSelector = includeRepo && typeof row.repoName === "string" ? `--repo ${row.repoName} ` : "";
     return [
@@ -4857,13 +5615,136 @@ function fullSelectorSuggestions(candidates) {
   }))].sort();
 }
 
+// src/trace/004-dynamic-candidate-sources.ts
+function dynamicCandidateTargets(db, effectiveOperationPath, originalOperationPath, embedded, workspaceId, requireCanonical) {
+  const canonical = queryOperationTargets(
+    db,
+    effectiveOperationPath,
+    originalOperationPath,
+    workspaceId
+  );
+  if (canonical.length > 0 || requireCanonical) return canonical;
+  return targetsFromEvidence(embedded);
+}
+function targetsFromEvidence(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((item) => {
+    const row = record(item);
+    const operationId = numberValue4(row.operationId);
+    const repoName = stringValue6(row.repoName);
+    const servicePath = stringValue6(row.servicePath);
+    const operationPath = stringValue6(row.operationPath);
+    const operationName = stringValue6(row.operationName) ?? operationPath?.replace(/^\//, "");
+    if (operationId === void 0 || !repoName || !servicePath || !operationPath || !operationName)
+      return [];
+    return [{
+      operationId,
+      repoId: numberValue4(row.repoId),
+      repoName,
+      packageName: stringValue6(row.packageName),
+      serviceName: stringValue6(row.serviceName) ?? "",
+      qualifiedName: stringValue6(row.qualifiedName) ?? "",
+      servicePath,
+      operationPath,
+      operationName,
+      sourceFile: stringValue6(row.sourceFile) ?? "",
+      sourceLine: numberValue4(row.sourceLine) ?? 0,
+      score: numberValue4(row.score) ?? 0,
+      reasons: stringArray3(row.reasons)
+    }];
+  });
+}
+function queryOperationTargets(db, effectiveOperationPath, originalOperationPath, workspaceId) {
+  const operationPath = effectiveOperationPath ?? originalOperationPath;
+  if (!operationPath) return [];
+  if (extractPlaceholders(operationPath).length > 0)
+    return templateOperationTargets(db, operationPath, workspaceId);
+  return exactOperationTargets(db, operationPath, workspaceId);
+}
+function exactOperationTargets(db, operationPath, workspaceId) {
+  const simple = operationPath.replace(/^\//, "").split(".").at(-1) ?? operationPath;
+  const rows2 = recordRows(db.prepare(
+    `SELECT o.id operationId,r.id repoId,r.name repoName,r.package_name packageName,
+      s.service_name serviceName,s.qualified_name qualifiedName,s.service_path servicePath,
+      o.operation_path operationPath,o.operation_name operationName,o.source_file sourceFile,
+      o.source_line sourceLine 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 (o.operation_path IN (?,?) OR o.operation_name=?)
+     ORDER BY r.name,s.service_path,o.operation_name,o.id`
+  ).all(workspaceId, workspaceId, operationPath, `/${simple}`, simple));
+  return rows2.flatMap(targetFromRow);
+}
+function templateOperationTargets(db, operationTemplate, workspaceId) {
+  const rows2 = recordRows(db.prepare(
+    `SELECT o.id operationId,r.id repoId,r.name repoName,r.package_name packageName,
+      s.service_name serviceName,s.qualified_name qualifiedName,s.service_path servicePath,
+      o.operation_path operationPath,o.operation_name operationName,o.source_file sourceFile,
+      o.source_line sourceLine 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=?)
+     ORDER BY r.name,s.service_path,o.operation_name,o.id`
+  ).all(workspaceId, workspaceId));
+  return rows2.flatMap((row) => {
+    const operationPath = stringValue6(row.operationPath);
+    return matchRuntimeTemplate(operationTemplate, operationPath) ? targetFromRow(row) : [];
+  });
+}
+function targetFromRow(row) {
+  const operationId = numberValue4(row.operationId);
+  const repoName = stringValue6(row.repoName);
+  const servicePath = stringValue6(row.servicePath);
+  const operationPath = stringValue6(row.operationPath);
+  const operationName = stringValue6(row.operationName);
+  if (operationId === void 0 || !repoName || !servicePath || !operationPath || !operationName)
+    return [];
+  return [{
+    operationId,
+    repoId: numberValue4(row.repoId),
+    repoName,
+    packageName: stringValue6(row.packageName),
+    serviceName: stringValue6(row.serviceName) ?? "",
+    qualifiedName: stringValue6(row.qualifiedName) ?? "",
+    servicePath,
+    operationPath,
+    operationName,
+    sourceFile: stringValue6(row.sourceFile) ?? "",
+    sourceLine: numberValue4(row.sourceLine) ?? 0,
+    score: 0.2,
+    reasons: ["operation_path_match"]
+  }];
+}
+function record(value) {
+  return isRecord4(value) ? value : {};
+}
+function recordRows(value) {
+  return Array.isArray(value) ? value.filter(isRecord4) : [];
+}
+function isRecord4(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function stringValue6(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function numberValue4(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function stringArray3(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+
 // src/trace/001-dynamic-identity.ts
-function uniqueIdentityDerivations(db, candidates, templates) {
-  const identities = workspaceIdentities(db, candidates);
-  const proposals = candidates.flatMap((candidate) => {
-    const owner = implementationOwner(db, candidate.candidateOperationId);
+function uniqueIdentityDerivations(db, candidates2, templates) {
+  const identities = workspaceIdentities(db, candidates2);
+  const proposals = candidates2.flatMap((candidate) => {
+    const implementation = routeImplementationEvidence(
+      db,
+      candidate.candidateOperationId
+    );
     const identity = identities.find((item) => item.repoId === candidate.repoId);
-    return ownerAgrees(candidate, owner) && identity ? identityProposals(candidate, identity, templates) : [];
+    if (!identity || !implementation || !routeOwnerAgrees(candidate, implementation))
+      return [];
+    return identityProposals(candidate, identity, templates, implementation);
   });
   const matches2 = workspaceIdentityMatches(identities, templates);
   const competing = competingIdentityKeys(matches2);
@@ -4875,7 +5756,7 @@ function uniqueIdentityDerivations(db, candidates, templates) {
     provenance: proposal.provenance
   }));
 }
-function identityProposals(candidate, identity, templates) {
+function identityProposals(candidate, identity, templates, implementation) {
   const routeTemplates = [templates.alias, templates.destination].filter((value) => Boolean(value));
   const identities = [
     { name: identity.packageName, sourceKind: "package_identity", npmPackage: true },
@@ -4886,11 +5767,12 @@ function identityProposals(candidate, identity, templates) {
     template,
     identity2.name,
     identity2.sourceKind,
-    identity2.npmPackage
+    identity2.npmPackage,
+    implementation
   )));
   return deduplicateProposals(proposals);
 }
-function proposalForIdentity(candidate, template, identity, sourceKind, npmPackage) {
+function proposalForIdentity(candidate, template, identity, sourceKind, npmPackage, implementation) {
   const match = matchIdentityTemplate(template, identity, npmPackage);
   if (!match) return [];
   return [{
@@ -4905,7 +5787,13 @@ function proposalForIdentity(candidate, template, identity, sourceKind, npmPacka
       template,
       matchedName: identity,
       normalizedForm: match.normalizedIdentity,
-      sourceRepo: candidate.repoName
+      sourceRepo: candidate.repoName,
+      routeOwner: candidate.repoName,
+      candidateOperationId: candidate.candidateOperationId,
+      effectiveBaseOperationId: implementation.baseOperationId,
+      candidateOperationProvenance: implementation.operationProvenance,
+      implementationEdgeStatus: implementation.edgeStatus,
+      implementationHandlerRepo: implementation.handlerRepo
     }
   }];
 }
@@ -4918,7 +5806,7 @@ function matchIdentityTemplate(template, identity, npmPackage) {
   const [prefix, suffix, extra] = normalizedTemplate.split(sentinel);
   if (!prefix || !suffix || extra !== void 0) return void 0;
   const normalizedIdentity = normalizeIdentity(identity, npmPackage);
-  const match = new RegExp(`^${escapeRegex(prefix)}([a-z0-9]+)${escapeRegex(suffix)}$`).exec(normalizedIdentity);
+  const match = new RegExp(`^${escapeRegex2(prefix)}([a-z0-9]+)${escapeRegex2(suffix)}$`).exec(normalizedIdentity);
   if (!match?.[1]) return void 0;
   return { key: matches2[0][1].trim(), value: match[1], normalizedIdentity };
 }
@@ -4966,8 +5854,8 @@ function workspaceIdentityMatches(identities, templates) {
     }));
   });
 }
-function workspaceIdentities(db, candidates) {
-  const repoIds = [...new Set(candidates.flatMap((candidate) => candidate.repoId === void 0 ? [] : [candidate.repoId]))].sort((a, b) => a - b);
+function workspaceIdentities(db, candidates2) {
+  const repoIds = [...new Set(candidates2.flatMap((candidate) => candidate.repoId === void 0 ? [] : [candidate.repoId]))].sort((a, b) => a - b);
   if (repoIds.length === 0) return [];
   const placeholders3 = repoIds.map(() => "?").join(",");
   const rows2 = db.prepare(`SELECT id repoId,name repoName,package_name packageName
@@ -4975,12 +5863,12 @@ function workspaceIdentities(db, candidates) {
       SELECT DISTINCT workspace_id FROM repositories WHERE id IN (${placeholders3})
     ) ORDER BY workspace_id,name,absolute_path,id`).all(...repoIds);
   return rows2.flatMap((row) => {
-    const repoId = numberValue(row.repoId);
-    const repoName = stringValue4(row.repoName);
+    const repoId = numberValue5(row.repoId);
+    const repoName = stringValue7(row.repoName);
     return repoId === void 0 || !repoName ? [] : [{
       repoId,
       repoName,
-      packageName: stringValue4(row.packageName)
+      packageName: stringValue7(row.packageName)
     }];
   });
 }
@@ -4994,57 +5882,168 @@ function deduplicateProposals(rows2) {
     return true;
   });
 }
-function ownerAgrees(candidate, owner) {
-  return candidate.repoId !== void 0 && owner?.repoId !== void 0 && owner.repoId === candidate.repoId;
+function routeOwnerAgrees(candidate, implementation) {
+  return candidate.repoId !== void 0 && implementation?.routeRepoId === candidate.repoId && implementation.edgeStatus === "resolved" && candidate.viable && candidate.reasons.includes("service_path_template_match");
 }
-function implementationOwner(db, operationId) {
+function routeImplementationEvidence(db, operationId) {
   const rows2 = db.prepare(
-    `SELECT r.id repoId
-     FROM graph_edges e JOIN handler_methods hm ON hm.id=CAST(e.to_id AS INTEGER)
+    `SELECT s.repo_id routeRepoId,o.provenance operationProvenance,
+      o.base_operation_id baseOperationId,e.status edgeStatus,
+      r.name handlerRepo
+     FROM cds_operations o JOIN cds_services s ON s.id=o.service_id
+     JOIN graph_edges e ON e.edge_type='OPERATION_IMPLEMENTED_BY_HANDLER'
+       AND e.from_kind='operation' AND e.from_id=CAST(o.id AS TEXT)
+     JOIN handler_methods hm ON hm.id=CAST(e.to_id AS INTEGER)
      JOIN handler_classes hc ON hc.id=hm.handler_class_id
      JOIN repositories r ON r.id=hc.repo_id
      WHERE e.edge_type='OPERATION_IMPLEMENTED_BY_HANDLER' AND e.status='resolved'
-       AND e.from_kind='operation' AND e.from_id=?
-     ORDER BY r.id,hm.id,e.id`
+       AND o.id=?
+     ORDER BY e.id,hm.id`
   ).all(String(operationId));
   if (rows2.length !== 1) return void 0;
   const row = rows2[0];
   if (!row) return void 0;
   return {
-    repoId: numberValue(row.repoId)
+    routeRepoId: numberValue5(row.routeRepoId),
+    handlerRepo: stringValue7(row.handlerRepo),
+    operationProvenance: stringValue7(row.operationProvenance),
+    baseOperationId: numberValue5(row.baseOperationId),
+    edgeStatus: stringValue7(row.edgeStatus)
   };
 }
 function normalizeIdentity(value, npmPackage = false) {
   const unscoped = npmPackage && /^@[^/]+\/[^/]+$/.test(value) ? value.slice(value.indexOf("/") + 1) : value;
   return unscoped.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
 }
-function stringValue4(value) {
+function stringValue7(value) {
   return typeof value === "string" ? value : void 0;
 }
-function numberValue(value) {
+function numberValue5(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
-function escapeRegex(value) {
+function escapeRegex2(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
 // src/trace/003-dynamic-references.ts
-function dynamicReferenceRows(db, workspaceId, callerRepoId, callerRepo) {
+function dynamicRoutingContext(db, workspaceId, evidence) {
+  const selected = selectedBinding(db, workspaceId, evidence);
+  const persisted = persistedBindingResolution(evidence);
+  const alternatives = boundedAlternatives(
+    persisted.candidates,
+    persisted.candidateCount
+  );
+  if (selected) {
+    const requires = exactRequireReferences(db, workspaceId, selected);
+    return {
+      ...contextBase(selected, persisted.status, alternatives),
+      selectedBinding: selected,
+      references: [selected, ...requires],
+      fallbackUsed: false
+    };
+  }
+  const callerRepoId = numberValue6(evidence.repoId);
+  const callerRepo = stringValue8(evidence.repo);
+  return {
+    outboundCallId: numberValue6(evidence.outboundCallId ?? evidence.callId),
+    callerRepoId,
+    callerRepo,
+    bindingResolutionStatus: persisted.status,
+    bindingAlternatives: alternatives.items,
+    bindingAlternativeCount: alternatives.totalCount,
+    shownBindingAlternativeCount: alternatives.shownCount,
+    omittedBindingAlternativeCount: alternatives.omittedCount,
+    references: fallbackReferences(db, workspaceId, callerRepoId, callerRepo),
+    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}`;
+  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
+  };
+}
+function contextBase(selected, status, alternatives) {
+  return {
+    outboundCallId: selected.outboundCallId,
+    callerRepoId: selected.callerRepoId,
+    callerRepo: selected.repoName,
+    selectedBindingId: selected.bindingId,
+    bindingResolutionStatus: status,
+    bindingAlternatives: alternatives.items,
+    bindingAlternativeCount: alternatives.totalCount,
+    shownBindingAlternativeCount: alternatives.shownCount,
+    omittedBindingAlternativeCount: alternatives.omittedCount
+  };
+}
+function selectedBinding(db, workspaceId, evidence) {
+  const callId = numberValue6(evidence.outboundCallId ?? evidence.callId);
+  if (callId === void 0) return void 0;
+  const row = db.prepare(`SELECT c.id outboundCallId,c.repo_id callerRepoId,r.name repoName,
+      b.id bindingId,b.alias,b.alias_expr aliasExpr,b.destination_expr destination,
+      b.service_path_expr servicePath,b.source_file sourceFile,b.source_line sourceLine,
+      b.helper_chain_json helperChainJson
+    FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id
+    JOIN service_bindings b ON b.id=c.service_binding_id AND b.repo_id=c.repo_id
+    WHERE c.id=? AND (? IS NULL OR r.workspace_id=?)`).get(
+    callId,
+    workspaceId,
+    workspaceId
+  );
+  return selectedReferenceFromRow(row);
+}
+function selectedReferenceFromRow(row) {
+  const outboundCallId = numberValue6(row?.outboundCallId);
+  const callerRepoId = numberValue6(row?.callerRepoId);
+  const reference = referenceFromRow(
+    row,
+    "service_binding",
+    "selected_binding"
+  )[0];
+  return reference && outboundCallId !== void 0 && callerRepoId !== void 0 ? { ...reference, outboundCallId, callerRepoId } : void 0;
+}
+function exactRequireReferences(db, workspaceId, selected) {
+  if (!(selected.aliasExpr ?? selected.alias)) return [];
+  const rows2 = db.prepare(`SELECT req.alias,req.destination,req.service_path servicePath,
+      r.name repoName,'package.json' sourceFile,1 sourceLine
+    FROM cds_requires req JOIN repositories r ON r.id=req.repo_id
+    WHERE req.repo_id=? AND (? IS NULL OR r.workspace_id=?)
+    ORDER BY req.alias,req.id`).all(
+    selected.callerRepoId,
+    workspaceId,
+    workspaceId
+  );
+  return rows2.flatMap((row) => referenceFromRow(
+    row,
+    "cds_require",
+    "selected_binding_require",
+    selected.bindingId
+  ));
+}
+function fallbackReferences(db, workspaceId, callerRepoId, callerRepo) {
   if (callerRepoId === void 0 && callerRepo === void 0) return [];
-  const rows2 = db.prepare(
-    `SELECT COALESCE(b.alias,b.alias_expr) alias,b.destination_expr destination,
-      b.service_path_expr servicePath,'service_binding' sourceKind,r.name repoName,
-      b.source_file sourceFile,b.source_line sourceLine,0 sourcePriority
-     FROM service_bindings b JOIN repositories r ON r.id=b.repo_id
-     WHERE (? IS NULL OR r.workspace_id=?)
-       AND ((? IS NOT NULL AND r.id=?) OR (? IS NULL AND r.name=?))
-     UNION ALL
-     SELECT req.alias,req.destination,req.service_path,'cds_require',r.name,
-      'package.json',1,1 FROM cds_requires req JOIN repositories r ON r.id=req.repo_id
-     WHERE (? IS NULL OR r.workspace_id=?)
-       AND ((? IS NOT NULL AND r.id=?) OR (? IS NULL AND r.name=?))
-     ORDER BY sourcePriority,repoName,sourceFile,sourceLine`
-  ).all(
+  const rows2 = db.prepare(`SELECT b.id bindingId,COALESCE(b.alias,b.alias_expr) alias,
+      b.alias_expr aliasExpr,b.destination_expr destination,b.service_path_expr servicePath,
+      'service_binding' sourceKind,r.name repoName,b.source_file sourceFile,
+      b.source_line sourceLine,b.helper_chain_json helperChainJson,0 sourcePriority
+    FROM service_bindings b JOIN repositories r ON r.id=b.repo_id
+    WHERE (? IS NULL OR r.workspace_id=?)
+      AND ((? IS NOT NULL AND r.id=?) OR (? IS NULL AND r.name=?))
+    UNION ALL
+    SELECT NULL,req.alias,req.alias,req.destination,req.service_path,
+      'cds_require',r.name,'package.json',1,NULL,1
+    FROM cds_requires req JOIN repositories r ON r.id=req.repo_id
+    WHERE (? IS NULL OR r.workspace_id=?)
+      AND ((? IS NOT NULL AND r.id=?) OR (? IS NULL AND r.name=?))
+    ORDER BY sourcePriority,repoName,sourceFile,sourceLine`).all(
     workspaceId,
     workspaceId,
     callerRepoId,
@@ -5058,61 +6057,90 @@ function dynamicReferenceRows(db, workspaceId, callerRepoId, callerRepo) {
     callerRepoId,
     callerRepo
   );
-  return rows2.flatMap(referenceFromRow);
-}
-function dynamicReferenceProvenance(reference, kind, template, value) {
-  return {
-    sourceKind: `${reference.sourceKind}.${kind}`,
-    value,
-    rule: "exact_indexed_reference_template_match",
-    template,
-    sourceRepo: reference.repoName,
-    sourceFile: reference.sourceFile,
-    sourceLine: reference.sourceLine
-  };
+  return rows2.flatMap((row) => {
+    const sourceKind = row.sourceKind;
+    return sourceKind === "service_binding" || sourceKind === "cds_require" ? referenceFromRow(row, sourceKind, "fallback") : [];
+  });
 }
-function referenceFromRow(row) {
-  const sourceKind = row.sourceKind;
-  const repoName = stringValue5(row.repoName);
-  if (sourceKind !== "service_binding" && sourceKind !== "cds_require" || !repoName) return [];
+function referenceFromRow(row, sourceKind, selection, bindingId = numberValue6(row?.bindingId)) {
+  const repoName = stringValue8(row?.repoName);
+  if (!repoName) return [];
   return [{
-    alias: stringValue5(row.alias),
-    destination: stringValue5(row.destination),
-    servicePath: stringValue5(row.servicePath),
+    bindingId,
+    alias: stringValue8(row?.alias),
+    aliasExpr: stringValue8(row?.aliasExpr),
+    destination: stringValue8(row?.destination),
+    servicePath: stringValue8(row?.servicePath),
     sourceKind,
+    selection,
     repoName,
-    sourceFile: stringValue5(row.sourceFile),
-    sourceLine: numberValue2(row.sourceLine)
+    sourceFile: stringValue8(row?.sourceFile),
+    sourceLine: numberValue6(row?.sourceLine),
+    helperChain: parsedJson(row?.helperChainJson)
   }];
 }
-function stringValue5(value) {
+function persistedBindingResolution(evidence) {
+  const outbound = record2(evidence.outboundEvidence);
+  const resolution = record2(outbound.serviceBindingResolution);
+  return {
+    status: stringValue8(resolution.status) ?? "unknown",
+    candidates: recordArray2(resolution.candidates),
+    candidateCount: numberValue6(resolution.candidateCount) ?? 0
+  };
+}
+function boundedAlternatives(rows2, reportedCount) {
+  const projection = projectBounded(rows2, (left, right) => Number(left.bindingId ?? 0) - Number(right.bindingId ?? 0) || String(left.sourceFile ?? "").localeCompare(String(right.sourceFile ?? "")) || Number(left.sourceLine ?? 0) - Number(right.sourceLine ?? 0));
+  const totalCount = Math.max(reportedCount, projection.totalCount);
+  return {
+    ...projection,
+    totalCount,
+    omittedCount: Math.max(0, totalCount - projection.shownCount)
+  };
+}
+function parsedJson(value) {
+  if (typeof value !== "string" || value.length === 0) return void 0;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+}
+function record2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function recordArray2(value) {
+  return Array.isArray(value) ? value.filter((item) => Boolean(item && typeof item === "object" && !Array.isArray(item))) : [];
+}
+function stringValue8(value) {
   return typeof value === "string" ? value : void 0;
 }
-function numberValue2(value) {
+function numberValue6(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
 
 // src/trace/dynamic-targets.ts
 function analyzeDynamicTargetCandidates(db, evidence, workspaceId, mode, maxCandidates) {
-  const inputs = analysisInputs(evidence);
+  const inputs = analysisInputs(db, evidence, workspaceId);
   if (inputs.required.length === 0) return void 0;
-  const targets = candidateTargets(db, evidence, workspaceId);
-  const references = dynamicReferenceRows(
+  const targets = dynamicCandidateTargets(
     db,
+    inputs.effective.operationPath,
+    inputs.original.operationPath,
+    evidence.candidates,
     workspaceId,
-    inputs.callerRepoId,
-    inputs.callerRepo
+    inputs.routing.outboundCallId !== void 0
   );
-  const candidates = buildCandidates(db, targets, references, inputs);
-  applyUniqueIdentityEvidence(db, candidates, inputs);
-  finalizeCandidates(candidates, inputs.order);
-  const ranked = stableRank(candidates);
+  const candidates2 = buildCandidates(db, targets, inputs.routing.references, inputs);
+  applyUniqueIdentityEvidence(db, candidates2, inputs);
+  finalizeCandidates(candidates2, inputs.order);
+  const ranked = stableRank(candidates2);
   const inference = inferenceDecision(ranked);
   applyModeState(ranked, mode, inference);
   const viable = ranked.filter((candidate) => candidate.viable);
   const rejected = ranked.filter((candidate) => candidate.rejected);
   const shown = viable.slice(0, maxCandidates).map((candidate) => boundedCandidate(candidate, maxCandidates));
   const shownRejected = rejected.slice(0, maxCandidates).map((candidate) => boundedCandidate(candidate, maxCandidates));
+  const suggestionProjection = suggestedVarSets(viable, inputs.order, maxCandidates);
   return {
     mode,
     maxCandidates,
@@ -5131,16 +6159,21 @@ function analyzeDynamicTargetCandidates(db, evidence, workspaceId, mode, maxCand
     candidates: shown,
     shownCandidates: shown,
     rejectedCandidates: shownRejected,
-    suggestedVarSets: suggestedVarSets(viable, inputs.order, maxCandidates),
-    inference
+    suggestedVarSets: suggestionProjection.items,
+    suggestedVarSetCount: suggestionProjection.totalCount,
+    shownSuggestedVarSetCount: suggestionProjection.shownCount,
+    omittedSuggestedVarSetCount: suggestionProjection.omittedCount,
+    inference,
+    routingContext: routingEvidence2(inputs.routing)
   };
 }
-function analysisInputs(evidence) {
-  const original = templatesFromEvidence(evidence, "original");
-  const effective = templatesFromEvidence(evidence, "effective");
+function analysisInputs(db, evidence, workspaceId) {
+  const routing = dynamicRoutingContext(db, workspaceId, evidence);
+  const supplied = stringRecord(evidence.suppliedRuntimeVariables);
+  const original = templatesFromEvidence(evidence, routing);
+  const effective = effectiveTemplates(original, supplied);
   const requiredSources = placeholderSources(original);
   const required = Object.keys(requiredSources);
-  const supplied = stringRecord(evidence.suppliedRuntimeVariables);
   return {
     original,
     effective,
@@ -5148,94 +6181,51 @@ function analysisInputs(evidence) {
     requiredSources,
     supplied,
     order: variableOrder(original, required),
-    callerRepo: stringValue6(evidence.repo),
-    callerRepoId: numberValue3(evidence.repoId)
+    callerRepo: routing.callerRepo ?? stringValue9(evidence.repo),
+    callerRepoId: routing.callerRepoId ?? numberValue7(evidence.repoId),
+    routing
   };
 }
-function candidateTargets(db, evidence, workspaceId) {
-  const embedded = rowsFromEvidence(evidence.candidates);
-  if (embedded.length > 0) return embedded;
-  const operationPath = effectiveSignal(evidence, "operationPath");
-  if (!operationPath || extractPlaceholders(operationPath).length > 0) return [];
-  return queryOperationTargets(db, operationPath, workspaceId);
-}
-function rowsFromEvidence(value) {
-  if (!Array.isArray(value)) return [];
-  return value.flatMap((item) => {
-    const row = record(item);
-    const operationId = numberValue3(row.operationId);
-    const repoName = stringValue6(row.repoName);
-    const servicePath = stringValue6(row.servicePath);
-    const operationPath = stringValue6(row.operationPath);
-    const operationName = stringValue6(row.operationName) ?? operationPath?.replace(/^\//, "");
-    if (operationId === void 0 || !repoName || !servicePath || !operationPath || !operationName) return [];
-    return [{
-      operationId,
-      repoId: numberValue3(row.repoId),
-      repoName,
-      packageName: stringValue6(row.packageName),
-      serviceName: stringValue6(row.serviceName) ?? "",
-      qualifiedName: stringValue6(row.qualifiedName) ?? "",
-      servicePath,
-      operationPath,
-      operationName,
-      sourceFile: stringValue6(row.sourceFile) ?? "",
-      sourceLine: numberValue3(row.sourceLine) ?? 0,
-      score: numberValue3(row.score) ?? 0,
-      reasons: stringArray(row.reasons)
-    }];
-  });
-}
-function queryOperationTargets(db, operationPath, workspaceId) {
-  const simple = operationPath.replace(/^\//, "").split(".").at(-1) ?? operationPath;
-  const rows2 = db.prepare(
-    `SELECT o.id operationId,r.id repoId,r.name repoName,r.package_name packageName,
-      s.service_name serviceName,s.qualified_name qualifiedName,s.service_path servicePath,
-      o.operation_path operationPath,o.operation_name operationName,o.source_file sourceFile,
-      o.source_line sourceLine 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 (o.operation_path IN (?,?) OR o.operation_name=?)
-     ORDER BY r.name,s.service_path,o.operation_name,o.id`
-  ).all(workspaceId, workspaceId, operationPath, `/${simple}`, simple);
-  return rows2.flatMap(operationTargetFromRow);
-}
-function operationTargetFromRow(row) {
-  const operationId = numberValue3(row.operationId);
-  const repoName = stringValue6(row.repoName);
-  const servicePath = stringValue6(row.servicePath);
-  const operationPath = stringValue6(row.operationPath);
-  const operationName = stringValue6(row.operationName);
-  if (operationId === void 0 || !repoName || !servicePath || !operationPath || !operationName) return [];
-  return [{
-    operationId,
-    repoId: numberValue3(row.repoId),
-    repoName,
-    packageName: stringValue6(row.packageName),
-    serviceName: stringValue6(row.serviceName) ?? "",
-    qualifiedName: stringValue6(row.qualifiedName) ?? "",
-    servicePath,
-    operationPath,
-    operationName,
-    sourceFile: stringValue6(row.sourceFile) ?? "",
-    sourceLine: numberValue3(row.sourceLine) ?? 0,
-    score: 0.2,
-    reasons: ["operation_path_match"]
-  }];
-}
 function buildCandidates(db, targets, references, inputs) {
   return targets.map((target) => {
     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) => reference.servicePath === target.servicePath);
-    applyReferenceSignal(state, inputs, matchingReferences, "alias");
-    applyReferenceSignal(state, inputs, matchingReferences, "destination");
+    const matchingReferences = references.filter((reference) => referenceMatchesCandidate(reference, target.servicePath) && referenceMatchesSelectedAlias(reference, inputs.routing.selectedBinding));
+    const referencesForSignals = fallbackReferencesForCandidate(
+      state,
+      matchingReferences,
+      inputs.routing.fallbackUsed
+    );
+    applyReferenceSignal(state, inputs, referencesForSignals, "alias");
+    applyReferenceSignal(state, inputs, referencesForSignals, "destination");
     if (hasResolvedImplementation(db, target.operationId))
       addScore(state, 0.1, "implementation_edge_resolved");
     return state;
   });
 }
+function fallbackReferencesForCandidate(state, references, fallbackUsed) {
+  if (!fallbackUsed) return references;
+  const unique3 = uniqueFallbackReferences(references);
+  if (unique3.length <= 1) return unique3;
+  addReason(state, "fallback_reference_ambiguous");
+  addInferenceBlock(state, "fallback_reference_ambiguous");
+  return [];
+}
+function uniqueFallbackReferences(references) {
+  const seen = /* @__PURE__ */ new Set();
+  return references.filter((reference) => {
+    const signature = [
+      reference.sourceKind,
+      reference.alias,
+      reference.destination,
+      reference.servicePath
+    ].join("\0");
+    if (seen.has(signature)) return false;
+    seen.add(signature);
+    return true;
+  });
+}
 function emptyCandidate(target, inputs) {
   return {
     candidateOperationId: target.operationId,
@@ -5274,20 +6264,25 @@ function emptyCandidate(target, inputs) {
 function applyDirectSignal(state, inputs, kind, concrete, score) {
   const effective = inputs.effective[kind];
   const original = inputs.original[kind];
-  if (effective && !matchTemplate(effective, concrete)) {
+  if (effective && !matchRuntimeTemplate(effective, concrete)) {
     reject(state, `${signalCode(kind)}_contradicts_runtime_substitution`);
     return;
   }
   if (!effective) return;
   const suppliedKeys = extractPlaceholders(original).filter((key) => inputs.supplied[key] !== void 0);
   state.explicitSignalStrength += suppliedKeys.length;
-  const matched = matchTemplate(original, concrete) ?? {};
+  const matched = matchRuntimeTemplate(original, concrete) ?? {};
+  const fromSelectedBinding = kind === "servicePath" && inputs.routing.selectedBinding !== void 0;
   for (const [key, value] of Object.entries(matched)) {
     addDerivation(state, key, value, {
-      sourceKind: `${signalCode(kind)}_template`,
+      sourceKind: fromSelectedBinding ? `selected_binding.${signalCode(kind)}_template` : `${signalCode(kind)}_template`,
       value,
-      rule: "exact_template_match",
-      template: original
+      rule: fromSelectedBinding ? "exact_selected_binding_template_match" : "exact_template_match",
+      template: original,
+      sourceRepo: fromSelectedBinding ? inputs.routing.selectedBinding?.repoName : void 0,
+      sourceFile: fromSelectedBinding ? inputs.routing.selectedBinding?.sourceFile : void 0,
+      sourceLine: fromSelectedBinding ? inputs.routing.selectedBinding?.sourceLine : void 0,
+      selection: fromSelectedBinding ? "selected_binding" : "call_evidence"
     });
   }
   addScore(state, score, `${signalCode(kind)}_template_match`);
@@ -5305,7 +6300,7 @@ function applyReferenceSignal(state, inputs, references, kind) {
   }
   let matchedSignal = false;
   for (const { reference, concrete } of values) {
-    const matched = matchTemplate(original, concrete);
+    const matched = matchRuntimeTemplate(original, concrete);
     if (!matched) continue;
     matchedSignal = true;
     for (const [key, value] of Object.entries(matched)) {
@@ -5322,9 +6317,9 @@ function applyReferenceSignal(state, inputs, references, kind) {
     addScore(state, 0.2, `${kind}_template_match`);
   }
 }
-function applyUniqueIdentityEvidence(db, candidates, inputs) {
-  for (const derivation of uniqueIdentityDerivations(db, candidates, inputs.original)) {
-    const candidate = candidates.find((item) => item.candidateOperationId === derivation.operationId);
+function applyUniqueIdentityEvidence(db, candidates2, inputs) {
+  for (const derivation of uniqueIdentityDerivations(db, candidates2, inputs.original)) {
+    const candidate = candidates2.find((item) => item.candidateOperationId === derivation.operationId);
     if (!candidate) continue;
     addDerivation(candidate, derivation.key, derivation.value, derivation.provenance);
     addScore(candidate, 0.2, "exact_identity_template_match");
@@ -5362,8 +6357,8 @@ function uniqueProvenance(rows2) {
     return true;
   });
 }
-function finalizeCandidates(candidates, order) {
-  for (const candidate of candidates) {
+function finalizeCandidates(candidates2, order) {
+  for (const candidate of candidates2) {
     candidate.missingVariables = order.filter((key) => candidate.completeVariables[key] === void 0);
     candidate.viable = candidate.rejectedReasons.length === 0;
     candidate.rejected = !candidate.viable;
@@ -5375,15 +6370,17 @@ function finalizeCandidates(candidates, order) {
     candidate.cli = candidate.missingVariables.length === 0 && candidate.viable ? cliFor(candidate.completeVariables, order) : void 0;
   }
 }
-function stableRank(candidates) {
-  return [...candidates].sort((left, right) => Number(right.viable) - Number(left.viable) || right.score - left.score || right.explicitSignalStrength - left.explicitSignalStrength || left.repoName.localeCompare(right.repoName) || String(left.packageName ?? "").localeCompare(String(right.packageName ?? "")) || left.servicePath.localeCompare(right.servicePath) || left.operationPath.localeCompare(right.operationPath) || left.operationName.localeCompare(right.operationName) || left.candidateOperationId - right.candidateOperationId);
+function stableRank(candidates2) {
+  return [...candidates2].sort((left, right) => Number(right.viable) - Number(left.viable) || right.score - left.score || right.explicitSignalStrength - left.explicitSignalStrength || left.repoName.localeCompare(right.repoName) || String(left.packageName ?? "").localeCompare(String(right.packageName ?? "")) || left.servicePath.localeCompare(right.servicePath) || left.operationPath.localeCompare(right.operationPath) || left.operationName.localeCompare(right.operationName) || left.candidateOperationId - right.candidateOperationId);
 }
-function inferenceDecision(candidates) {
-  const viable = candidates.filter((candidate) => candidate.viable);
+function inferenceDecision(candidates2) {
+  const viable = candidates2.filter((candidate) => candidate.viable);
   const first = viable[0];
   const second = viable[1];
   if (!first || first.missingVariables.length > 0)
     return { status: "unresolved", reason: "missing_required_runtime_variable" };
+  if (first.inferenceBlockReasons.length > 0)
+    return { status: "unresolved", reason: first.inferenceBlockReasons[0] };
   if (first.score < 0.85)
     return { status: "unresolved", reason: "candidate_score_below_inference_threshold" };
   const scoreGap = second ? Number((first.score - second.score).toFixed(12)) : void 0;
@@ -5402,57 +6399,90 @@ function inferenceDecision(candidates) {
   };
 }
 function boundedCandidate(candidate, limit) {
-  const derivationProvenance = Object.fromEntries(
-    Object.entries(candidate.derivationProvenance).sort(([left], [right]) => left.localeCompare(right)).map(([key, rows2]) => [key, rows2.slice(0, limit)])
+  const provenanceProjections = Object.fromEntries(
+    Object.entries(candidate.derivationProvenance).sort(([left], [right]) => left.localeCompare(right)).map(([key, rows2]) => [key, projectBounded(rows2, compareProvenance, limit)])
   );
-  const conflicts = candidate.conflicts.slice(0, limit).map((conflict) => ({
+  const derivationProvenance = Object.fromEntries(Object.entries(provenanceProjections).map(([key, projection]) => [key, projection.items]));
+  const derivationProvenanceCounts = Object.fromEntries(Object.entries(provenanceProjections).map(([key, projection]) => [key, {
+    provenanceCount: projection.totalCount,
+    shownProvenanceCount: projection.shownCount,
+    omittedProvenanceCount: projection.omittedCount
+  }]));
+  const conflicts = projectBounded(candidate.conflicts, compareConflict, limit);
+  return {
+    ...candidate,
+    derivationProvenance,
+    derivationProvenanceCounts,
+    conflicts: conflicts.items.map(boundedConflict),
+    conflictCount: conflicts.totalCount,
+    shownConflictCount: conflicts.shownCount,
+    omittedConflictCount: conflicts.omittedCount
+  };
+}
+function compareProvenance(left, right) {
+  return left.sourceKind.localeCompare(right.sourceKind) || String(left.matchedName ?? "").localeCompare(String(right.matchedName ?? "")) || left.value.localeCompare(right.value);
+}
+function compareConflict(left, right) {
+  return left.key.localeCompare(right.key) || left.reason.localeCompare(right.reason) || left.values.join("\0").localeCompare(right.values.join("\0"));
+}
+function boundedConflict(conflict) {
+  const sources = projectBounded(conflict.sources, (left, right) => left.localeCompare(right));
+  return {
     ...conflict,
-    sources: conflict.sources.slice(0, limit)
-  }));
-  return { ...candidate, derivationProvenance, conflicts };
+    sources: sources.items,
+    sourceCount: sources.totalCount,
+    shownSourceCount: sources.shownCount,
+    omittedSourceCount: sources.omittedCount
+  };
 }
-function applyModeState(candidates, mode, inference) {
-  const selectedId = mode === "infer" && inference.status === "resolved" ? numberValue3(inference.candidateOperationId) : void 0;
-  for (const candidate of candidates) {
+function applyModeState(candidates2, mode, inference) {
+  const selectedId = mode === "infer" && inference.status === "resolved" ? numberValue7(inference.candidateOperationId) : void 0;
+  for (const candidate of candidates2) {
     candidate.selected = selectedId === candidate.candidateOperationId;
     candidate.exploratory = mode === "candidates" && candidate.viable;
   }
 }
-function suggestedVarSets(candidates, order, limit) {
+function suggestedVarSets(candidates2, order, limit) {
   const seen = /* @__PURE__ */ new Set();
   const rows2 = [];
-  for (const candidate of candidates) {
+  for (const candidate of candidates2) {
     if (!candidate.cli || candidate.missingVariables.length > 0) continue;
     if (seen.has(candidate.cli)) continue;
     seen.add(candidate.cli);
     rows2.push({ variables: orderedVariables(candidate.completeVariables, order), cli: candidate.cli });
-    if (rows2.length >= limit) break;
   }
-  return rows2;
+  return projectBounded(rows2, (left, right) => left.cli.localeCompare(right.cli), limit);
 }
 function hasResolvedImplementation(db, operationId) {
   return Boolean(db.prepare(
     "SELECT 1 FROM graph_edges WHERE edge_type='OPERATION_IMPLEMENTED_BY_HANDLER' AND status='resolved' AND from_kind='operation' AND from_id=? LIMIT 1"
   ).get(String(operationId)));
 }
-function templatesFromEvidence(evidence, phase) {
+function templatesFromEvidence(evidence, routing) {
+  const selected = routing.selectedBinding;
   return {
-    servicePath: substitutionSignal(evidence, "servicePath", phase),
-    operationPath: substitutionSignal(evidence, "operationPath", phase),
-    alias: substitutionSignal(
+    servicePath: selected?.servicePath ?? substitutionSignal(evidence, "servicePath", "original"),
+    operationPath: substitutionSignal(evidence, "operationPath", "original"),
+    alias: selected?.aliasExpr ?? selected?.alias ?? substitutionSignal(
       evidence,
       evidence.serviceAliasExpr !== void 0 ? "serviceAliasExpr" : "serviceAlias",
-      phase
+      "original"
     ),
-    destination: substitutionSignal(evidence, "destination", phase)
+    destination: selected?.destination ?? substitutionSignal(evidence, "destination", "original")
   };
 }
-function substitutionSignal(evidence, key, phase) {
-  const substitution = record(record(evidence.runtimeSubstitutions)[key]);
-  return stringValue6(substitution[phase]) ?? stringValue6(evidence[key]);
+function effectiveTemplates(templates, supplied) {
+  const operationPath = applyVariables(templates.operationPath, supplied);
+  return {
+    servicePath: applyVariables(templates.servicePath, supplied),
+    operationPath: normalizeODataOperationInvocationPath(operationPath)?.normalizedOperationPath ?? operationPath,
+    alias: applyVariables(templates.alias, supplied),
+    destination: applyVariables(templates.destination, supplied)
+  };
 }
-function effectiveSignal(evidence, key) {
-  return substitutionSignal(evidence, key, "effective");
+function substitutionSignal(evidence, key, phase) {
+  const substitution = record3(record3(evidence.runtimeSubstitutions)[key]);
+  return stringValue9(substitution[phase]) ?? stringValue9(evidence[key]);
 }
 function placeholderSources(templates) {
   const sources = {};
@@ -5472,31 +6502,13 @@ function variableOrder(templates, required) {
   ].flatMap((value) => extractPlaceholders(value));
   return [.../* @__PURE__ */ new Set([...ordered, ...required])];
 }
-function matchTemplate(template, concrete) {
-  if (!template || !concrete) return void 0;
-  const keys = extractPlaceholders(template);
-  if (keys.length === 0) return template === concrete ? {} : void 0;
-  const match = new RegExp(`^${templateToPattern(template)}$`).exec(concrete);
-  if (!match) return void 0;
-  const values = {};
-  for (let index = 0; index < keys.length; index += 1) {
-    const key = keys[index];
-    const value = match[index + 1];
-    if (!key || value === void 0) return void 0;
-    if (values[key] !== void 0 && values[key] !== value) return void 0;
-    values[key] = value;
-  }
-  return values;
+function referenceMatchesCandidate(reference, servicePath) {
+  return matchRuntimeTemplate(reference.servicePath, servicePath) !== void 0;
 }
-function templateToPattern(template) {
-  let pattern = "";
-  let lastIndex = 0;
-  for (const match of template.matchAll(/\$\{([^}]*)\}/g)) {
-    pattern += escapeRegex2(template.slice(lastIndex, match.index));
-    pattern += "([^/]+?)";
-    lastIndex = (match.index ?? 0) + match[0].length;
-  }
-  return `${pattern}${escapeRegex2(template.slice(lastIndex))}`;
+function referenceMatchesSelectedAlias(reference, selected) {
+  if (reference.selection !== "selected_binding_require") return true;
+  const template = selected?.aliasExpr ?? selected?.alias;
+  return matchRuntimeTemplate(template, reference.alias) !== void 0;
 }
 function cliFor(variables, order) {
   return order.filter((key) => variables[key] !== void 0).map((key) => `--var ${shellArgument(`${key}=${variables[key]}`)}`).join(" ");
@@ -5530,39 +6542,252 @@ function addInferenceBlock(state, reason) {
 function requiredSuppliedVariables(inputs) {
   return Object.fromEntries(inputs.required.flatMap((key) => inputs.supplied[key] === void 0 ? [] : [[key, inputs.supplied[key]]]));
 }
+function routingEvidence2(routing) {
+  const binding = routing.selectedBinding;
+  return {
+    outboundCallId: routing.outboundCallId,
+    callerRepoId: routing.callerRepoId,
+    callerRepo: routing.callerRepo,
+    selectedBindingId: routing.selectedBindingId,
+    bindingResolutionStatus: routing.bindingResolutionStatus,
+    selectedBinding: binding ? {
+      bindingId: binding.bindingId,
+      alias: binding.alias,
+      aliasExpr: binding.aliasExpr,
+      destination: binding.destination,
+      destinationExpr: binding.destination,
+      servicePath: binding.servicePath,
+      servicePathExpr: binding.servicePath,
+      sourceFile: binding.sourceFile,
+      sourceLine: binding.sourceLine,
+      helperChain: binding.helperChain
+    } : void 0,
+    bindingAlternativeCount: routing.bindingAlternativeCount,
+    shownBindingAlternativeCount: routing.shownBindingAlternativeCount,
+    omittedBindingAlternativeCount: routing.omittedBindingAlternativeCount,
+    bindingAlternatives: routing.bindingAlternatives,
+    fallbackUsed: routing.fallbackUsed
+  };
+}
 function signalCode(kind) {
   return kind === "servicePath" ? "service_path" : "operation_path";
 }
-function record(value) {
+function record3(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 function stringRecord(value) {
-  const entries = Object.entries(record(value)).filter((entry) => typeof entry[1] === "string").sort(([left], [right]) => left.localeCompare(right));
+  const entries = Object.entries(record3(value)).filter((entry) => typeof entry[1] === "string").sort(([left], [right]) => left.localeCompare(right));
   return Object.fromEntries(entries);
 }
-function stringValue6(value) {
+function stringValue9(value) {
   return typeof value === "string" ? value : void 0;
 }
-function numberValue3(value) {
+function numberValue7(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
-function stringArray(value) {
+function stringArray4(value) {
   return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
 }
 function nonEmptyStrings(value, fallback) {
-  const values = stringArray(value).filter((item) => item.length > 0);
+  const values = stringArray4(value).filter((item) => item.length > 0);
   return values.length > 0 ? values : fallback;
 }
 function isConcrete(value) {
   return typeof value === "string" && value.length > 0 && extractPlaceholders(value).length === 0;
 }
-function escapeRegex2(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+// src/trace/006-contextual-projection.ts
+function boundedContextCandidates(values) {
+  const candidates2 = values.flatMap((value) => {
+    return isRecord5(value) ? [value] : [];
+  });
+  const projection = projectBounded(candidates2, (left, right) => Number(right.score ?? 0) - Number(left.score ?? 0) || String(left.repoName ?? "").localeCompare(String(right.repoName ?? "")) || String(left.servicePath ?? "").localeCompare(String(right.servicePath ?? "")) || String(left.sourceFile ?? "").localeCompare(String(right.sourceFile ?? "")) || Number(left.sourceLine ?? 0) - Number(right.sourceLine ?? 0) || Number(left.bindingId ?? left.operationId ?? 0) - Number(right.bindingId ?? right.operationId ?? 0));
+  return {
+    candidates: projection.items,
+    candidateCount: projection.totalCount,
+    shownCandidateCount: projection.shownCount,
+    omittedCandidateCount: projection.omittedCount
+  };
+}
+function isRecord5(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+// src/trace/008-contextual-runtime-state.ts
+function dynamicMissingReason(keys) {
+  const missing = normalizedKeys(keys);
+  return missing.length > 0 ? `Dynamic target is missing runtime variables: ${missing.join(", ")}` : "Dynamic target still requires runtime variables";
+}
+function isStructuralContextualBlocker(state) {
+  return state?.category === "ambiguous_binding" || state?.category === "ambiguous_operation" || state?.category === "no_matching_operation" || state?.category === "other_blocker";
+}
+function contextualRuntimeResolution(db, call, binding, workspaceId, persistedRows = []) {
+  if (!binding || call.call_type !== "remote_action" || call.operation_path_expr === void 0 || call.operation_path_expr === null)
+    return { state: { category: "none" } };
+  if (binding.resolutionStatus === "ambiguous")
+    return ambiguousBindingResolution(binding);
+  return selectedBindingResolution(db, call, binding, workspaceId, persistedRows);
+}
+function ambiguousBindingResolution(binding) {
+  const candidates2 = boundedContextCandidates(binding.bindingCandidates ?? []);
+  const state = {
+    category: "ambiguous_binding",
+    message: "Ambiguous contextual service binding candidates",
+    resolutionStatus: "ambiguous"
+  };
+  return {
+    evidence: {
+      contextualServiceBindingAttempted: true,
+      contextualBinding: {
+        source: binding.source,
+        status: "tied",
+        candidates: candidates2.candidates,
+        candidateCount: candidates2.candidateCount,
+        shownCandidateCount: candidates2.shownCandidateCount,
+        omittedCandidateCount: candidates2.omittedCandidateCount
+      },
+      contextualResolutionStatus: "ambiguous",
+      contextualCandidateCount: candidates2.candidateCount,
+      contextualPreSubstitutionState: historicalState(state)
+    },
+    state
+  };
+}
+function selectedBindingResolution(db, call, binding, workspaceId, persistedRows) {
+  const normalized = normalizeODataOperationInvocationPath(
+    String(call.operation_path_expr)
+  );
+  const operationPath = normalized?.normalizedOperationPath ?? withLeadingSlash(String(call.operation_path_expr));
+  const servicePath = binding.effectiveServicePath ?? binding.servicePathExpr ?? binding.requireServicePath;
+  const destination = binding.effectiveDestination ?? binding.destinationExpr ?? binding.requireDestination;
+  const resolution = resolveOperation(db, {
+    servicePath,
+    operationPath,
+    alias: binding.aliasExpr ?? binding.alias,
+    destination,
+    hasExplicitOverride: true,
+    isDynamic: false
+  }, workspaceId);
+  const state = stateForResolution(resolution);
+  const evidence = contextualEvidence(
+    binding,
+    normalized,
+    operationPath,
+    servicePath,
+    destination,
+    resolution,
+    state
+  );
+  if (!resolution.target) return { evidence, state };
+  const resolvedEvidence = {
+    ...evidence,
+    contextualServiceBindingSelected: true,
+    targetRepo: resolution.target.repoName,
+    targetServicePath: resolution.target.servicePath,
+    targetOperationPath: resolution.target.operationPath,
+    targetOperation: resolution.target.operationName
+  };
+  if (persistedRows.some((row) => row.status === "resolved"))
+    return { evidence: { ...resolvedEvidence, contextualPreservedPersistedResolvedEdge: true }, state };
+  return {
+    row: {
+      id: -call.id,
+      edge_type: "REMOTE_CALL_RESOLVES_TO_OPERATION",
+      from_id: String(call.id),
+      to_kind: "operation",
+      to_id: String(resolution.target.operationId),
+      confidence: resolution.target.score,
+      evidence_json: JSON.stringify(resolvedEvidence),
+      status: "resolved"
+    },
+    evidence: resolvedEvidence,
+    state
+  };
+}
+function contextualEvidence(binding, normalized, operationPath, servicePath, destination, resolution, state) {
+  const candidates2 = boundedContextCandidates(resolution.candidates);
+  return {
+    contextualServiceBindingAttempted: true,
+    contextualBinding: bindingEvidence2(binding),
+    operationPath,
+    rawOperationPath: normalized?.rawOperationPath,
+    normalizedOperationPath: normalized?.wasInvocation ? normalized.normalizedOperationPath : void 0,
+    invocationArgumentPlaceholderKeys: normalized?.invocationArgumentPlaceholderKeys.length ? normalized.invocationArgumentPlaceholderKeys : void 0,
+    servicePath,
+    serviceAlias: binding.alias,
+    serviceAliasExpr: binding.aliasExpr,
+    destination,
+    requireServicePath: binding.requireServicePath,
+    requireDestination: binding.requireDestination,
+    effectiveServicePath: binding.effectiveServicePath,
+    effectiveDestination: binding.effectiveDestination,
+    contextualResolutionStatus: resolution.status,
+    contextualCandidateCount: candidates2.candidateCount,
+    shownContextualCandidateCount: candidates2.shownCandidateCount,
+    omittedContextualCandidateCount: candidates2.omittedCandidateCount,
+    candidates: candidates2.candidates,
+    contextualResolutionReasons: resolution.reasons,
+    resolutionReasons: resolution.reasons,
+    contextualPreSubstitutionState: historicalState(state)
+  };
+}
+function bindingEvidence2(binding) {
+  return {
+    source: binding.source,
+    callerArgument: binding.callerArgument,
+    callerProperty: binding.callerProperty,
+    calleeParameter: binding.calleeParameter,
+    calleeReceiver: binding.calleeReceiver,
+    callerSite: binding.callerSite,
+    calleeSite: binding.calleeSite,
+    bindingSourceFile: binding.sourceFile,
+    bindingSourceLine: binding.sourceLine,
+    alias: binding.alias,
+    aliasExpr: binding.aliasExpr,
+    requireServicePath: binding.requireServicePath,
+    requireDestination: binding.requireDestination,
+    effectiveServicePath: binding.effectiveServicePath,
+    effectiveDestination: binding.effectiveDestination
+  };
+}
+function stateForResolution(resolution) {
+  if (resolution.status === "resolved") return { category: "none" };
+  if (resolution.status === "dynamic") {
+    const missingVariables = missingVariableKeys(resolution.reasons);
+    return {
+      category: "dynamic_missing",
+      message: dynamicMissingReason(missingVariables),
+      missingVariables,
+      resolutionStatus: resolution.status
+    };
+  }
+  if (resolution.status === "ambiguous") return {
+    category: "ambiguous_operation",
+    message: "Ambiguous contextual operation candidates",
+    resolutionStatus: resolution.status
+  };
+  return {
+    category: resolution.status === "unresolved" ? "no_matching_operation" : "other_blocker",
+    message: resolution.status === "unresolved" ? "No contextual operation candidate matched" : "Contextual operation resolution is blocked",
+    resolutionStatus: resolution.status
+  };
+}
+function historicalState(state) {
+  return { ...state, phase: "before_runtime_substitution" };
+}
+function missingVariableKeys(reasons) {
+  return normalizedKeys(reasons.flatMap((reason) => reason.startsWith("missing_variable:") ? [reason.slice("missing_variable:".length)] : []));
+}
+function normalizedKeys(keys) {
+  return [...new Set(keys.filter((key) => key.length > 0))].sort();
+}
+function withLeadingSlash(value) {
+  return value.startsWith("/") ? value : `/${value}`;
 }
 
 // src/trace/evidence.ts
-function baseTraceEvidence(row, call, persistedEvidence, contextualEvidence) {
-  const evidence = { ...persistedEvidence, ...contextualEvidence ?? {} };
+function baseTraceEvidence(row, call, persistedEvidence, contextualEvidence2) {
+  const evidence = { ...persistedEvidence, ...contextualEvidence2 ?? {} };
   return {
     ...evidence,
     graphEdgeId: row.id,
@@ -5576,20 +6801,21 @@ function baseTraceEvidence(row, call, persistedEvidence, contextualEvidence) {
     file: call.source_file,
     line: call.source_line,
     persistedTarget: { kind: row.to_kind, id: row.to_id },
-    contextualResolutionParticipated: Boolean(contextualEvidence?.contextualServiceBindingAttempted),
+    contextualResolutionParticipated: Boolean(contextualEvidence2?.contextualServiceBindingAttempted),
     persistedResolution: persistedResolution(row)
   };
 }
-function runtimeResolution(db, row, evidence, options, workspaceId, contextualUnresolvedReason) {
+function runtimeResolution(db, row, evidence, options, workspaceId, contextualState) {
   const dynamicMode = options.dynamicMode ?? "strict";
   const candidateCap = positiveCandidateCap(options.maxDynamicCandidates);
+  const boundedEvidence = boundCandidateLikeEvidence(evidence, candidateCap);
   if (!isDynamicRemoteOperationEdge(row, evidence))
     return unchangedRuntimeResolution(
       row,
-      boundDynamicEvidence(evidence, candidateCap),
-      contextualUnresolvedReason
+      boundDynamicEvidence(boundedEvidence, candidateCap),
+      contextualState
     );
-  const substituted = evidenceWithRuntimeVariables(evidence, options.vars);
+  const substituted = evidenceWithRuntimeVariables(boundedEvidence, options.vars);
   const analysis = analyzeDynamicTargetCandidates(
     db,
     substituted,
@@ -5601,44 +6827,98 @@ function runtimeResolution(db, row, evidence, options, workspaceId, contextualUn
     analysis ? evidenceWithDynamicAnalysis(substituted, analysis) : substituted,
     candidateCap
   );
-  if (analysis && analysis.candidateCount > 0 && analysis.viableCandidateCount === 0 && Object.keys(analysis.appliedSuppliedVariables).length > 0)
-    return noCandidateRuntimeResolution(row, enriched);
-  if (dynamicMode === "infer") {
-    const inferred = inferredTarget(analysis);
-    if (inferred)
-      return resolvedRuntimeResolution(row, enriched, inferred, inferred.reasons);
-  }
-  if (!hasApplicableRuntimeVariables(evidence, options.vars)) {
-    const unresolvedReason2 = contextualUnresolvedReason ?? row.unresolved_reason;
-    const withSections = withEffectiveResolution(enriched, row, unresolvedReason2);
-    return { row, evidence: withSections, unresolvedReason: unresolvedReason2 };
-  }
-  const resolution = resolveRuntimeOperation(db, enriched, workspaceId);
+  const appliedRuntimeValues = hasApplicableRuntimeVariables(evidence, options.vars);
+  const analyzed = analyzedRuntimeResolution(
+    row,
+    enriched,
+    analysis,
+    dynamicMode,
+    appliedRuntimeValues,
+    contextualState
+  );
+  if (analyzed) return analyzed;
+  if (!appliedRuntimeValues) {
+    const unresolvedReason = contextualReason(contextualState) ?? row.unresolved_reason;
+    const withSections = withEffectiveResolution(
+      enriched,
+      row,
+      unresolvedReason,
+      void 0,
+      contextualState
+    );
+    return { row, evidence: withSections, unresolvedReason };
+  }
+  return resolveSuppliedRuntimeOperation(db, row, enriched, workspaceId, contextualState);
+}
+function analyzedRuntimeResolution(row, evidence, analysis, dynamicMode, 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;
+  if (inferred && !isStructuralContextualBlocker(contextualState))
+    return resolvedRuntimeResolution(row, evidence, inferred, inferred.reasons);
+  if (analysis && analysis.missingVariables.length > 0 && appliedRuntimeValues) {
+    const unresolvedReason = dynamicMissingReason(analysis.missingVariables);
+    return {
+      row,
+      evidence: withEffectiveResolution(
+        evidence,
+        row,
+        unresolvedReason,
+        void 0,
+        contextualState
+      ),
+      unresolvedReason
+    };
+  }
+  return isStructuralContextualBlocker(contextualState) ? unchangedRuntimeResolution(row, evidence, contextualState) : void 0;
+}
+function resolveSuppliedRuntimeOperation(db, row, evidence, workspaceId, contextualState) {
+  const resolution = resolveRuntimeOperation(db, evidence, workspaceId);
   if (resolution.target)
     return resolvedRuntimeResolution(
       row,
-      enriched,
+      evidence,
       resolution.target,
       resolution.reasons
     );
-  if (analysis && analysis.viableCandidateCount === 0 && Object.keys(analysis.appliedSuppliedVariables).length > 0)
-    return noCandidateRuntimeResolution(row, enriched);
   const unresolvedReason = runtimeUnresolvedReason(resolution);
-  return { row, evidence: withEffectiveResolution(enriched, row, unresolvedReason, resolution), unresolvedReason };
+  return {
+    row,
+    evidence: withEffectiveResolution(
+      evidence,
+      row,
+      unresolvedReason,
+      resolution,
+      contextualState
+    ),
+    unresolvedReason
+  };
 }
-function unchangedRuntimeResolution(row, evidence, contextualUnresolvedReason) {
-  const unresolvedReason = contextualUnresolvedReason ?? row.unresolved_reason;
+function unchangedRuntimeResolution(row, evidence, contextualState) {
+  const unresolvedReason = contextualReason(contextualState) ?? row.unresolved_reason;
   return {
     row,
-    evidence: withEffectiveResolution(evidence, row, unresolvedReason),
+    evidence: withEffectiveResolution(
+      evidence,
+      row,
+      unresolvedReason,
+      void 0,
+      contextualState
+    ),
     unresolvedReason
   };
 }
-function noCandidateRuntimeResolution(row, evidence) {
+function noCandidateRuntimeResolution(row, evidence, contextualState) {
   const unresolvedReason = "No candidate remained after runtime substitution";
   return {
     row,
-    evidence: withEffectiveResolution(evidence, row, unresolvedReason),
+    evidence: withEffectiveResolution(
+      evidence,
+      row,
+      unresolvedReason,
+      void 0,
+      contextualState
+    ),
     unresolvedReason
   };
 }
@@ -5714,17 +6994,17 @@ function runtimeDiagnosticTotals(edges) {
     rejectedCandidateCount += numeric(exploration.rejectedCandidateCount);
     appendBounded(
       candidateSuggestions,
-      recordArray(edge.evidence.dynamicTargetCandidateSuggestions),
+      recordArray3(edge.evidence.dynamicTargetCandidateSuggestions),
       maxCandidates
     );
     appendBounded(
       rejectedCandidates,
-      recordArray(exploration.rejectedCandidates),
+      recordArray3(exploration.rejectedCandidates),
       maxCandidates
     );
     appendBounded(
       suggestedVarSets2,
-      recordArray(exploration.suggestedVarSets),
+      recordArray3(exploration.suggestedVarSets),
       maxCandidates
     );
   }
@@ -5771,27 +7051,27 @@ function runtimeNoCandidateDiagnostics(edges) {
       omittedRejectedCandidateCount: numeric(
         exploration.omittedRejectedCandidateCount
       ),
-      rejectedCandidates: recordArray(exploration.rejectedCandidates).slice(0, maxCandidates),
+      rejectedCandidates: recordArray3(exploration.rejectedCandidates).slice(0, maxCandidates),
       callSite
     }];
   });
 }
 function edgeTarget(row, evidence) {
   const effective = parseObject(evidence.effectiveResolution);
-  const targetServicePath = stringValue7(effective.targetServicePath ?? evidence.targetServicePath);
-  const targetOperationPath = stringValue7(effective.targetOperationPath ?? evidence.targetOperationPath);
+  const targetServicePath = stringValue10(effective.targetServicePath ?? evidence.targetServicePath);
+  const targetOperationPath = stringValue10(effective.targetOperationPath ?? evidence.targetOperationPath);
   if (targetServicePath && targetOperationPath) return `${targetServicePath}${targetOperationPath}`;
   const runtimeCandidate = evidence.runtimeResolvedCandidate;
   if (runtimeCandidate?.servicePath && runtimeCandidate.operationPath) return `${runtimeCandidate.servicePath}${runtimeCandidate.operationPath}`;
-  const servicePath = stringValue7(evidence.servicePath);
-  const operationPath = stringValue7(evidence.operationPath);
-  const targetOperation = stringValue7(evidence.targetOperation);
-  const targetRepo = stringValue7(evidence.targetRepo) ?? "";
+  const servicePath = stringValue10(evidence.servicePath);
+  const operationPath = stringValue10(evidence.operationPath);
+  const targetOperation = stringValue10(evidence.targetOperation);
+  const targetRepo = stringValue10(evidence.targetRepo) ?? "";
   if (row.edge_type === "HANDLER_RUNS_DB_QUERY") return `Entity: ${row.to_id || "unknown"}`;
-  if (row.edge_type === "HANDLER_RUNS_REMOTE_QUERY") return stringValue7(evidence.remoteQueryTarget) ?? `Remote query: ${row.to_id || "unknown"}`;
+  if (row.edge_type === "HANDLER_RUNS_REMOTE_QUERY") return stringValue10(evidence.remoteQueryTarget) ?? `Remote query: ${row.to_id || "unknown"}`;
   if (row.edge_type === "HANDLER_CALLS_EXTERNAL_HTTP") {
     const target = parseObject(evidence.externalTarget);
-    return stringValue7(target.label) ?? `External endpoint: ${row.to_id || "unknown"}`;
+    return stringValue10(target.label) ?? `External endpoint: ${row.to_id || "unknown"}`;
   }
   if (servicePath && operationPath) return `${servicePath}${operationPath}`;
   return targetOperation ? `${targetRepo}:${targetOperation}` : row.to_id;
@@ -5807,7 +7087,7 @@ function persistedResolution(row) {
     edgeType: row.edge_type
   };
 }
-function effectiveResolution(row, evidence, unresolvedReason, resolution) {
+function effectiveResolution(row, evidence, unresolvedReason, resolution, contextualState) {
   const target = resolution?.target;
   return {
     status: target ? "resolved" : row.status,
@@ -5820,22 +7100,42 @@ function effectiveResolution(row, evidence, unresolvedReason, resolution) {
     confidence: target?.score ?? row.confidence,
     reasons: resolution?.reasons ?? evidence.resolutionReasons,
     unresolvedReason,
-    edgeType: target ? "REMOTE_CALL_RESOLVES_TO_OPERATION" : row.edge_type
+    edgeType: target ? "REMOTE_CALL_RESOLVES_TO_OPERATION" : row.edge_type,
+    contextualBlocker: isStructuralContextualBlocker(contextualState) ? contextualState : void 0
   };
 }
-function withEffectiveResolution(evidence, row, unresolvedReason, resolution) {
-  const current = effectiveResolution(row, evidence, unresolvedReason, resolution);
+function withEffectiveResolution(evidence, row, unresolvedReason, resolution, contextualState) {
+  const current = effectiveResolution(
+    row,
+    evidence,
+    unresolvedReason,
+    resolution,
+    contextualState
+  );
   const rest = { ...evidence };
   delete rest.runtimeResolvedCandidate;
-  return { ...rest, effectiveResolution: current, linker: { status: current.status, confidence: current.confidence, reason: unresolvedReason, edgeType: current.edgeType } };
+  return {
+    ...rest,
+    effectiveResolution: current,
+    linker: {
+      status: current.status,
+      confidence: current.confidence,
+      reason: unresolvedReason,
+      edgeType: current.edgeType,
+      contextualBlocker: current.contextualBlocker
+    }
+  };
+}
+function contextualReason(state) {
+  return state?.category === "none" ? void 0 : state?.message;
 }
 function resolveRuntimeOperation(db, evidence, workspaceId) {
-  const servicePath = stringValue7(evidence.servicePath);
-  const rawOperationPath = stringValue7(evidence.operationPath);
+  const servicePath = stringValue10(evidence.servicePath);
+  const rawOperationPath = stringValue10(evidence.operationPath);
   const normalized = normalizeODataOperationInvocationPath(rawOperationPath);
-  const operationPath = normalized?.wasInvocation ? normalized.normalizedOperationPath : stringValue7(evidence.normalizedOperationPath) ?? rawOperationPath;
-  const alias = stringValue7(evidence.serviceAliasExpr ?? evidence.serviceAlias);
-  const destination = stringValue7(evidence.destination);
+  const operationPath = normalized?.wasInvocation ? normalized.normalizedOperationPath : stringValue10(evidence.normalizedOperationPath) ?? rawOperationPath;
+  const alias = stringValue10(evidence.serviceAliasExpr ?? evidence.serviceAlias);
+  const destination = stringValue10(evidence.destination);
   return resolveOperation(db, { servicePath, operationPath, alias, destination, hasExplicitOverride: true, isDynamic: true }, workspaceId);
 }
 function evidenceWithRuntimeVariables(evidence, vars) {
@@ -5855,16 +7155,23 @@ function evidenceWithRuntimeVariables(evidence, vars) {
   return next;
 }
 function evidenceWithDynamicAnalysis(evidence, analysis) {
-  const persistedCandidates = recordArray(evidence.candidates);
-  const persistedScores = recordArray(evidence.candidateScores);
+  const persistedCandidates = recordArray3(evidence.candidates);
+  const persistedScores = recordArray3(evidence.candidateScores);
+  const persistedCandidateCount = numeric(evidence.persistedCandidateCount) || numeric(evidence.candidateCount) || persistedCandidates.length;
+  const persistedScoreCount = numeric(evidence.candidateScoreCount) || persistedScores.length;
   return {
     ...evidence,
     candidates: persistedCandidates.slice(0, analysis.maxCandidates),
     candidateScores: persistedScores.slice(0, analysis.maxCandidates),
-    persistedCandidateCount: persistedCandidates.length,
+    persistedCandidateCount,
     persistedCandidateOmittedCount: Math.max(
       0,
-      persistedCandidates.length - analysis.maxCandidates
+      persistedCandidateCount - Math.min(persistedCandidates.length, analysis.maxCandidates)
+    ),
+    persistedCandidateScoreCount: persistedScoreCount,
+    persistedCandidateScoreOmittedCount: Math.max(
+      0,
+      persistedScoreCount - Math.min(persistedScores.length, analysis.maxCandidates)
     ),
     dynamicTargetExploration: {
       mode: analysis.mode,
@@ -5882,10 +7189,17 @@ function evidenceWithDynamicAnalysis(evidence, analysis) {
       shownRejectedCandidateCount: analysis.shownRejectedCandidateCount,
       omittedRejectedCandidateCount: analysis.omittedRejectedCandidateCount,
       rejectedCandidates: analysis.rejectedCandidates,
-      suggestedVarSets: analysis.suggestedVarSets
+      suggestedVarSets: analysis.suggestedVarSets,
+      suggestedVarSetCount: analysis.suggestedVarSetCount,
+      shownSuggestedVarSetCount: analysis.shownSuggestedVarSetCount,
+      omittedSuggestedVarSetCount: analysis.omittedSuggestedVarSetCount,
+      routingContext: analysis.routingContext
     },
     dynamicTargetCandidates: analysis.candidates,
     dynamicTargetCandidateSuggestions: analysis.shownCandidates,
+    dynamicTargetCandidateSuggestionCount: analysis.viableCandidateCount,
+    shownDynamicTargetCandidateSuggestionCount: analysis.shownCandidateCount,
+    omittedDynamicTargetCandidateSuggestionCount: analysis.omittedCandidateCount,
     rejectedCandidates: analysis.rejectedCandidates,
     dynamicTargetInference: analysis.inference
   };
@@ -5900,10 +7214,11 @@ var boundedDynamicListKeys = /* @__PURE__ */ new Set([
   "rejectedCandidates",
   "rejectedCandidateSuggestions",
   "copyableExamples",
-  "conflicts"
+  "conflicts",
+  "bindingAlternatives"
 ]);
 function boundDynamicEvidence(evidence, limit) {
-  const candidateCount = numeric(evidence.persistedCandidateCount) || (Array.isArray(evidence.candidates) ? evidence.candidates.length : 0);
+  const candidateCount = numeric(evidence.persistedCandidateCount) || numeric(evidence.candidateCount) || (Array.isArray(evidence.candidates) ? evidence.candidates.length : 0);
   const projected = boundDynamicValue(evidence, limit);
   const next = parseObject(projected);
   if (candidateCount === 0) return next;
@@ -5935,7 +7250,7 @@ function runtimeSubstitutions(evidence, vars) {
   return substitutions;
 }
 function substitutionValue(evidence, key) {
-  const value = stringValue7(evidence[key]);
+  const value = stringValue10(evidence[key]);
   if (key !== "operationPath") return value;
   const normalized = normalizeODataOperationInvocationPath(value);
   return normalized?.wasInvocation ? normalized.normalizedOperationPath : value;
@@ -5984,13 +7299,13 @@ function runtimeUnresolvedReason(resolution) {
 function parseObject(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
-function stringValue7(value) {
+function stringValue10(value) {
   return typeof value === "string" ? value : void 0;
 }
 function numeric(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : 0;
 }
-function recordArray(value) {
+function recordArray3(value) {
   return Array.isArray(value) ? value.filter((item) => Boolean(item && typeof item === "object" && !Array.isArray(item))) : [];
 }
 function appendBounded(target, values, limit) {
@@ -6017,8 +7332,8 @@ function positiveCandidateCap(value) {
 
 // src/trace/dynamic-branches.ts
 function dynamicCandidateBranches(depth, call, evidence) {
-  const exploration = objectRecord(evidence.dynamicTargetExploration);
-  return recordArray2(evidence.dynamicTargetCandidateSuggestions).map((candidate) => ({
+  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}`,
@@ -6028,19 +7343,19 @@ function dynamicCandidateBranches(depth, call, evidence) {
       exploratory: true,
       dynamicMode: String(exploration.mode ?? "candidates"),
       selected: false,
-      omittedCandidateCount: numericValue2(exploration.omittedCandidateCount)
+      omittedCandidateCount: numericValue4(exploration.omittedCandidateCount)
     },
-    confidence: numericValue2(candidate.score),
+    confidence: numericValue4(candidate.score),
     unresolvedReason: "Exploratory dynamic target candidate; provide runtime variables to select it"
   }));
 }
-function objectRecord(value) {
+function objectRecord2(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
-function recordArray2(value) {
+function recordArray4(value) {
   return Array.isArray(value) ? value.filter((item) => Boolean(item && typeof item === "object" && !Array.isArray(item))) : [];
 }
-function numericValue2(value) {
+function numericValue4(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : 0;
 }
 
@@ -6067,16 +7382,300 @@ function prependTraceDiagnostic(diagnostics, diagnostic) {
 }
 function sameDiagnosticLocation(left, right) {
   if (left.code !== right.code) return false;
-  const leftFile = stringValue8(left.sourceFile);
-  const rightFile = stringValue8(right.sourceFile);
+  const leftFile = stringValue11(left.sourceFile);
+  const rightFile = stringValue11(right.sourceFile);
   if (leftFile || rightFile)
-    return leftFile === rightFile && numericValue3(left.sourceLine) === numericValue3(right.sourceLine);
+    return leftFile === rightFile && numericValue5(left.sourceLine) === numericValue5(right.sourceLine);
   return String(left.message ?? "") === String(right.message ?? "");
 }
-function stringValue8(value) {
+function stringValue11(value) {
   return typeof value === "string" ? value : void 0;
 }
-function numericValue3(value) {
+function numericValue5(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+
+// src/trace/005-implementation-selection.ts
+function hintedImplementationSelection(db, edge, operationId, options) {
+  if (!edge || edge.status !== "ambiguous")
+    return { blocksAutomatic: false, evidence: { status: "not_applicable" } };
+  return selectImplementation(
+    parsedEvidence(edge.evidence_json),
+    options.implementationHints,
+    options.implementationRepo,
+    canonicalImplementationEvidence(db, operationId)
+  );
+}
+function contextualImplementationSelection(db, edge, operationId, callerRepoId, remoteEvidence, options) {
+  const hinted = hintedImplementationSelection(db, edge, operationId, options);
+  if (hinted.methodId || hinted.blocksAutomatic || !edge || edge.status !== "ambiguous" || callerRepoId === void 0) return hinted;
+  const candidates2 = implementationCandidates2(
+    canonicalImplementationEvidence(db, operationId) ?? parsedEvidence(edge.evidence_json)
+  );
+  const scores = candidates2.filter((candidate) => candidate.accepted).map((candidate) => contextualScore(candidate, callerRepoId, remoteEvidence)).sort(compareScore);
+  if (scores.length === 0)
+    return { blocksAutomatic: false, evidence: { status: "not_applicable", candidateScores: [] } };
+  const [first, second] = scores;
+  if (first?.methodId !== void 0 && first.score > 0 && (!second || first.score > second.score))
+    return selectedContext(first, scores);
+  return tiedContext(hinted, scores);
+}
+function selectedContext(first, scores) {
+  const projection = projectBounded(scores, compareScore);
+  return {
+    methodId: String(first.methodId),
+    blocksAutomatic: false,
+    evidence: {
+      status: "selected",
+      selectedMethodId: first.methodId,
+      candidateScores: projection.items,
+      candidateScoreCount: projection.totalCount,
+      shownCandidateScoreCount: projection.shownCount,
+      omittedCandidateScoreCount: projection.omittedCount
+    }
+  };
+}
+function tiedContext(hinted, scores) {
+  if (hinted.evidence.reason === "no_scoped_hint_matched_edge") return hinted;
+  const projection = projectBounded(scores, compareScore);
+  return {
+    blocksAutomatic: false,
+    evidence: {
+      status: "tied",
+      tieReason: scores.length > 1 ? "duplicate_helper_implementation_candidates" : "no_unique_materially_stronger_candidate",
+      candidateScores: projection.items,
+      candidateScoreCount: projection.totalCount,
+      shownCandidateScoreCount: projection.shownCount,
+      omittedCandidateScoreCount: projection.omittedCount
+    }
+  };
+}
+function implementationCandidates2(evidence) {
+  const rows2 = Array.isArray(evidence.candidates) ? evidence.candidates : [];
+  return rows2.flatMap((value) => {
+    const row = record4(value);
+    return Object.keys(row).length === 0 ? [] : [{
+      accepted: row.accepted === true,
+      methodId: numberValue8(row.methodId),
+      score: numberValue8(row.score) ?? 0,
+      handlerPackage: record4(row.handlerPackage),
+      applicationPackage: record4(row.applicationPackage)
+    }];
+  });
+}
+function contextualScore(candidate, callerRepoId, remoteEvidence) {
+  const reasons = [];
+  let score = candidate.score;
+  if (numberValue8(candidate.handlerPackage.id) === callerRepoId) {
+    score += 10;
+    reasons.push("handler_package_matches_caller_repository");
+  }
+  if (numberValue8(candidate.applicationPackage.id) === callerRepoId) {
+    score += 10;
+    reasons.push("registration_package_matches_caller_repository");
+  }
+  if (hasRemoteContext(remoteEvidence)) {
+    score += 1;
+    reasons.push("remote_call_context_available");
+  }
+  return {
+    methodId: candidate.methodId,
+    score,
+    reasons,
+    handlerPackage: candidate.handlerPackage,
+    applicationPackage: candidate.applicationPackage
+  };
+}
+function hasRemoteContext(evidence) {
+  return typeof evidence.effectiveServicePath === "string" || typeof evidence.effectiveDestination === "string" || typeof evidence.effectiveAlias === "string";
+}
+function compareScore(left, right) {
+  return right.score - left.score || Number(left.methodId ?? 0) - Number(right.methodId ?? 0);
+}
+function parsedEvidence(value) {
+  try {
+    return record4(JSON.parse(String(value ?? "{}")));
+  } catch {
+    return {};
+  }
+}
+function record4(value) {
+  return isRecord6(value) ? value : {};
+}
+function isRecord6(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function numberValue8(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+
+// src/trace/007-implementation-start-diagnostic.ts
+function implementationStartDiagnostic(edge, evidence) {
+  return {
+    severity: "warning",
+    code: edge.status === "ambiguous" ? "trace_start_ambiguous" : "trace_start_implementation_unresolved",
+    message: `Indexed operation matched but implementation edge is ${String(
+      edge.status ?? "unresolved"
+    )}`,
+    resolutionStage: "implementation",
+    resolutionStatus: edge.status === "ambiguous" ? "ambiguous_implementation" : "rejected_implementation",
+    implementationEdgeId: edge.id,
+    implementationStatus: edge.status,
+    implementationAmbiguityReasons: evidence.ambiguityReasons,
+    implementationRejectionReasons: implementationRejectionReasons(evidence),
+    implementationHintSuggestions: evidence.implementationHintSuggestions,
+    implementationHintSuggestionCount: evidence.implementationHintSuggestionCount,
+    shownImplementationHintSuggestionCount: evidence.shownImplementationHintSuggestionCount,
+    omittedImplementationHintSuggestionCount: evidence.omittedImplementationHintSuggestionCount,
+    candidates: evidence.candidates,
+    candidateCount: evidence.candidateCount,
+    shownCandidateCount: evidence.shownCandidateCount,
+    omittedCandidateCount: evidence.omittedCandidateCount
+  };
+}
+function implementationRejectionReasons(evidence) {
+  const candidates2 = recordArray5(evidence.candidates);
+  const reasons = candidates2.flatMap((candidate) => stringArray5(candidate.rejectedReasons));
+  return [...new Set(reasons)].sort();
+}
+function recordArray5(value) {
+  return Array.isArray(value) ? value.filter(isRecord7) : [];
+}
+function stringArray5(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function isRecord7(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+// src/trace/009-selected-handler-provenance.ts
+function handlerMethodNode(db, methodId) {
+  const row = db.prepare(`SELECT hm.id methodId,hm.method_name methodName,
+    hm.source_line sourceLine,hc.class_name className,hc.source_file sourceFile,
+    r.name repoName,r.id repoId,r.package_name packageName
+    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(methodId);
+  return handlerNodeFromRow(row);
+}
+function withSelectedHandlerProvenance(evidence, targetId, handler) {
+  if (!handler) return unavailableHandlerEvidence(evidence, targetId);
+  const selected = selectedHandlerProvenance(handlerSource(handler));
+  const stored = record5(evidence.selectedHandler);
+  const mismatchedFields = storedSelectedHandlerMismatches(
+    stored,
+    selected,
+    targetId
+  );
+  if (mismatchedFields.length === 0)
+    return { handler, evidence: { ...evidence, selectedHandler: selected } };
+  return {
+    handler,
+    evidence: {
+      ...evidence,
+      selectedHandler: selected,
+      selectedHandlerProvenanceAudit: {
+        status: "mismatch",
+        graphTargetId: targetId,
+        mismatchedFields,
+        persistedSelectedHandler: stored
+      }
+    },
+    diagnostic: {
+      severity: "warning",
+      code: "selected_handler_provenance_mismatch",
+      message: "Persisted selected handler provenance did not match the resolved graph target",
+      graphTargetId: targetId,
+      mismatchedFields,
+      sourceFile: handler.sourceFile,
+      sourceLine: handler.sourceLine
+    }
+  };
+}
+function unavailableHandlerEvidence(evidence, targetId) {
+  return {
+    evidence: {
+      ...evidence,
+      selectedHandlerProvenanceAudit: {
+        status: "unavailable",
+        graphTargetId: targetId,
+        reason: "handler_target_not_indexed"
+      }
+    },
+    diagnostic: {
+      severity: "warning",
+      code: "selected_handler_target_not_found",
+      message: "Resolved implementation target is not an indexed handler method",
+      graphTargetId: targetId
+    },
+    unresolvedReason: "Resolved implementation target is not an indexed handler method"
+  };
+}
+function handlerNodeFromRow(row) {
+  const methodId = numberValue9(row?.methodId);
+  const methodName2 = stringValue12(row?.methodName);
+  const className = stringValue12(row?.className);
+  const sourceFile = stringValue12(row?.sourceFile);
+  const sourceLine2 = numberValue9(row?.sourceLine);
+  const repoId = numberValue9(row?.repoId);
+  const repoName = stringValue12(row?.repoName);
+  if (methodId === void 0 || !methodName2 || !className || !sourceFile || sourceLine2 === void 0 || repoId === void 0 || !repoName)
+    return void 0;
+  return {
+    id: `handler_method:${methodId}`,
+    kind: "handler_method",
+    label: `${repoName}:${className}.${methodName2}`,
+    methodId,
+    methodName: methodName2,
+    className,
+    sourceFile,
+    sourceLine: sourceLine2,
+    repoId,
+    repoName,
+    packageName: stringValue12(row?.packageName)
+  };
+}
+function handlerSource(node) {
+  return {
+    methodId: node.methodId,
+    methodName: node.methodName,
+    className: node.className,
+    repositoryId: node.repoId,
+    repositoryName: node.repoName,
+    repositoryPackageName: node.packageName,
+    sourceFile: node.sourceFile,
+    sourceLine: node.sourceLine
+  };
+}
+function storedSelectedHandlerMismatches(stored, selected, targetId) {
+  if (Object.keys(stored).length === 0) return [];
+  const expectedRepository = record5(stored.repository);
+  const selectedRepository = selected.repository ?? {};
+  return [
+    mismatch("graphTargetId", stored.graphTargetId, targetId),
+    mismatch("methodId", stored.methodId, selected.methodId),
+    mismatch("className", stored.className, selected.className),
+    mismatch("methodName", stored.methodName, selected.methodName),
+    mismatch("sourceFile", stored.sourceFile, selected.sourceFile),
+    mismatch("sourceLine", stored.sourceLine, selected.sourceLine),
+    mismatch("repository.id", expectedRepository.id, selectedRepository.id),
+    mismatch("repository.name", expectedRepository.name, selectedRepository.name),
+    mismatch(
+      "repository.packageName",
+      expectedRepository.packageName,
+      selectedRepository.packageName
+    )
+  ].flatMap((field) => field ? [field] : []);
+}
+function mismatch(field, stored, actual) {
+  return stored === void 0 || stored === actual ? void 0 : field;
+}
+function record5(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function stringValue12(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function numberValue9(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
 
@@ -6108,24 +7707,24 @@ function operationStartScope(db, repoId, start, hintOptions, workspaceId) {
   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 = implementationMethodIdFromHint(impl.edge, hintOptions);
+  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 = parseEvidence(impl.edge.evidence_json);
-    const hintDiagnostic = implementationHintDiagnostic(hinted, evidence.implementationHintSuggestions);
-    const diagnostics = [{ severity: "warning", code: impl.edge.status === "ambiguous" ? "trace_start_ambiguous" : "trace_start_implementation_unresolved", message: `Indexed operation matched but implementation edge is ${String(impl.edge.status ?? "unresolved")}`, resolutionStage: "implementation", resolutionStatus: impl.edge.status === "ambiguous" ? "ambiguous_implementation" : "rejected_implementation", implementationEdgeId: impl.edge.id, implementationStatus: impl.edge.status, implementationAmbiguityReasons: evidence.ambiguityReasons, implementationRejectionReasons: implementationRejectionReasons(evidence), implementationHintSuggestions: evidence.implementationHintSuggestions, candidates: evidence.candidates }];
+    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 implementationRejectionReasons(evidence) {
-  const candidates = Array.isArray(evidence.candidates) ? evidence.candidates.filter((item) => Boolean(item && typeof item === "object" && !Array.isArray(item))) : [];
-  const reasons = candidates.flatMap((candidate) => Array.isArray(candidate.rejectedReasons) ? candidate.rejectedReasons.filter((reason) => typeof reason === "string") : []);
-  return [...new Set(reasons)].sort();
-}
 function sourceFilesForStart(db, repoId, start, workspaceId) {
   return sourceScopeForSelector(db, repoId, start, workspaceId);
 }
@@ -6199,11 +7798,6 @@ function handlerFilesForOperation(db, operationId) {
 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 handlerMethodNode(db, methodId) {
-  const row = db.prepare(`SELECT hm.id methodId,hm.method_name methodName,hm.decorator_value decoratorValue,hm.source_line sourceLine,hc.class_name className,hc.source_file sourceFile,r.name repoName,r.id repoId 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(methodId);
-  if (!row) return void 0;
-  return { id: `handler_method:${methodId}`, kind: "handler_method", label: `${String(row.repoName)}:${String(row.className)}.${String(row.methodName)}`, ...row };
-}
 function implementationScope(db, operationId) {
   const edge = implementationEdge(db, operationId);
   if (!edge || edge.status !== "resolved") return { files: /* @__PURE__ */ new Set(), edge };
@@ -6212,38 +7806,6 @@ function implementationScope(db, operationId) {
     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 implementationMethodIdFromHint(edge, options) {
-  if (!edge || edge.status !== "ambiguous") return { blocksAutomatic: false, evidence: { status: "not_applicable" } };
-  return selectImplementation(parseEvidence(edge.evidence_json), options.implementationHints, options.implementationRepo);
-}
-function contextImplementationMethodId(edge, callerRepoId, remoteEvidence, hintOptions) {
-  const hinted = implementationMethodIdFromHint(edge, hintOptions);
-  if (hinted.methodId) return hinted;
-  if (hinted.blocksAutomatic) return hinted;
-  if (!edge || edge.status !== "ambiguous" || callerRepoId === void 0) return hinted;
-  const evidence = JSON.parse(String(edge.evidence_json || "{}"));
-  const scores = (evidence.candidates ?? []).filter((item) => item.accepted).map((item) => {
-    const reasons = [];
-    let score = Number(item.score ?? 0);
-    if (Number(item.handlerPackage?.id) === callerRepoId) {
-      score += 10;
-      reasons.push("handler_package_matches_caller_repository");
-    }
-    if (Number(item.applicationPackage?.id) === callerRepoId) {
-      score += 10;
-      reasons.push("registration_package_matches_caller_repository");
-    }
-    if (typeof remoteEvidence.effectiveServicePath === "string" || typeof remoteEvidence.effectiveDestination === "string" || typeof remoteEvidence.effectiveAlias === "string") {
-      score += 1;
-      reasons.push("remote_call_context_available");
-    }
-    return { methodId: item.methodId, score, reasons, handlerPackage: item.handlerPackage, applicationPackage: item.applicationPackage };
-  }).sort((a, b) => b.score - a.score);
-  if (scores.length === 0) return { blocksAutomatic: false, evidence: { status: "not_applicable", candidateScores: [] } };
-  const [first, second] = scores;
-  if (first && first.methodId !== void 0 && first.score > 0 && (!second || first.score > second.score)) return { methodId: String(first.methodId), blocksAutomatic: false, evidence: { status: "selected", selectedMethodId: first.methodId, candidateScores: scores } };
-  return { blocksAutomatic: false, evidence: hinted.evidence.reason === "no_scoped_hint_matched_edge" ? hinted.evidence : { status: "tied", tieReason: scores.length > 1 ? "duplicate_helper_implementation_candidates" : "no_unique_materially_stronger_candidate", candidateScores: scores } };
-}
 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;
@@ -6289,11 +7851,14 @@ function workspaceIdForCall(db, callId) {
 function parseEvidence(value) {
   try {
     const parsed = JSON.parse(String(value || "{}"));
-    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+    return isEvidenceRecord2(parsed) ? boundCandidateLikeEvidence(parsed) : {};
   } catch {
     return {};
   }
 }
+function isEvidenceRecord2(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
 function receiverFromEvidence(value) {
   const evidence = parseEvidence(value);
   return typeof evidence.receiver === "string" ? evidence.receiver : void 0;
@@ -6341,7 +7906,7 @@ function knownBindingsForScope(db, repoId, symbolIds, files) {
       map.set(row.variableName, candidate);
       continue;
     }
-    const candidates = uniqueBindingCandidates([
+    const candidates2 = uniqueBindingCandidates([
       ...existing.bindingCandidates ?? [bindingCandidateEvidence(existing)],
       bindingCandidateEvidence(candidate)
     ]);
@@ -6350,7 +7915,7 @@ function knownBindingsForScope(db, repoId, symbolIds, files) {
       bindingId: void 0,
       source: "ambiguous_local_service_bindings",
       resolutionStatus: "ambiguous",
-      bindingCandidates: candidates
+      bindingCandidates: candidates2
     });
   }
   return map;
@@ -6366,9 +7931,9 @@ function bindingCandidateEvidence(binding) {
     servicePathExpr: binding.servicePathExpr
   };
 }
-function uniqueBindingCandidates(candidates) {
+function uniqueBindingCandidates(candidates2) {
   const seen = /* @__PURE__ */ new Set();
-  return candidates.filter((candidate) => {
+  return candidates2.filter((candidate) => {
     const key = JSON.stringify(candidate);
     if (seen.has(key)) return false;
     seen.add(key);
@@ -6378,13 +7943,13 @@ function uniqueBindingCandidates(candidates) {
 function contextForSymbolCall(db, symbolCall, callerBindings) {
   const next = /* @__PURE__ */ new Map();
   if (callerBindings.size === 0) return next;
-  const callEvidence2 = parseEvidence(symbolCall.evidence_json);
+  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(callEvidence2.callArguments) ? callEvidence2.callArguments : [];
+  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 }
@@ -6422,35 +7987,6 @@ function contextForSymbolCall(db, symbolCall, callerBindings) {
   });
   return next;
 }
-function contextualRuntimeResolution(db, call, binding, workspaceId, persistedRows = []) {
-  if (!binding || String(call.call_type) !== "remote_action" || call.operation_path_expr === void 0 || call.operation_path_expr === null) return {};
-  if (binding.resolutionStatus === "ambiguous") {
-    return {
-      evidence: {
-        contextualServiceBindingAttempted: true,
-        contextualBinding: {
-          source: binding.source,
-          status: "tied",
-          candidates: binding.bindingCandidates
-        },
-        contextualResolutionStatus: "ambiguous",
-        contextualCandidateCount: binding.bindingCandidates?.length ?? 0
-      },
-      unresolvedReason: "Ambiguous contextual service binding candidates"
-    };
-  }
-  const normalized = normalizeODataOperationInvocationPath(String(call.operation_path_expr));
-  const op = normalized?.normalizedOperationPath ?? (String(call.operation_path_expr).startsWith("/") ? String(call.operation_path_expr) : `/${String(call.operation_path_expr)}`);
-  const servicePath = binding.effectiveServicePath ?? binding.servicePathExpr ?? binding.requireServicePath;
-  const destination = binding.effectiveDestination ?? binding.destinationExpr ?? binding.requireDestination;
-  const resolution = resolveOperation(db, { servicePath, operationPath: op, alias: binding.aliasExpr ?? binding.alias, destination, hasExplicitOverride: true, isDynamic: false }, workspaceId);
-  const evidence = { contextualServiceBindingAttempted: true, contextualBinding: { source: binding.source, callerArgument: binding.callerArgument, callerProperty: binding.callerProperty, calleeParameter: binding.calleeParameter, calleeReceiver: binding.calleeReceiver, callerSite: binding.callerSite, calleeSite: binding.calleeSite, bindingSourceFile: binding.sourceFile, bindingSourceLine: binding.sourceLine, alias: binding.alias, aliasExpr: binding.aliasExpr, requireServicePath: binding.requireServicePath, requireDestination: binding.requireDestination, effectiveServicePath: binding.effectiveServicePath, effectiveDestination: binding.effectiveDestination }, operationPath: op, rawOperationPath: normalized?.rawOperationPath, normalizedOperationPath: normalized?.wasInvocation ? normalized.normalizedOperationPath : void 0, invocationArgumentPlaceholderKeys: normalized?.invocationArgumentPlaceholderKeys.length ? normalized.invocationArgumentPlaceholderKeys : void 0, servicePath, serviceAlias: binding.alias, serviceAliasExpr: binding.aliasExpr, destination, requireServicePath: binding.requireServicePath, requireDestination: binding.requireDestination, effectiveServicePath: binding.effectiveServicePath, effectiveDestination: binding.effectiveDestination, contextualResolutionStatus: resolution.status, contextualCandidateCount: resolution.candidates.length, candidates: resolution.candidates, contextualResolutionReasons: resolution.reasons, resolutionReasons: resolution.reasons };
-  if (!resolution.target) return { evidence, unresolvedReason: resolution.status === "ambiguous" ? "Ambiguous contextual operation candidates" : resolution.status === "dynamic" ? `Dynamic contextual target is missing runtime variables: ${resolution.reasons.join(", ")}` : "No contextual operation candidate matched" };
-  const resolvedEvidence = { ...evidence, contextualServiceBindingSelected: true, targetRepo: resolution.target.repoName, targetServicePath: resolution.target.servicePath, targetOperationPath: resolution.target.operationPath, targetOperation: resolution.target.operationName };
-  const persistedResolved = persistedRows.find((item) => item.status === "resolved");
-  if (persistedResolved) return { row: void 0, evidence: { ...resolvedEvidence, contextualPreservedPersistedResolvedEdge: true }, unresolvedReason: void 0 };
-  return { row: { id: -Number(call.id), edge_type: "REMOTE_CALL_RESOLVES_TO_OPERATION", from_id: String(call.id), to_kind: "operation", to_id: String(resolution.target.operationId), confidence: resolution.target.score, evidence_json: JSON.stringify(resolvedEvidence), status: "resolved" }, evidence: resolvedEvidence, unresolvedReason: void 0 };
-}
 function trace(db, start, options) {
   const hintOptions = { implementationRepo: options.implementationRepo, implementationHints: options.implementationHints };
   const scope = startScope(db, start, hintOptions, options.workspaceId);
@@ -6478,14 +8014,34 @@ function trace(db, start, options) {
     const op = operationNode(db, scope.startOperationId);
     const impl = implementationScope(db, scope.startOperationId);
     if (op) nodes.set(String(op.id), op);
-    const startSelection = implementationMethodIdFromHint(impl.edge, hintOptions);
+    const startSelection = hintedImplementationSelection(
+      db,
+      impl.edge,
+      scope.startOperationId,
+      hintOptions
+    );
     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), startResolution: { strategy: "indexed_operation_graph", matchedOperationId: scope.startOperationId, implementationEdgeId: impl.edge.id, implementationStatus: impl.edge.status, selectedHandlerMethodId: selectedMethodId }, implementationSelection: startSelection.methodId ? startSelection.evidence : void 0 };
-      const handlerNode = selectedMethodId ? handlerMethodNode(db, selectedMethodId) : void 0;
-      if (handlerNode) nodes.set(String(handlerNode.id), handlerNode);
+      const implEvidence = {
+        ...parseEvidence(impl.edge.evidence_json),
+        startResolution: {
+          strategy: "indexed_operation_graph",
+          matchedOperationId: scope.startOperationId,
+          implementationEdgeId: impl.edge.id,
+          implementationStatus: impl.edge.status,
+          selectedHandlerMethodId: selectedMethodId
+        },
+        implementationSelection: startSelection.methodId ? startSelection.evidence : void 0
+      };
+      const selected = selectedMethodId ? withSelectedHandlerProvenance(
+        implEvidence,
+        selectedMethodId,
+        handlerMethodNode(db, selectedMethodId)
+      ) : { 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: handlerNode?.label ? String(handlerNode.label) : `${impl.edge.to_kind}:${impl.edge.to_id}`, evidence: implEvidence, confidence: Number(impl.edge.confidence ?? 0), unresolvedReason: impl.edge.status === "resolved" || startSelection.methodId ? void 0 : String(impl.edge.unresolved_reason ?? impl.edge.status) });
+      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 seenScopes = /* @__PURE__ */ new Set();
@@ -6513,7 +8069,7 @@ function trace(db, start, options) {
         const nextKey = `${nextRepoId}:${[...nextSymbols].join(",")}:${[...nextFiles].join(",")}`;
         const calleeNode = symbolNode(db, Number(symbolCall.callee_symbol_id));
         if (calleeNode) nodes.set(String(calleeNode.id), calleeNode);
-        const evidence = { ...JSON.parse(String(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 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) });
@@ -6539,15 +8095,13 @@ function trace(db, start, options) {
       for (const row of graphRows) {
         if (seenEdges.has(Number(row.id))) continue;
         seenEdges.add(Number(row.id));
-        const persistedEvidence = JSON.parse(
-          String(row.evidence_json || "{}")
-        );
+        const persistedEvidence = parseEvidence(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.unresolvedReason);
+        }, workspaceIdForCall(db, String(call.id)), contextual.state);
         const evidence = effective.evidence;
         const effectiveRow = effective.row;
         const targetNode = `${effectiveRow.to_kind}:${effectiveRow.to_id}`;
@@ -6567,35 +8121,59 @@ function trace(db, start, options) {
           confidence: Number(effectiveRow.confidence ?? call.confidence),
           unresolvedReason: effective.unresolvedReason
         });
-        if ((options.dynamicMode ?? "strict") === "candidates")
+        if ((options.dynamicMode ?? "strict") === "candidates" && effectiveRow.status !== "resolved")
           edges.push(...dynamicCandidateBranches(current.depth, call, evidence));
         if (effectiveRow.to_kind === "operation") {
           const implementation = implementationScope(db, effectiveRow.to_id);
-          const contextSelection = contextImplementationMethodId(implementation.edge, current.repoId, evidence, hintOptions);
+          const contextSelection = contextualImplementationSelection(
+            db,
+            implementation.edge,
+            effectiveRow.to_id,
+            current.repoId,
+            evidence,
+            hintOptions
+          );
           const contextMethodId = contextSelection.methodId;
-          const contextNode = contextMethodId ? handlerMethodNode(db, contextMethodId) : void 0;
+          let selectedHandlerAvailable = true;
           if (implementation.edge) {
-            const implEvidence = JSON.parse(String(implementation.edge.evidence_json || "{}"));
-            const hintDiagnostic = implementationHintDiagnostic(contextSelection, implEvidence.implementationHintSuggestions);
+            const implEvidence = parseEvidence(implementation.edge.evidence_json);
+            const hintDiagnostic = implementationHintDiagnostic(contextSelection, implEvidence);
             if (hintDiagnostic) prependTraceDiagnostic(diagnostics, hintDiagnostic);
-            const handlerNode = implementation.edge.status === "resolved" ? handlerMethodNode(db, implementation.edge.to_id) : contextNode;
-            const implTo = handlerNode?.label ? String(handlerNode.label) : `${implementation.edge.to_kind}:${implementation.edge.to_id}`;
-            if (handlerNode) nodes.set(String(handlerNode.id), handlerNode);
+            const selectedMethodId = implementation.edge.status === "resolved" ? implementation.edge.to_id : contextMethodId;
+            const selectionEvidence = contextMethodId ? {
+              ...implEvidence,
+              contextualImplementationSelected: contextSelection.evidence.strategy !== "implementation_repo_hint",
+              contextualImplementation: contextSelection.evidence,
+              implementationSelection: contextSelection.evidence
+            } : {
+              ...implEvidence,
+              contextualImplementation: contextSelection.evidence,
+              implementationSelection: contextSelection.evidence
+            };
+            const selected = selectedMethodId ? withSelectedHandlerProvenance(
+              selectionEvidence,
+              selectedMethodId,
+              handlerMethodNode(db, selectedMethodId)
+            ) : { evidence: selectionEvidence };
+            selectedHandlerAvailable = !selected.unresolvedReason;
+            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({
               step: current.depth,
               type: "operation_implemented_by_handler",
               from: to,
               to: implTo,
-              evidence: contextMethodId ? { ...implEvidence, contextualImplementationSelected: contextSelection.evidence.strategy !== "implementation_repo_hint", contextualImplementation: contextSelection.evidence, implementationSelection: contextSelection.evidence } : { ...implEvidence, contextualImplementation: contextSelection.evidence, implementationSelection: contextSelection.evidence },
+              evidence: selected.evidence,
               confidence: Number(implementation.edge.confidence ?? 0),
-              unresolvedReason: implementation.edge.status === "resolved" || contextMethodId ? void 0 : String(implementation.edge.unresolved_reason ?? implementation.edge.status)
+              unresolvedReason: selected.unresolvedReason ?? (implementation.edge.status === "resolved" || contextMethodId ? void 0 : String(implementation.edge.unresolved_reason ?? implementation.edge.status))
             });
           }
           if (current.depth >= maxDepth) continue;
           const contextScope = contextMethodId ? handlerScope(db, contextMethodId) : void 0;
           const files = contextScope?.files ?? (implementation.files.size > 0 ? implementation.files : handlerFilesForOperation(db, effectiveRow.to_id));
           const symbolIds = contextScope?.symbolId ? /* @__PURE__ */ new Set([contextScope.symbolId]) : implementation.symbolId ? /* @__PURE__ */ new Set([implementation.symbolId]) : void 0;
-          if ((implementation.edge?.status === "resolved" || contextScope) && files.size > 0) {
+          if (selectedHandlerAvailable && (implementation.edge?.status === "resolved" || contextScope) && files.size > 0) {
             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;
@@ -6630,6 +8208,7 @@ function trace(db, start, options) {
 }
 
 export {
+  projectBoundedInOrder,
   upsertWorkspace,
   getWorkspace,
   upsertRepository,
@@ -6671,4 +8250,4 @@ export {
   selectorRepoAmbiguousDiagnostic,
   trace
 };
-//# sourceMappingURL=chunk-PTLDSHRC.js.map
+//# sourceMappingURL=chunk-ERIZHM5C.js.map