@saptools/service-flow 0.1.47 → 0.1.49

package/src/parsers/outbound-call-parser.ts

@@ -8,6 +8,12 @@ import { summarizeExpression } from '../utils/redaction.js';
 import { classifyODataPathIntent } from '../linker/odata-path-normalizer.js';
 import { parseServiceBindings } from './service-binding-parser.js';
 import { parseImportedWrapperCalls } from './imported-wrapper-parser.js';
+import {
+  analyzeOperationPath,
+  operationPathExpression,
+  pathUnresolvedReason,
+  type OperationPathAnalysis,
+} from './operation-path-analysis.js';
 function lineOf(text: string, idx: number): number {
   return text.slice(0, idx).split('\n').length;
 }
@@ -180,44 +186,9 @@ function staticExpressionText(expr: ts.Expression | undefined, initializers: Map
   if (ts.isIdentifier(expr) && initializers.has(expr.text)) return staticExpressionText(initializers.get(expr.text), initializers);
   return undefined;
 }
-interface StaticPathResolution { text?: string; sourceKind: 'literal' | 'template' | 'const' | 'dynamic'; rawExpression?: string; constName?: string; resolution: ExpressionResolution }
-function staticPathExpression(expr: ts.Expression | undefined, use: ts.Node): StaticPathResolution {
-  const resolution = resolveExpression(expr, use, 'operation_path');
-  const sourceKind = resolution.sourceKind === 'const_alias' ? 'const' : resolution.sourceKind === 'template_with_substitutions' || resolution.sourceKind === 'no_substitution_template' ? 'template' : resolution.status === 'static' ? 'literal' : 'dynamic';
-  return { text: resolution.value, sourceKind, rawExpression: resolution.rawExpression, constName: resolution.constName, resolution };
-}
 function operationPathFromStatic(text: string | undefined): string | undefined {
   return text ? `/${stripQuotes(text).replace(/^\//, '')}` : undefined;
 }
-interface PathCandidateEvidence { candidatePaths: string[]; normalizedCandidateOperations: string[]; candidateSourceKind: string; candidateIdentifier: string; hasDynamicAssignments: boolean; conservativeReason?: string }
-function staticPathCandidates(identifier: ts.Identifier, call: ts.Node, method: string): PathCandidateEvidence | undefined {
-  const binding = resolveBinding(identifier, call);
-  const declaration = binding.declaration;
-  if (!declaration) return undefined;
-  const source = call.getSourceFile();
-  const paths: string[] = [];
-  let hasDynamicAssignments = false;
-  const addExpr = (expr: ts.Expression | undefined, origin: ts.Node): void => {
-    const resolved = staticPathExpression(expr, origin);
-    if (resolved.text) paths.push(operationPathFromStatic(resolved.text) ?? resolved.text);
-    else hasDynamicAssignments = true;
-  };
-  if (ts.isVariableDeclaration(declaration)) addExpr(declaration.initializer, declaration);
-  const visit = (node: ts.Node): void => {
-    if (node !== source && isFunctionLikeScope(node) && !nodeContains(node, call)) return;
-    if (node.getStart(source) >= call.getStart(source)) return;
-    if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isIdentifier(node.left)) {
-      const target = resolveBinding(node.left, node);
-      if (target.declaration === declaration) addExpr(node.right, node);
-    }
-    ts.forEachChild(node, visit);
-  };
-  visit(source);
-  const candidatePaths = [...new Set(paths)];
-  if (candidatePaths.length === 0) return undefined;
-  const normalizedCandidateOperations = [...new Set(candidatePaths.map((candidate) => classifyODataPathIntent(candidate, method).topLevelOperationName).filter((value): value is string => Boolean(value)))];
-  return { candidatePaths, normalizedCandidateOperations, candidateSourceKind: 'static candidates observed before call in lexical scope', candidateIdentifier: identifier.text, hasDynamicAssignments, conservativeReason: hasDynamicAssignments ? 'dynamic_assignment_observed' : normalizedCandidateOperations.length > 1 ? 'candidate_tie' : undefined };
-}
 function destinationExpressionShape(expr: ts.Expression | undefined): string | undefined {
   if (!expr) return undefined;
   if (ts.isIdentifier(expr)) return 'identifier';
@@ -252,6 +223,33 @@ function safeOperationName(value: string | undefined): string | undefined {
   if (!value || !/^[A-Za-z_$][\w$]*(?:[./][A-Za-z_$][\w$]*)*$/.test(value)) return undefined;
   return operationPathFromStatic(value);
 }
+function wrapperSourceKind(sourceKind: string): string {
+  if (sourceKind.includes('const_alias')) return 'const';
+  if (sourceKind.includes('template')) return 'template';
+  if (sourceKind.includes('string_literal')) return 'literal';
+  return sourceKind.includes('conditional') ? 'ambiguous' : 'dynamic';
+}
+function literalPathSource(analysis: OperationPathAnalysis): string | undefined {
+  if (analysis.status !== 'static') return undefined;
+  if (analysis.sourceKind.includes('const_alias')) return 'same_scope_const_initializer';
+  if (analysis.sourceKind.includes('no_substitution_template')) return 'template';
+  return analysis.sourceKind.includes('string_literal') ? 'literal' : analysis.sourceKind;
+}
+function legacyPathCandidates(analysis: OperationPathAnalysis): Record<string, unknown> | undefined {
+  if (analysis.candidateRawPaths.length < 2 && analysis.dynamicReassignments.length === 0)
+    return undefined;
+  return {
+    candidatePaths: analysis.candidateRawPaths,
+    normalizedCandidateOperations: analysis.candidateNormalizedOperationPaths
+      .map((value) => value.replace(/^\//, '')),
+    candidateSourceKind: analysis.sourceKind,
+    candidateIdentifier: analysis.candidateIdentifier,
+    hasDynamicAssignments: analysis.dynamicReassignments.length > 0,
+    conservativeReason: analysis.dynamicReassignments.length > 0
+      ? 'dynamic_assignment_observed'
+      : 'candidate_tie',
+  };
+}
 function hasTemplatePlaceholder(value: string): boolean { return /\$\{|%7B|%7D/i.test(value); }
 function urlTargetFromExpression(expr: ts.Expression | undefined, use: ts.Node): Record<string, unknown> {
   const resolved = resolveExpression(expr, use, 'external');
@@ -346,15 +344,16 @@ function collectWrapperSpecs(source: ts.SourceFile): Map<string, WrapperSpec> {
   const serviceVariables = collectServiceVariables(source);
   const calledNames = new Set<string>();
   const collectCalls = (node: ts.Node): void => {
-    if (ts.isCallExpression(node)) {
-      if (ts.isIdentifier(node.expression)) calledNames.add(node.expression.text);
-      if (ts.isCallExpression(node.expression) && ts.isIdentifier(node.expression.expression)) calledNames.add(node.expression.expression.text);
-    }
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression))
+      calledNames.add(node.expression.text);
+    if (ts.isCallExpression(node) && ts.isCallExpression(node.expression)
+      && ts.isIdentifier(node.expression.expression))
+      calledNames.add(node.expression.expression.text);
     ts.forEachChild(node, collectCalls);
   };
   collectCalls(source);
   const scanFunction = (name: string, fn: ts.FunctionLikeDeclaration): void => {
-    if (!calledNames.has(name)) return;
+    if (!calledNames.has(name) && !isExportedWrapper(fn)) return;
     const params = fn.parameters.map((param) => ts.isIdentifier(param.name) ? param.name.text : undefined);
     const sends: Array<{ client: string; path: string; method?: string; methodLiteral?: string; nestedWrapperFunction?: string; start: number; end: number }> = [];
     const visit = (node: ts.Node): void => {
@@ -396,6 +395,16 @@ function collectWrapperSpecs(source: ts.SourceFile): Map<string, WrapperSpec> {
   visitTop(source);
   return specs;
 }
+function isExportedWrapper(fn: ts.FunctionLikeDeclaration): boolean {
+  const declaration = ts.isFunctionDeclaration(fn)
+    ? fn
+    : ts.isVariableDeclaration(fn.parent)
+      ? fn.parent.parent.parent
+      : undefined;
+  if (!declaration || !ts.canHaveModifiers(declaration)) return false;
+  return ts.getModifiers(declaration)?.some((modifier) =>
+    modifier.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+}
 export function classifyOutboundCallsInSource(source: ts.SourceFile, filePath: string): ClassifiedOutboundCall[] {
   const calls: ClassifiedOutboundCall[] = [];
   const sourceFile = normalizePath(filePath);
@@ -425,17 +434,16 @@ export function classifyOutboundCallsInSource(source: ts.SourceFile, filePath: s
           const query = objectPropertyText(objectArg, 'query');
           const method = stripQuotes(resolveExpression(propertyInitializer(objectArg, 'method'), node, 'literal').value ?? objectPropertyText(objectArg, 'method') ?? 'POST');
           const pathExpr = propertyInitializer(objectArg, 'path') ?? propertyInitializer(objectArg, 'event');
-          const resolvedPath = staticPathExpression(pathExpr, node);
-          const op = pathExpr ? resolvedPath.text ?? pathExpr.getText(source) : undefined;
+          const pathAnalysis = analyzeOperationPath(pathExpr, node, method);
+          const op = pathExpr ? operationPathExpression(pathAnalysis) ?? pathExpr.getText(source) : undefined;
           const shorthandPath = objectPropertyIsShorthand(objectArg, 'path');
-          const candidateEvidence = pathExpr && ts.isIdentifier(pathExpr) && !resolvedPath.text ? staticPathCandidates(pathExpr, node, method) : undefined;
-          const candidateOperationPath = candidateEvidence && !candidateEvidence.hasDynamicAssignments && candidateEvidence.normalizedCandidateOperations.length === 1 && candidateEvidence.candidatePaths.length > 0 ? candidateEvidence.candidatePaths[0] : undefined;
-          const operationPathExpr = operationPathFromStatic(resolvedPath.text) ?? candidateOperationPath;
+          const operationPathExpr = operationPathExpression(pathAnalysis);
           const intent = classifyODataPathIntent(operationPathExpr, method);
           const entityCallTypes: Record<string, OutboundCallFact['callType']> = { entity_mutation: 'remote_entity_mutation', entity_delete: 'remote_entity_delete', entity_media: 'remote_entity_media', entity_candidate: 'remote_entity_candidate' };
           const entityCallType = entityCallTypes[intent.kind];
           const isODataQueryRead = method.toUpperCase() === 'GET' && ['entity_query', 'entity_key_read', 'entity_navigation_query'].includes(intent.kind);
-          add(node, { callType: query ? 'remote_query' : entityCallType ?? (isODataQueryRead ? 'remote_query' : 'remote_action'), serviceVariableName: receiver, method, operationPathExpr, queryEntity: query ? extractQueryEntity(query) : isODataQueryRead ? intent.entitySegment : undefined, payloadSummary: summarizeExpression(objectArg.getText(source)), confidence: op || query ? 0.8 : 0.4, unresolvedReason: !query && pathExpr && !operationPathExpr ? 'dynamic_operation_path_identifier' : undefined }, { receiver, classifier: 'service_client_send_object', operationPathExpression: shorthandPath ? op : undefined, rawPathExpression: resolvedPath.rawExpression, literalPathSource: resolvedPath.text ? (resolvedPath.sourceKind === 'const' ? 'same_scope_const_initializer' : resolvedPath.sourceKind) : undefined, odataPathIntent: operationPathExpr ? intent : undefined, staticPathCandidates: candidateEvidence, parserWarning: !query && pathExpr && !operationPathExpr ? 'dynamic_operation_path_identifier' : undefined });
+          const unresolvedReason = !query && pathExpr ? pathUnresolvedReason(pathAnalysis) : undefined;
+          add(node, { callType: query ? 'remote_query' : entityCallType ?? (isODataQueryRead ? 'remote_query' : 'remote_action'), serviceVariableName: receiver, method, operationPathExpr, queryEntity: query ? extractQueryEntity(query) : isODataQueryRead ? intent.entitySegment : undefined, payloadSummary: summarizeExpression(objectArg.getText(source)), confidence: op || query ? 0.8 : 0.4, unresolvedReason }, { receiver, classifier: 'service_client_send_object', operationPathExpression: shorthandPath ? op : undefined, rawPathExpression: pathAnalysis.rawExpression, literalPathSource: literalPathSource(pathAnalysis), odataPathIntent: operationPathExpr ? intent : undefined, pathAnalysis, staticPathCandidates: legacyPathCandidates(pathAnalysis), parserWarning: unresolvedReason });
         } else {
           const receiver = receiverName(expr.expression);
           const rootReceiver = rootReceiverName(expr.expression);
@@ -444,10 +452,11 @@ export function classifyOutboundCallsInSource(source: ts.SourceFile, filePath: s
           const pathArg = node.arguments[1];
           const supported = method && supportedHttpMethods.has(method);
           if (receiver && supported && serviceVariables.has(rootReceiver ?? receiver)) {
-            const resolvedPath = staticPathExpression(pathArg, node);
-            const operationPathExpr = operationPathFromStatic(resolvedPath.text);
+            const pathAnalysis = analyzeOperationPath(pathArg, node, method);
+            const operationPathExpr = operationPathExpression(pathAnalysis);
             const intent = classifyODataPathIntent(operationPathExpr, method);
-            add(node, { callType: 'remote_action', serviceVariableName: rootReceiver ?? receiver, method, operationPathExpr, payloadSummary: summarizeExpression(node.getText(source)), confidence: operationPathExpr ? 0.8 : 0.45, unresolvedReason: operationPathExpr ? undefined : 'dynamic_operation_path_identifier' }, { receiver, rootReceiver, classifier: 'service_client_send_method_path', rawPathExpression: resolvedPath.rawExpression, literalPathSource: resolvedPath.text ? (resolvedPath.sourceKind === 'const' ? 'same_scope_const_initializer' : resolvedPath.sourceKind) : undefined, odataPathIntent: operationPathExpr ? intent : undefined, parserWarning: operationPathExpr ? undefined : 'dynamic_operation_path_identifier' });
+            const unresolvedReason = pathUnresolvedReason(pathAnalysis);
+            add(node, { callType: 'remote_action', serviceVariableName: rootReceiver ?? receiver, method, operationPathExpr, payloadSummary: summarizeExpression(node.getText(source)), confidence: operationPathExpr ? 0.8 : 0.45, unresolvedReason }, { receiver, rootReceiver, classifier: 'service_client_send_method_path', rawPathExpression: pathAnalysis.rawExpression, literalPathSource: literalPathSource(pathAnalysis), odataPathIntent: operationPathExpr ? intent : undefined, pathAnalysis, staticPathCandidates: legacyPathCandidates(pathAnalysis), parserWarning: unresolvedReason });
           } else if (receiver && serviceVariables.has(rootReceiver ?? receiver)) {
             const operationPathExpr = safeOperationName(firstArg.value);
             add(node, { callType: 'remote_action', serviceVariableName: rootReceiver ?? receiver, operationPathExpr, payloadSummary: summarizeExpression(node.getText(source)), confidence: operationPathExpr ? 0.75 : 0.35, unresolvedReason: operationPathExpr ? undefined : 'unsupported_cap_send_signature' }, { receiver, rootReceiver, classifier: operationPathExpr ? 'service_client_send_operation_event' : 'service_client_send_unsupported_signature', rawOperationExpression: firstArg.rawExpression, literalOperationSource: firstArg.value ? firstArg.sourceKind : undefined, parserWarning: operationPathExpr ? undefined : 'unsupported_cap_send_signature' });
@@ -462,13 +471,14 @@ export function classifyOutboundCallsInSource(source: ts.SourceFile, filePath: s
         const methodArg = spec?.methodIndex === undefined ? undefined : wrapperArgs[spec.methodIndex];
         const receiver = clientArg && ts.isIdentifier(clientArg) ? clientArg.text : spec?.clientName;
         const method = stripQuotes(resolveExpression(methodArg, node, 'literal').value ?? spec?.methodLiteral ?? 'POST');
-        const resolvedPath = staticPathExpression(pathArg, node);
-        const operationPathExpr = operationPathFromStatic(resolvedPath.text);
+        const pathAnalysis = analyzeOperationPath(pathArg, node, method);
+        const operationPathExpr = operationPathExpression(pathAnalysis);
         const normalizedOperationPath = operationPathExpr ? classifyODataPathIntent(operationPathExpr, method).topLevelOperationName : undefined;
+        const unresolvedReason = pathUnresolvedReason(pathAnalysis);
         if (spec && receiver && operationPathExpr) {
-          add(node, { callType: 'remote_action', serviceVariableName: receiver, method, operationPathExpr, payloadSummary: summarizeExpression(node.getText(source)), confidence: 0.75 }, { receiver, classifier: resolvedPath.sourceKind === 'literal' ? 'higher_order_wrapper_literal_path' : 'higher_order_wrapper_static_path', wrapperFunction: wrapperName, nestedWrapperFunction: spec.nestedWrapperFunction, wrapperDefinitionLine: spec.definitionLine, callerLine: lineOf(source.text, node.getStart(source)), wrapperPathSourceKind: resolvedPath.sourceKind, rawPathExpression: resolvedPath.rawExpression, normalizedOperationPath, literalPathSource: resolvedPath.sourceKind === 'const' ? 'same_scope_const_initializer' : `wrapper_call_${resolvedPath.sourceKind}`, literalCallerArgumentDetected: true });
+          add(node, { callType: 'remote_action', serviceVariableName: receiver, method, operationPathExpr, payloadSummary: summarizeExpression(node.getText(source)), confidence: 0.75, unresolvedReason }, { receiver, classifier: pathAnalysis.sourceKind.includes('string_literal') ? 'higher_order_wrapper_literal_path' : 'higher_order_wrapper_static_path', wrapperFunction: wrapperName, nestedWrapperFunction: spec.nestedWrapperFunction, wrapperDefinitionLine: spec.definitionLine, callerLine: lineOf(source.text, node.getStart(source)), wrapperPathSourceKind: wrapperSourceKind(pathAnalysis.sourceKind), rawPathExpression: pathAnalysis.rawExpression, normalizedOperationPath, literalPathSource: pathAnalysis.sourceKind.includes('const_alias') ? 'same_scope_const_initializer' : `wrapper_call_${wrapperSourceKind(pathAnalysis.sourceKind)}`, literalCallerArgumentDetected: true, pathAnalysis });
         } else if (spec && receiver) {
-          add(node, { callType: 'remote_action', serviceVariableName: receiver, method, payloadSummary: summarizeExpression(node.getText(source)), confidence: 0.45, unresolvedReason: 'dynamic_operation_path_identifier' }, { receiver, classifier: 'higher_order_wrapper_dynamic_path', wrapperFunction: wrapperName, wrapperDefinitionLine: spec.definitionLine, callerLine: lineOf(source.text, node.getStart(source)), wrapperPathSourceKind: resolvedPath.sourceKind, rawPathExpression: resolvedPath.rawExpression, parserWarning: 'dynamic_operation_path_identifier' });
+          add(node, { callType: 'remote_action', serviceVariableName: receiver, method, payloadSummary: summarizeExpression(node.getText(source)), confidence: 0.45, unresolvedReason }, { receiver, classifier: pathAnalysis.status === 'ambiguous' ? 'higher_order_wrapper_ambiguous_path' : 'higher_order_wrapper_dynamic_path', wrapperFunction: wrapperName, wrapperDefinitionLine: spec.definitionLine, callerLine: lineOf(source.text, node.getStart(source)), wrapperPathSourceKind: wrapperSourceKind(pathAnalysis.sourceKind), rawPathExpression: pathAnalysis.rawExpression, pathAnalysis, parserWarning: unresolvedReason });
         }
       } else if (ts.isPropertyAccessExpression(expr) && ['emit', 'publish', 'on'].includes(expr.name.text)) {
         const receiver = receiverName(expr.expression);

package/src/trace/evidence.ts

@@ -52,11 +52,13 @@ export function runtimeResolution(
   evidence: Record<string, unknown>,
   vars: Record<string, string> | undefined,
   workspaceId: number | undefined,
+  contextualUnresolvedReason?: string,
 ): { row: TraceGraphRow; evidence: Record<string, unknown>; target?: OperationTarget; unresolvedReason?: string } {
   const substituted = evidenceWithRuntimeVariables(evidence, vars);
   if (!isRemoteRuntimeCandidate(row, evidence, vars)) {
-    const withSections = withEffectiveResolution(substituted, row, row.unresolved_reason);
-    return { row, evidence: withSections, unresolvedReason: row.unresolved_reason };
+    const unresolvedReason = contextualUnresolvedReason ?? row.unresolved_reason;
+    const withSections = withEffectiveResolution(substituted, row, unresolvedReason);
+    return { row, evidence: withSections, unresolvedReason };
   }
   const resolution = resolveRuntimeOperation(db, substituted, workspaceId);
   if (resolution.target) {
@@ -70,6 +72,9 @@ export function runtimeResolution(
 export function runtimeVariableDiagnostic(edges: Array<{ evidence: Record<string, unknown> }>): Record<string, unknown> | undefined {
   const missing = new Set<string>();
   for (const edge of edges) {
+    const effective = parseObject(edge.evidence.effectiveResolution);
+    if (!['dynamic', 'unresolved', 'ambiguous'].includes(String(effective.status ?? '')))
+      continue;
     const substitutions = edge.evidence.runtimeSubstitutions;
     if (!substitutions || typeof substitutions !== 'object' || Array.isArray(substitutions)) continue;
     for (const value of Object.values(substitutions as Record<string, RuntimeSubstitution>))
@@ -178,12 +183,22 @@ function evidenceWithRuntimeVariables(evidence: Record<string, unknown>, vars: R
 function runtimeSubstitutions(evidence: Record<string, unknown>, vars: Record<string, string>): Record<string, RuntimeSubstitution> {
   const substitutions: Record<string, RuntimeSubstitution> = {};
   for (const key of ['servicePath', 'operationPath', 'serviceAliasExpr', 'serviceAlias', 'destination']) {
-    const substitution = substituteVariables(stringValue(evidence[key]), vars);
+    const substitution = substituteVariables(substitutionValue(evidence, key), vars);
     if (substitution.placeholders.length > 0) substitutions[key] = substitution;
   }
   return substitutions;
 }
 
+function substitutionValue(
+  evidence: Record<string, unknown>,
+  key: string,
+): string | undefined {
+  const value = stringValue(evidence[key]);
+  if (key !== 'operationPath') return value;
+  const normalized = normalizeODataOperationInvocationPath(value);
+  return normalized?.wasInvocation ? normalized.normalizedOperationPath : value;
+}
+
 function isRemoteRuntimeCandidate(row: TraceGraphRow, evidence: Record<string, unknown>, vars: Record<string, string> | undefined): boolean {
   if (!vars || Object.keys(vars).length === 0) return false;
   if (!['dynamic', 'ambiguous', 'unresolved'].includes(String(row.status ?? ''))) return false;

package/src/trace/trace-engine.ts

@@ -5,13 +5,13 @@ import { resolveOperation } from '../linker/service-resolver.js';
 import type { ImplementationHint, TraceEdge, TraceResult, TraceStart } from '../types.js';
 import { baseTraceEvidence, edgeTarget, runtimeResolution, runtimeVariableDiagnostic, type TraceGraphRow } from './evidence.js';
 import { implementationHintDiagnostic, selectImplementation, type ImplementationSelection } from './implementation-hints.js';
-
 interface RepoRef {
   id: number;
   name: string;
 }
 interface StartScope {
   repo?: RepoRef;
+  executionRepoId?: number;
   sourceFiles?: Set<string>;
   symbolIds?: Set<number>;
   selectorMatched: boolean;
@@ -40,7 +40,7 @@ interface GraphRow extends Record<string, unknown> {
   status?: string;
 }
 interface ContextBinding {
-  bindingId: number;
+  bindingId?: number;
   alias?: string;
   aliasExpr?: string;
   destinationExpr?: string;
@@ -62,6 +62,8 @@ interface ContextBinding {
   calleeReceiver: string;
   callerSite?: { sourceFile?: string; sourceLine?: number };
   calleeSite?: { sourceFile?: string; sourceLine?: number };
+  resolutionStatus?: 'selected' | 'ambiguous';
+  bindingCandidates?: Array<Record<string, unknown>>;
 }
 interface ImplementationHintOptions {
   implementationRepo?: string;
@@ -74,42 +76,75 @@ function normalizeOperation(value: string | undefined): string | undefined {
 function positiveDepth(value: number): number {
   return Number.isFinite(value) && value > 0 ? Math.floor(value) : 25;
 }
-
-function operationStartScope(db: Db, repoId: number | undefined, start: TraceStart, hintOptions: ImplementationHintOptions): { files?: Set<string>; symbols?: Set<number>; operationId?: string; diagnostics?: Array<Record<string, unknown>> } | undefined {
+function operationStartScope(db: Db, repoId: number | undefined, start: TraceStart, hintOptions: ImplementationHintOptions): { files?: Set<string>; symbols?: Set<number>; repoId?: number; operationId?: string; diagnostics?: Array<Record<string, unknown>> } | undefined {
   const requested = normalizeOperation(start.operationPath ?? start.operation);
   if (!requested) return undefined;
-  const rows = db.prepare(`SELECT o.id operationId,o.operation_name operationName,o.operation_path operationPath,s.service_path servicePath,r.id repoId,r.name repoName
+  const rows = db.prepare(`SELECT o.id operationId,o.operation_name operationName,o.operation_path operationPath,o.source_file sourceFile,o.source_line sourceLine,s.service_path servicePath,r.id repoId,r.name repoName
     FROM cds_operations o JOIN cds_services s ON s.id=o.service_id JOIN repositories r ON r.id=s.repo_id
     WHERE (? IS NULL OR r.id=?) AND (? IS NULL OR s.service_path=?) AND (o.operation_name=? OR o.operation_path=? OR o.operation_path=?)
     ORDER BY r.name,s.service_path,o.operation_name,o.id`).all(repoId, repoId, start.servicePath, start.servicePath, requested, requested, requested.startsWith('/') ? requested : `/${requested}`) as Array<Record<string, unknown>>;
   if (rows.length === 0) return undefined;
   const repoCount = new Set(rows.map((row) => String(row.repoName))).size;
   const serviceCount = new Set(rows.map((row) => `${String(row.repoName)}:${String(row.servicePath)}`)).size;
-  if (!repoId && repoCount > 1) return { diagnostics: [{ severity: 'warning', code: 'trace_start_ambiguous', message: 'Operation trace start matched multiple repositories; add --repo to disambiguate', normalizedSelectorValue: requested, resolutionStage: 'operation', resolutionStatus: 'ambiguous_operation', candidates: rows }] };
-  if (!start.servicePath && serviceCount > 1) return { diagnostics: [{ severity: 'warning', code: 'trace_start_ambiguous', message: 'Operation trace start matched multiple services; add --service to disambiguate', normalizedSelectorValue: requested, resolutionStage: 'operation', resolutionStatus: 'ambiguous_operation', candidates: rows }] };
-  if (rows.length !== 1) return { diagnostics: [{ severity: 'warning', code: 'trace_start_ambiguous', message: 'Operation trace start matched multiple indexed operations', normalizedSelectorValue: requested, resolutionStage: 'operation', resolutionStatus: 'ambiguous_operation', candidates: rows }] };
+  if (!repoId && repoCount > 1)
+    return { diagnostics: [ambiguousStartDiagnostic(requested, rows, 'Operation trace start matched multiple repositories; add --repo to disambiguate')] };
+  if (!start.servicePath && serviceCount > 1)
+    return { diagnostics: [ambiguousStartDiagnostic(requested, rows, 'Operation trace start matched multiple services; add --service to disambiguate')] };
+  if (rows.length !== 1)
+    return { diagnostics: [ambiguousStartDiagnostic(requested, rows, 'Operation trace start matched multiple indexed operations')] };
   const operationId = String(rows[0]?.operationId);
   const impl = implementationScope(db, operationId);
-  if (impl.edge?.status === 'resolved' && impl.files.size > 0) return { files: impl.files, symbols: impl.symbolId ? new Set([impl.symbolId]) : undefined, operationId, diagnostics: [] };
+  if (impl.edge?.status === 'resolved' && impl.files.size > 0) return { files: impl.files, symbols: impl.symbolId ? new Set([impl.symbolId]) : undefined, repoId: impl.repoId, operationId, diagnostics: [] };
   const hinted = implementationMethodIdFromHint(impl.edge, hintOptions);
   if (hinted.methodId) {
     const hintedScope = handlerScope(db, hinted.methodId);
-    if (hintedScope?.files.size) return { files: hintedScope.files, symbols: hintedScope.symbolId ? new Set([hintedScope.symbolId]) : undefined, operationId, diagnostics: [] };
+    if (hintedScope?.files.size) return { files: hintedScope.files, symbols: hintedScope.symbolId ? new Set([hintedScope.symbolId]) : undefined, 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, implementationHintSuggestions: evidence.implementationHintSuggestions, candidates: evidence.candidates }];
+    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 }];
     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: Record<string, unknown>): string[] {
+  const candidates = Array.isArray(evidence.candidates)
+    ? evidence.candidates.filter((item): item is Record<string, unknown> =>
+        Boolean(item && typeof item === 'object' && !Array.isArray(item)))
+    : [];
+  const reasons = candidates.flatMap((candidate) =>
+    Array.isArray(candidate.rejectedReasons)
+      ? candidate.rejectedReasons.filter((reason): reason is string =>
+          typeof reason === 'string')
+      : []);
+  return [...new Set(reasons)].sort();
+}
+function ambiguousStartDiagnostic(
+  requested: string,
+  candidates: Array<Record<string, unknown>>,
+  message: string,
+): Record<string, unknown> {
+  const serviceSuggestions = [...new Set(candidates
+    .flatMap((row) => typeof row.servicePath === 'string'
+      ? [`--service ${row.servicePath}`]
+      : []))].sort();
+  return {
+    severity: 'warning',
+    code: 'trace_start_ambiguous',
+    message,
+    normalizedSelectorValue: requested,
+    resolutionStage: 'operation',
+    resolutionStatus: 'ambiguous_operation',
+    candidates,
+    serviceSuggestions,
+  };
+}
 function sourceFilesForStart(
   db: Db,
   repoId: number | undefined,
   start: TraceStart,
-): { files?: Set<string>; symbols?: Set<number> } | undefined {
+): { files?: Set<string>; symbols?: Set<number>; repoId?: number } | undefined {
   const handler = start.handler;
   const operation = normalizeOperation(start.operation ?? start.operationPath);
   if (!handler && !operation) return undefined;
@@ -138,7 +173,7 @@ function sourceFilesForStart(
       operation,
       operation,
     ) as Array<{ sourceFile?: string; symbolId?: number }>;
-  if (rows.length > 0) return { files: new Set(rows.map((row) => row.sourceFile).filter(Boolean) as string[]), symbols: new Set(rows.map((row) => Number(row.symbolId)).filter(Boolean)) };
+  if (rows.length > 0) return { files: new Set(rows.map((row) => row.sourceFile).filter(Boolean) as string[]), symbols: new Set(rows.map((row) => Number(row.symbolId)).filter(Boolean)), repoId };
   if (start.servicePath && operation) {
     const implRows = db.prepare(`SELECT DISTINCT hc.source_file sourceFile,sym.id symbolId
       FROM cds_services s JOIN cds_operations o ON o.service_id=s.id
@@ -147,7 +182,7 @@ function sourceFilesForStart(
       JOIN handler_classes hc ON hc.id=hm.handler_class_id
       LEFT JOIN symbols sym ON sym.repo_id=hc.repo_id AND sym.source_file=hc.source_file AND sym.name=hm.method_name
       WHERE (? IS NULL OR s.repo_id=?) AND s.service_path=? AND (o.operation_path=? OR o.operation_name=?)`).all(repoId, repoId, start.servicePath, operation, operation) as Array<{ sourceFile?: string; symbolId?: number }>;
-    if (implRows.length > 0) return { files: new Set(implRows.map((row) => row.sourceFile).filter(Boolean) as string[]), symbols: new Set(implRows.map((row) => Number(row.symbolId)).filter(Boolean)) };
+    if (implRows.length > 0) return { files: new Set(implRows.map((row) => row.sourceFile).filter(Boolean) as string[]), symbols: new Set(implRows.map((row) => Number(row.symbolId)).filter(Boolean)), repoId };
   }
   return undefined;
 }
@@ -171,6 +206,7 @@ function startScope(db: Db, start: TraceStart, hintOptions: ImplementationHintOp
     return { repo, selectorMatched: false };
   return {
     repo,
+    executionRepoId: sourceScope?.repoId ?? repo?.id,
     sourceFiles,
     symbolIds: sourceScope?.symbols,
     selectorMatched: !terminalOperationScope && (!hasSelector || sourceFiles !== undefined),
@@ -201,7 +237,6 @@ function handlerFilesForOperation(db: Db, operationId: string): Set<string> {
   }>;
   return new Set(rows.map((row) => row.sourceFile).filter(Boolean) as string[]);
 }
-
 function implementationEdge(db: Db, operationId: string): GraphRow | undefined {
   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) as GraphRow | undefined;
 }
@@ -220,7 +255,6 @@ function implementationMethodIdFromHint(edge: GraphRow | undefined, options: Imp
   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: GraphRow | undefined, callerRepoId: number | undefined, remoteEvidence: Record<string, unknown>, hintOptions: ImplementationHintOptions): ImplementationSelection {
   const hinted = implementationMethodIdFromHint(edge, hintOptions);
   if (hinted.methodId) return hinted;
@@ -331,21 +365,65 @@ function knownBindingsForCalls(db: Db, calls: CallRow[]): Map<string, ContextBin
 function knownBindingsForScope(db: Db, repoId: number | undefined, symbolIds: Set<number> | undefined, files: Set<string> | undefined): Map<string, ContextBinding> {
   const map = new Map<string, ContextBinding>();
   if (repoId === undefined) return map;
-  type BindingRow = Omit<ContextBinding, 'bindingId' | 'source' | 'calleeReceiver'> & { id?: number; variableName?: string };
-  const rows = db.prepare(`SELECT b.id,b.variable_name variableName,b.alias,b.alias_expr aliasExpr,b.destination_expr destinationExpr,b.service_path_expr servicePathExpr,b.source_file sourceFile,b.source_line sourceLine,req.service_path requireServicePath,req.destination requireDestination
+  type BindingRow = Omit<ContextBinding, 'bindingId' | 'source' | 'calleeReceiver'> & { id?: number; symbolId?: number | null; variableName?: string };
+  const rows = db.prepare(`SELECT b.id,b.symbol_id symbolId,b.variable_name variableName,b.alias,b.alias_expr aliasExpr,b.destination_expr destinationExpr,b.service_path_expr servicePathExpr,b.source_file sourceFile,b.source_line sourceLine,req.service_path requireServicePath,req.destination requireDestination
     FROM service_bindings b LEFT JOIN cds_requires req ON req.repo_id=b.repo_id AND req.alias=b.alias
     WHERE b.repo_id=?`).all(repoId) as BindingRow[];
   for (const row of rows) {
     if (!row.variableName) continue;
     if (files && !files.has(String(row.sourceFile))) continue;
-    if (symbolIds && symbolIds.size > 0) {
-      const owner = db.prepare('SELECT id FROM symbols WHERE id IN (' + [...symbolIds].map(() => '?').join(',') + ') AND source_file=? AND start_line<=? AND end_line>=? LIMIT 1').get(...symbolIds, row.sourceFile, row.sourceLine, row.sourceLine) as { id?: number } | undefined;
-      if (!owner) continue;
+    if (symbolIds && symbolIds.size > 0 && row.symbolId != null
+      && !symbolIds.has(Number(row.symbolId))) continue;
+    const candidate = enrichBinding({
+      ...row,
+      bindingId: Number(row.id),
+      source: 'local_service_binding',
+      calleeReceiver: row.variableName,
+      resolutionStatus: 'selected',
+    });
+    const existing = map.get(row.variableName);
+    if (!existing) {
+      map.set(row.variableName, candidate);
+      continue;
     }
-    map.set(row.variableName, enrichBinding({ ...row, bindingId: Number(row.id), source: 'local_service_binding', calleeReceiver: row.variableName }));
+    const candidates = uniqueBindingCandidates([
+      ...(existing.bindingCandidates ?? [bindingCandidateEvidence(existing)]),
+      bindingCandidateEvidence(candidate),
+    ]);
+    map.set(row.variableName, {
+      ...candidate,
+      bindingId: undefined,
+      source: 'ambiguous_local_service_bindings',
+      resolutionStatus: 'ambiguous',
+      bindingCandidates: candidates,
+    });
   }
   return map;
 }
+
+function bindingCandidateEvidence(binding: ContextBinding): Record<string, unknown> {
+  return {
+    bindingId: binding.bindingId,
+    sourceFile: binding.sourceFile,
+    sourceLine: binding.sourceLine,
+    alias: binding.alias,
+    aliasExpr: binding.aliasExpr,
+    destinationExpr: binding.destinationExpr,
+    servicePathExpr: binding.servicePathExpr,
+  };
+}
+
+function uniqueBindingCandidates(
+  candidates: Array<Record<string, unknown>>,
+): Array<Record<string, unknown>> {
+  const seen = new Set<string>();
+  return candidates.filter((candidate) => {
+    const key = JSON.stringify(candidate);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
 function contextForSymbolCall(db: Db, symbolCall: Record<string, unknown>, callerBindings: Map<string, ContextBinding>): Map<string, ContextBinding> {
   const next = new Map<string, ContextBinding>();
   if (callerBindings.size === 0) return next;
@@ -397,6 +475,21 @@ function contextForSymbolCall(db: Db, symbolCall: Record<string, unknown>, calle
 }
 function contextualRuntimeResolution(db: Db, call: CallRow, binding: ContextBinding | undefined, workspaceId: number | undefined, persistedRows: GraphRow[] = []): { row?: GraphRow; evidence?: Record<string, unknown>; unresolvedReason?: string } {
   if (!binding || String(call.call_type) !== 'remote_action' || call.operation_path_expr === undefined || 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;
@@ -445,7 +538,7 @@ export function trace(
   const seenEdges = new Set<number>();
   const queue: Array<{ repoId?: number; files?: Set<string>; symbolIds?: Set<number>; depth: number; context?: Map<string, ContextBinding> }> =
     scope.selectorMatched
-      ? [{ repoId: scope.repo?.id, files: scope.sourceFiles, symbolIds: scope.symbolIds, depth: 1, context: new Map() }]
+      ? [{ repoId: scope.executionRepoId, files: scope.sourceFiles, symbolIds: scope.symbolIds, depth: 1, context: new Map() }]
       : [];
   if (scope.startOperationId && scope.selectorMatched) {
     const op = operationNode(db, scope.startOperationId);
@@ -521,7 +614,7 @@ export function trace(
           String(row.evidence_json || '{}'),
         ) as Record<string, unknown>;
         const rawEvidence = baseTraceEvidence(row as TraceGraphRow, call, persistedEvidence, contextual.evidence);
-        const effective = runtimeResolution(db, row as TraceGraphRow, rawEvidence, options.vars, workspaceIdForCall(db, String(call.id)));
+        const effective = runtimeResolution(db, row as TraceGraphRow, rawEvidence, options.vars, workspaceIdForCall(db, String(call.id)), contextual.unresolvedReason);
         const evidence = effective.evidence;
         const effectiveRow = effective.row;
         const targetNode = `${effectiveRow.to_kind}:${effectiveRow.to_id}`;