@saptools/service-flow 0.1.53 → 0.1.55

package/dist/{chunk-LFH7C46B.js → chunk-GXYVIHJ5.js}

@@ -13,6 +13,16 @@ function projectBounded(values, compare, limit = DEFAULT_EVIDENCE_CANDIDATE_LIMI
     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;
 }
@@ -51,7 +61,7 @@ function boundCandidateLikeEvidence(evidence, limit = DEFAULT_EVIDENCE_CANDIDATE
       output[key] = boundNestedEvidence(value, limit);
       continue;
     }
-    const projection = projectBounded(value, compareEvidenceValue, limit);
+    const projection = projectBoundedInOrder(value, limit);
     output[key] = projection.items.map((item) => boundNestedEvidence(item, limit));
     addCollectionCounts(output, evidence, key, projection);
   }
@@ -106,17 +116,6 @@ function collectionStem(key) {
   };
   return stems[key] ?? "candidate";
 }
-function compareEvidenceValue(left, right) {
-  return stableProjectionValue(left).localeCompare(stableProjectionValue(right));
-}
-function stableProjectionValue(value) {
-  if (Array.isArray(value))
-    return `[${value.map(stableProjectionValue).join(",")}]`;
-  if (isEvidenceRecord(value)) {
-    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableProjectionValue(value[key])}`).join(",")}}`;
-  }
-  return JSON.stringify(value) ?? "";
-}
 function numericValue(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : 0;
 }
@@ -3046,19 +3045,105 @@ function variableInitializers(source) {
   }
   return initializers;
 }
+function unwrapQueryExpression(expr) {
+  if (ts8.isParenthesizedExpression(expr) || ts8.isAwaitExpression(expr) || ts8.isAsExpression(expr) || ts8.isTypeAssertionExpression(expr) || ts8.isNonNullExpression(expr) || ts8.isSatisfiesExpression(expr))
+    return unwrapQueryExpression(expr.expression);
+  return expr;
+}
 function queryEntityFromAst(expr, initializers = /* @__PURE__ */ new Map()) {
-  if (ts8.isParenthesizedExpression(expr) || ts8.isAwaitExpression(expr)) return queryEntityFromAst(expr.expression, initializers);
-  if (ts8.isIdentifier(expr) && initializers.has(expr.text)) return queryEntityFromAst(initializers.get(expr.text), initializers);
-  if (ts8.isCallExpression(expr)) {
-    const name = expressionName(expr.expression);
-    if (name === "cds.run") return queryEntityFromAst(expr.arguments[0], initializers);
-    if (["SELECT.one.from", "SELECT.from", "SELECT.one", "INSERT.into", "UPSERT.into", "DELETE.from", "UPDATE.entity"].includes(name)) return entityFromExpression(expr.arguments[0]);
-    if (name === "UPDATE") return entityFromExpression(expr.arguments[0]);
-    const receiver = ts8.isPropertyAccessExpression(expr.expression) ? expr.expression.expression : void 0;
+  const unwrapped = unwrapQueryExpression(expr);
+  if (ts8.isIdentifier(unwrapped) && initializers.has(unwrapped.text)) return queryEntityFromAst(initializers.get(unwrapped.text), initializers);
+  if (ts8.isCallExpression(unwrapped)) {
+    const name = expressionName(unwrapped.expression);
+    if (name === "cds.run") return queryEntityFromAst(unwrapped.arguments[0], initializers);
+    if (capQueryBuilderRoots.has(name)) return entityFromExpression(unwrapped.arguments[0]);
+    const receiver = ts8.isPropertyAccessExpression(unwrapped.expression) ? unwrapped.expression.expression : void 0;
     if (receiver) return queryEntityFromAst(receiver, initializers);
   }
   return void 0;
 }
+var capQueryBuilderRoots = /* @__PURE__ */ new Set([
+  "SELECT.from",
+  "SELECT.one.from",
+  "SELECT.one",
+  "INSERT.into",
+  "UPSERT.into",
+  "UPDATE.entity",
+  "UPDATE",
+  "DELETE.from"
+]);
+function wrapperParent(node) {
+  const parent = node.parent;
+  if ((ts8.isParenthesizedExpression(parent) || ts8.isAsExpression(parent) || ts8.isTypeAssertionExpression(parent) || ts8.isNonNullExpression(parent) || ts8.isSatisfiesExpression(parent)) && parent.expression === node)
+    return parent;
+  return void 0;
+}
+function fluentCallParent(node) {
+  const property = node.parent;
+  if (!ts8.isPropertyAccessExpression(property) || property.expression !== node) return void 0;
+  const call = property.parent;
+  return ts8.isCallExpression(call) && call.expression === property ? call : void 0;
+}
+function queryBuilderRoot(expr) {
+  const unwrapped = unwrapQueryExpression(expr);
+  if (!ts8.isCallExpression(unwrapped)) return void 0;
+  if (capQueryBuilderRoots.has(expressionName(unwrapped.expression))) return unwrapped;
+  return ts8.isPropertyAccessExpression(unwrapped.expression) ? queryBuilderRoot(unwrapped.expression.expression) : void 0;
+}
+function outerFluentQueryCall(root) {
+  let current = root;
+  let outer = root;
+  while (true) {
+    const wrapper = wrapperParent(current);
+    if (wrapper) {
+      current = wrapper;
+      continue;
+    }
+    const next = fluentCallParent(current);
+    if (!next) return outer;
+    outer = next;
+    current = next;
+  }
+}
+function directQueryBuilderStatement(node) {
+  const root = queryBuilderRoot(node);
+  if (!root) return void 0;
+  const logicalCall = outerFluentQueryCall(root);
+  if (logicalCall !== node) return void 0;
+  let current = logicalCall;
+  while (true) {
+    const wrapper = wrapperParent(current);
+    if (wrapper) {
+      current = wrapper;
+      continue;
+    }
+    const parent = current.parent;
+    return ts8.isAwaitExpression(parent) && parent.expression === current ? { root, logicalCall, awaitExpression: parent } : void 0;
+  }
+}
+function queryBuilderEvidence(source, statement) {
+  return {
+    classifier: "cap_query_builder_direct",
+    queryDispatch: "direct_query_builder",
+    queryRoot: expressionName(statement.root.expression),
+    queryRootStartOffset: statement.root.getStart(source),
+    queryRootEndOffset: statement.root.getEnd(),
+    queryStatementStartOffset: statement.awaitExpression.getStart(source),
+    queryStatementEndOffset: statement.awaitExpression.getEnd()
+  };
+}
+function queryRunEvidence(source, argument) {
+  const root = argument ? queryBuilderRoot(argument) : void 0;
+  return {
+    classifier: "cap_query_run_wrapper",
+    queryDispatch: "cds_run_wrapper",
+    ...root ? {
+      queryRoot: expressionName(root.expression),
+      queryRootStartOffset: root.getStart(source),
+      queryRootEndOffset: root.getEnd()
+    } : {}
+  };
+}
 function extractQueryEntity(expr) {
   const source = ts8.createSourceFile("query.ts", `const __query = (${expr});`, ts8.ScriptTarget.Latest, true, ts8.ScriptKind.TS);
   const initializers = variableInitializers(source);
@@ -3411,11 +3496,16 @@ function classifyOutboundCallsInSource(source, filePath) {
       }
       const expr = node.expression;
       const exprText = expr.getText(source);
+      const directQuery = directQueryBuilderStatement(node);
       if (exprText === "cds.run") {
         const arg = node.arguments[0];
         const entity = arg ? queryEntityFromAst(arg, initializers) : void 0;
         const payload = arg?.getText(source) ?? "";
-        add(node, { callType: "local_db_query", queryEntity: entity, payloadSummary: summarizeExpression(payload), confidence: entity ? 0.9 : 0.55, unresolvedReason: entity ? void 0 : queryWarning(payload) });
+        add(node, { callType: "local_db_query", queryEntity: entity, payloadSummary: summarizeExpression(payload), confidence: entity ? 0.9 : 0.55, unresolvedReason: entity ? void 0 : queryWarning(payload) }, queryRunEvidence(source, arg));
+      } else if (directQuery) {
+        const entity = queryEntityFromAst(directQuery.logicalCall, initializers);
+        const payload = directQuery.logicalCall.getText(source);
+        add(directQuery.logicalCall, { callType: "local_db_query", queryEntity: entity, payloadSummary: summarizeExpression(payload), confidence: entity ? 0.9 : 0.55, unresolvedReason: entity ? void 0 : queryWarning(payload) }, queryBuilderEvidence(source, directQuery));
       } else if (ts8.isPropertyAccessExpression(expr) && expr.name.text === "send" && (ts8.isIdentifier(expr.expression) || ts8.isPropertyAccessExpression(expr.expression))) {
         const objectArg = node.arguments[0];
         if (objectArg && ts8.isObjectLiteralExpression(objectArg)) {
@@ -3931,9 +4021,41 @@ function buildRemoteQueryTarget(input) {
 }
 
 // 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 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 = projectBounded(candidates2, compareCandidateEvidence);
+  const candidateProjection = projectBoundedInOrder(candidates2);
   const families = recordArray(evidence.candidateFamilies);
   const familyProjection = projectBounded(families, compareFamilies);
   const hints = recordArray(evidence.implementationHintSuggestions);
@@ -3996,9 +4118,6 @@ function boundedFamilyEvidence(family) {
 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 compareCandidateEvidence(left, right) {
-  return Number(left.rank ?? 0) - Number(right.rank ?? 0) || compareTargetCandidates(left, right);
-}
 function compareFamilies(left, right) {
   return String(left.packageName ?? "").localeCompare(String(right.packageName ?? "")) || String(left.reason ?? "").localeCompare(String(right.reason ?? ""));
 }
@@ -4082,7 +4201,8 @@ function implementationDecision(db, workspaceId, operation, recordDiagnostics) {
     implementationContext,
     candidates2,
     duplicateFamilies,
-    ambiguityReasons
+    ambiguityReasons,
+    unique3
   );
   const hintProjection = implementationHintSuggestionProjection(evidence);
   return {
@@ -4126,7 +4246,7 @@ function insertImplementationEdge(db, workspaceId, generation, operation, decisi
     generation
   );
 }
-function implementationEvidence(operation, context, candidates2, duplicateFamilies, ambiguityReasons) {
+function implementationEvidence(operation, context, candidates2, duplicateFamilies, ambiguityReasons, selected) {
   return {
     servicePath: operation.servicePath,
     operationPath: operation.operationPath,
@@ -4141,7 +4261,11 @@ function implementationEvidence(operation, context, candidates2, duplicateFamili
     implementationOperationId: context.operationId,
     ambiguityReasons,
     candidateFamilies: duplicateFamilies,
-    candidates: candidates2.map((candidate, index) => candidateEvidence(candidate, index + 1))
+    selectedHandler: selected ? selectedHandlerProvenance(selectedHandlerSource(selected)) : void 0,
+    candidates: displayImplementationCandidates(
+      candidates2.map((candidate, index) => candidateEvidence(candidate, index + 1)),
+      selected?.methodId
+    )
   };
 }
 function implementationContextForOperation(db, operation) {
@@ -4271,7 +4395,7 @@ function implementationCandidates(db, workspaceId, operation) {
       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,
+      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,
@@ -4440,6 +4564,7 @@ function ownershipScore(signals, acceptedReasons) {
 function candidateEvidence(candidate, rank) {
   return {
     rank,
+    rankKind: "discovery_score",
     score: candidate.score,
     accepted: candidate.accepted,
     acceptedReasons: candidate.acceptedReasons,
@@ -4492,6 +4617,18 @@ function candidateEvidence(candidate, rank) {
     }
   };
 }
+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")
@@ -6550,9 +6687,198 @@ function isConcrete(value) {
   return typeof value === "string" && value.length > 0 && extractPlaceholders(value).length === 0;
 }
 
+// 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,
@@ -6566,11 +6892,11 @@ 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);
@@ -6578,7 +6904,7 @@ function runtimeResolution(db, row, evidence, options, workspaceId, contextualUn
     return unchangedRuntimeResolution(
       row,
       boundDynamicEvidence(boundedEvidence, candidateCap),
-      contextualUnresolvedReason
+      contextualState
     );
   const substituted = evidenceWithRuntimeVariables(boundedEvidence, options.vars);
   const analysis = analyzeDynamicTargetCandidates(
@@ -6592,50 +6918,98 @@ function runtimeResolution(db, row, evidence, options, workspaceId, contextualUn
     analysis ? evidenceWithDynamicAnalysis(substituted, analysis) : substituted,
     candidateCap
   );
+  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, enriched);
-  if (dynamicMode === "infer") {
-    const inferred = inferredTarget(analysis);
-    if (inferred)
-      return resolvedRuntimeResolution(row, enriched, inferred, inferred.reasons);
-  }
-  if (analysis && analysis.missingVariables.length > 0) {
-    const unresolvedReason2 = contextualUnresolvedReason ?? row.unresolved_reason ?? "Dynamic target still requires runtime variables";
+    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(enriched, row, unresolvedReason2),
-      unresolvedReason: unresolvedReason2
+      evidence: withEffectiveResolution(
+        evidence,
+        row,
+        unresolvedReason,
+        void 0,
+        contextualState
+      ),
+      unresolvedReason
     };
   }
-  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);
+  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
     );
   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
   };
 }
@@ -6804,7 +7178,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,
@@ -6817,14 +7191,34 @@ 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 = stringValue10(evidence.servicePath);
@@ -7197,32 +7591,15 @@ function parsedEvidence(value) {
   }
 }
 function record4(value) {
-  return isRecord5(value) ? value : {};
+  return isRecord6(value) ? value : {};
 }
-function isRecord5(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/006-contextual-projection.ts
-function boundedContextCandidates(values) {
-  const candidates2 = values.flatMap((value) => {
-    return isRecord6(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 isRecord6(value) {
-  return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-
 // src/trace/007-implementation-start-diagnostic.ts
 function implementationStartDiagnostic(edge, evidence) {
   return {
@@ -7262,6 +7639,137 @@ 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;
+}
+
 // src/trace/trace-engine.ts
 function normalizeOperation2(value) {
   if (!value) return void 0;
@@ -7381,11 +7889,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 };
@@ -7575,40 +8078,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") {
-    const candidates3 = boundedContextCandidates(binding.bindingCandidates ?? []);
-    return {
-      evidence: {
-        contextualServiceBindingAttempted: true,
-        contextualBinding: {
-          source: binding.source,
-          status: "tied",
-          candidates: candidates3.candidates,
-          candidateCount: candidates3.candidateCount,
-          shownCandidateCount: candidates3.shownCandidateCount,
-          omittedCandidateCount: candidates3.omittedCandidateCount
-        },
-        contextualResolutionStatus: "ambiguous",
-        contextualCandidateCount: candidates3.candidateCount
-      },
-      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 candidates2 = boundedContextCandidates(resolution.candidates);
-  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: candidates2.candidateCount, shownContextualCandidateCount: candidates2.shownCandidateCount, omittedContextualCandidateCount: candidates2.omittedCandidateCount, candidates: candidates2.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);
@@ -7644,11 +8113,26 @@ function trace(db, start, options) {
     );
     if (impl.edge && (impl.edge.status === "resolved" || startSelection.methodId)) {
       const selectedMethodId = impl.edge.status === "resolved" ? impl.edge.to_id : startSelection.methodId;
-      const implEvidence = { ...parseEvidence(impl.edge.evidence_json), 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();
@@ -7708,7 +8192,7 @@ function trace(db, start, options) {
           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}`;
@@ -7741,29 +8225,46 @@ function trace(db, start, options) {
             hintOptions
           );
           const contextMethodId = contextSelection.methodId;
-          const contextNode = contextMethodId ? handlerMethodNode(db, contextMethodId) : void 0;
+          let selectedHandlerAvailable = true;
           if (implementation.edge) {
             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;
@@ -7798,8 +8299,7 @@ function trace(db, start, options) {
 }
 
 export {
-  projectBounded,
-  stableProjectionValue,
+  projectBoundedInOrder,
   upsertWorkspace,
   getWorkspace,
   upsertRepository,
@@ -7841,4 +8341,4 @@ export {
   selectorRepoAmbiguousDiagnostic,
   trace
 };
-//# sourceMappingURL=chunk-LFH7C46B.js.map
+//# sourceMappingURL=chunk-GXYVIHJ5.js.map