@saptools/service-flow 0.1.53 → 0.1.55

package/dist/index.js

@@ -17,7 +17,7 @@ import {
   stripQuotes,
   substituteVariables,
   trace
-} from "./chunk-LFH7C46B.js";
+} from "./chunk-GXYVIHJ5.js";
 
 // src/parsers/generated-constants-parser.ts
 import fs from "fs/promises";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saptools/service-flow",
-  "version": "0.1.53",
+  "version": "0.1.55",
   "description": "Trace SAP CAP service-to-service flows across multi-repository workspaces with runtime-aware graph resolution",
   "type": "module",
   "publishConfig": {

package/src/cli/001-doctor-projection.ts

@@ -1,6 +1,5 @@
 import {
-  projectBounded,
-  stableProjectionValue,
+  projectBoundedInOrder,
   type BoundedProjection,
 } from '../utils/000-bounded-projection.js';
 
@@ -54,7 +53,8 @@ function boundDoctorValue(value: unknown): unknown {
       output[key] = boundDoctorValue(child);
       continue;
     }
-    const projection = projectBounded(child.map(boundDoctorValue), compareDiagnostic);
+    // Doctor producers already query or assemble deterministic semantic order.
+    const projection = projectBoundedInOrder(child.map(boundDoctorValue));
     output[key] = projection.items;
     addProjectionMetadata(output, input, key, projection);
   }
@@ -127,10 +127,6 @@ function projectionStem(key: string): string {
   return stems[key] ?? 'repository';
 }
 
-function compareDiagnostic(left: unknown, right: unknown): number {
-  return stableProjectionValue(left).localeCompare(stableProjectionValue(right));
-}
-
 function numericValue(value: unknown): number {
   return typeof value === 'number' && Number.isFinite(value) ? value : 0;
 }

package/src/cli.ts

@@ -30,9 +30,17 @@ import { renderTraceTable } from './output/table-output.js';
 import { renderTraceJson, renderJson } from './output/json-output.js';
 import { renderDoctorDiagnostics } from './output/doctor-output.js';
 import { renderMermaid } from './output/mermaid-output.js';
+import { createStdoutWriter } from './output/000-stdout-policy.js';
 import { VERSION } from './version.js';
 import type { DynamicMode } from './types.js';
 import { cleanWorkspaceState } from './cli/000-clean.js';
+
+const stdout = createStdoutWriter(process.stdout, fail);
+
+function writeStdout(value: string): void {
+  stdout.write(value);
+}
+
 async function init(
   workspace: string,
   options: { db?: string; ignore?: string[] },
@@ -58,7 +66,7 @@ async function init(
     });
   }
   db.close();
-  process.stdout.write(
+  writeStdout(
     `Workspace: ${config.rootPath}\nDatabase: ${config.dbPath}\nRepositories: ${repos.length}\nIgnored: ${config.ignore.join(', ')}\nNext: service-flow index --workspace ${config.rootPath}\n`,
   );
 }
@@ -148,7 +156,7 @@ export function createProgram(): Command {
             repo: opts.repo,
             force: Boolean(opts.force),
           });
-          process.stdout.write(
+          writeStdout(
             `Indexed ${r.indexedCount} repositories, skipped ${r.skippedCount}, ${r.fileCount} files, ${r.diagnosticCount} diagnostics\n`,
           );
         }).catch(fail),
@@ -162,7 +170,7 @@ export function createProgram(): Command {
         void withWorkspace(opts.workspace, (db, workspaceId) => {
           const r = linkWorkspace(db, workspaceId);
           const upgradeWarnings = linkUpgradeWarnings(db);
-          process.stdout.write(
+          writeStdout(
             `${upgradeWarnings.length ? `Warnings: ${upgradeWarnings.map((item) => String(item.code)).join(', ')}. Run service-flow doctor --strict for remediation.\n` : ''}Linked ${r.edgeCount} edges: ${r.remoteResolvedCount} remote operation calls resolved, ${r.localResolvedCount} local operation calls resolved, ${r.unresolvedCount} unresolved operation calls, ${r.ambiguousCount} ambiguous operation calls, ${r.dynamicCount} dynamic operation calls, ${r.terminalCount} terminal call edges, ${r.dependencyResolvedCount} dependency resolved, ${r.dependencyAmbiguousCount} dependency ambiguous, ${r.implementationResolvedCount} implementation resolved, ${r.implementationAmbiguousCount} implementation ambiguous, ${r.implementationUnresolvedCount} implementation unresolved\n`,
           );
         }).catch(fail),
@@ -227,7 +235,7 @@ export function createProgram(): Command {
               maxDynamicCandidates: parsePositiveInteger(opts.maxDynamicCandidates, 5),
             },
           );
-          process.stdout.write(
+          writeStdout(
             opts.format === 'json'
               ? renderTraceJson(result)
               : opts.format === 'mermaid'
@@ -243,7 +251,7 @@ export function createProgram(): Command {
     .action(
       (opts: { workspace?: string }) =>
         void withReadOnlyWorkspace(opts.workspace, (db, workspaceId) =>
-          process.stdout.write(
+          writeStdout(
             renderJson(
               listRepositories(db, workspaceId).map((r) => ({
                 name: r.name,
@@ -265,7 +273,7 @@ export function createProgram(): Command {
             ? selectRepository(db, opts.repo, workspaceId)
             : {};
           if (selection.diagnostic) {
-            process.stdout.write(renderJson([selection.diagnostic]));
+            writeStdout(renderJson([selection.diagnostic]));
             return;
           }
           const repo = selection.repo;
@@ -274,7 +282,7 @@ export function createProgram(): Command {
               'SELECT r.name repo,s.service_path servicePath,s.qualified_name qualifiedName FROM cds_services s JOIN repositories r ON r.id=s.repo_id WHERE r.workspace_id=? AND (? IS NULL OR s.repo_id=?) ORDER BY r.name,s.service_path',
             )
             .all(workspaceId, repo?.id, repo?.id);
-          process.stdout.write(renderJson(rows));
+          writeStdout(renderJson(rows));
         }).catch(fail),
     );
   list
@@ -289,7 +297,7 @@ export function createProgram(): Command {
             ? selectRepository(db, opts.repo, workspaceId)
             : {};
           if (selection.diagnostic) {
-            process.stdout.write(renderJson([selection.diagnostic]));
+            writeStdout(renderJson([selection.diagnostic]));
             return;
           }
           const repo = selection.repo;
@@ -298,7 +306,7 @@ export function createProgram(): Command {
               'SELECT r.name repo,s.service_path servicePath,o.operation_name operation,o.operation_path path FROM cds_operations o JOIN cds_services s ON s.id=o.service_id JOIN repositories r ON r.id=s.repo_id WHERE r.workspace_id=? AND (? IS NULL OR s.repo_id=?) AND (? IS NULL OR s.service_path=?)',
             )
             .all(workspaceId, repo?.id, repo?.id, opts.service, opts.service);
-          process.stdout.write(renderJson(rows));
+          writeStdout(renderJson(rows));
         }).catch(fail),
     );
   list
@@ -313,7 +321,7 @@ export function createProgram(): Command {
             ? selectRepository(db, opts.repo, workspaceId)
             : {};
           if (selection.diagnostic) {
-            process.stdout.write(renderJson([selection.diagnostic]));
+            writeStdout(renderJson([selection.diagnostic]));
             return;
           }
           const repo = selection.repo;
@@ -330,7 +338,7 @@ export function createProgram(): Command {
               opts.operation ? `/${opts.operation}` : undefined,
               opts.operation ? `%${opts.operation}%` : undefined,
             );
-          process.stdout.write(renderJson(rows));
+          writeStdout(renderJson(rows));
         }).catch(fail),
     );
   program
@@ -382,7 +390,7 @@ export function createProgram(): Command {
               maxDynamicCandidates: parsePositiveInteger(opts.maxDynamicCandidates, 5),
             },
           );
-          process.stdout.write(
+          writeStdout(
             opts.format === 'json'
               ? renderTraceJson(result)
               : renderMermaid(result),
@@ -398,7 +406,7 @@ export function createProgram(): Command {
       (name: string, opts: { workspace?: string }) =>
         void withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
           const selection = selectRepository(db, name, workspaceId);
-          process.stdout.write(renderJson(
+          writeStdout(renderJson(
             selection.repo ?? selection.diagnostic ?? { error: 'repo not found' },
           ));
         }).catch(fail),
@@ -415,7 +423,7 @@ export function createProgram(): Command {
               'SELECT o.* FROM cds_operations o JOIN cds_services s ON s.id=o.service_id JOIN repositories r ON r.id=s.repo_id WHERE r.workspace_id=? AND (o.operation_name=? OR o.operation_path=?)',
             )
             .all(workspaceId, selector, selector);
-          process.stdout.write(renderJson(rows));
+          writeStdout(renderJson(rows));
         }).catch(fail),
     );
   program
@@ -428,7 +436,7 @@ export function createProgram(): Command {
       (opts: { workspace?: string; strict?: boolean; detail?: boolean; format?: string }) =>
         void withReadOnlyWorkspace(opts.workspace, (db) => {
           const allDiagnostics = doctorDiagnostics(db, Boolean(opts.strict), { detail: Boolean(opts.detail) });
-          process.stdout.write(renderDoctorDiagnostics(allDiagnostics, opts.format));
+          writeStdout(renderDoctorDiagnostics(allDiagnostics, opts.format));
         }).catch(fail),
     );
   program
@@ -440,7 +448,7 @@ export function createProgram(): Command {
         void (async () => {
           const config = await loadWorkspaceConfig(opts.workspace);
           await cleanWorkspaceState(config, Boolean(opts.dbOnly));
-          process.stdout.write('Cleaned service-flow state\n');
+          writeStdout('Cleaned service-flow state\n');
         })().catch(fail),
     );
   return program;

package/src/linker/000-implementation-candidates.ts

@@ -4,6 +4,8 @@ import { normalizeDecoratorOperationSignal, normalizedOperationName } from './op
 import {
   boundedImplementationEvidence,
   boundedImplementationTargetIds,
+  displayImplementationCandidates,
+  selectedHandlerProvenance,
 } from './001-implementation-evidence-projection.js';
 
 interface ImplementationCandidate extends Record<string, unknown> {
@@ -107,6 +109,7 @@ function implementationDecision(
     : winners.length > 1 ? ['multiple_equal_score_implementation_candidates'] : [];
   const evidence = implementationEvidence(
     operation, implementationContext, candidates, duplicateFamilies, ambiguityReasons,
+    unique,
   );
   const hintProjection = implementationHintSuggestionProjection(evidence);
   return {
@@ -174,6 +177,7 @@ function implementationEvidence(
   candidates: ImplementationCandidate[],
   duplicateFamilies: Array<Record<string, unknown>>,
   ambiguityReasons: string[],
+  selected: ImplementationCandidate | undefined,
 ): Record<string, unknown> {
   return {
     servicePath: operation.servicePath,
@@ -191,7 +195,13 @@ function implementationEvidence(
     implementationOperationId: context.operationId,
     ambiguityReasons,
     candidateFamilies: duplicateFamilies,
-    candidates: candidates.map((candidate, index) => candidateEvidence(candidate, index + 1)),
+    selectedHandler: selected
+      ? selectedHandlerProvenance(selectedHandlerSource(selected))
+      : undefined,
+    candidates: displayImplementationCandidates(
+      candidates.map((candidate, index) => candidateEvidence(candidate, index + 1)),
+      selected?.methodId,
+    ),
   };
 }
 
@@ -350,7 +360,7 @@ function implementationCandidates(
       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,
@@ -526,6 +536,7 @@ function ownershipScore(
 function candidateEvidence(candidate: ImplementationCandidate, rank: number): Record<string, unknown> {
   return {
     rank,
+    rankKind: 'discovery_score',
     score: candidate.score,
     accepted: candidate.accepted,
     acceptedReasons: candidate.acceptedReasons,
@@ -580,6 +591,28 @@ function candidateEvidence(candidate: ImplementationCandidate, rank: number): Re
   };
 }
 
+function selectedHandlerSource(candidate: ImplementationCandidate): {
+  methodId: number;
+  className?: string;
+  methodName?: string;
+  repositoryId?: number;
+  repositoryName?: string;
+  repositoryPackageName?: string;
+  sourceFile?: string;
+  sourceLine?: number;
+} {
+  return {
+    methodId: candidate.methodId,
+    className: stringValue(candidate.className),
+    methodName: stringValue(candidate.methodName),
+    repositoryId: numberValue(candidate.handlerRepoId),
+    repositoryName: stringValue(candidate.handlerRepo),
+    repositoryPackageName: stringValue(candidate.handlerPackage),
+    sourceFile: stringValue(candidate.sourceFile),
+    sourceLine: numberValue(candidate.sourceLine),
+  };
+}
+
 function implementationMethodSignal(
   row: Record<string, unknown>,
   operation: Record<string, unknown>,

package/src/linker/001-implementation-evidence-projection.ts

@@ -1,14 +1,91 @@
 import {
   projectBounded,
+  projectBoundedInOrder,
   type BoundedProjection,
 } from '../utils/000-bounded-projection.js';
 
+export interface SelectedHandlerSource {
+  methodId: number;
+  className?: string;
+  methodName?: string;
+  repositoryId?: number;
+  repositoryName?: string;
+  repositoryPackageName?: string;
+  sourceFile?: string;
+  sourceLine?: number;
+}
+
+export interface SelectedHandlerProvenance {
+  status: 'selected';
+  accepted: true;
+  graphTargetId: string;
+  methodId: number;
+  className?: string;
+  methodName?: string;
+  repository?: {
+    id?: number;
+    name?: string;
+    packageName?: string;
+  };
+  sourceFile?: string;
+  sourceLine?: number;
+}
+
+export function selectedHandlerProvenance(
+  source: SelectedHandlerSource,
+): SelectedHandlerProvenance {
+  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,
+  };
+}
+
+export function displayImplementationCandidates(
+  candidates: Array<Record<string, unknown>>,
+  selectedMethodId: number | undefined,
+): Array<Record<string, unknown>> {
+  return [...candidates]
+    .sort((left, right) => compareDisplayCandidate(
+      left, right, selectedMethodId,
+    ))
+    .map((candidate, index) => ({
+      ...candidate,
+      discoveryRank: candidate.rank,
+      displayRank: index + 1,
+      selected: selectedMethodId !== undefined
+        && Number(candidate.methodId) === selectedMethodId,
+    }));
+}
+
+function compareDisplayCandidate(
+  left: Record<string, unknown>,
+  right: Record<string, unknown>,
+  selectedMethodId: number | undefined,
+): number {
+  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);
+}
+
 export function boundedImplementationEvidence(
   evidence: Record<string, unknown>,
   targetCandidateCount: number,
 ): Record<string, unknown> {
   const candidates = recordArray(evidence.candidates);
-  const candidateProjection = projectBounded(candidates, compareCandidateEvidence);
+  const candidateProjection = projectBoundedInOrder(candidates);
   const families = recordArray(evidence.candidateFamilies);
   const familyProjection = projectBounded(families, compareFamilies);
   const hints = recordArray(evidence.implementationHintSuggestions);
@@ -80,11 +157,6 @@ function compareTargetCandidates(left: Record<string, unknown>, right: Record<st
     || Number(left.methodId ?? 0) - Number(right.methodId ?? 0);
 }
 
-function compareCandidateEvidence(left: Record<string, unknown>, right: Record<string, unknown>): number {
-  return Number(left.rank ?? 0) - Number(right.rank ?? 0)
-    || compareTargetCandidates(left, right);
-}
-
 function compareFamilies(left: Record<string, unknown>, right: Record<string, unknown>): number {
   return String(left.packageName ?? '').localeCompare(String(right.packageName ?? ''))
     || String(left.reason ?? '').localeCompare(String(right.reason ?? ''));

package/src/output/000-stdout-policy.ts

@@ -0,0 +1,65 @@
+import type { Writable } from 'node:stream';
+
+export interface StdoutWriter {
+  write(value: string): boolean;
+}
+
+interface OutputState {
+  blocked: boolean;
+  unexpectedReported: boolean;
+}
+
+interface WriterEntry {
+  state: OutputState;
+  writer: StdoutWriter;
+}
+
+const writers = new WeakMap<Writable, WriterEntry>();
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+
+function isBrokenPipe(error: Error): boolean {
+  return isRecord(error) && error.code === 'EPIPE';
+}
+
+function asError(value: unknown): Error {
+  return value instanceof Error ? value : new Error(String(value));
+}
+
+function handleStreamError(
+  state: OutputState,
+  error: Error,
+  onUnexpectedError: (error: Error) => void,
+): void {
+  state.blocked = true;
+  if (isBrokenPipe(error) || state.unexpectedReported) return;
+  state.unexpectedReported = true;
+  onUnexpectedError(error);
+}
+
+export function createStdoutWriter(
+  stream: Writable,
+  onUnexpectedError: (error: Error) => void,
+): StdoutWriter {
+  const existing = writers.get(stream);
+  if (existing) return existing.writer;
+  const state: OutputState = { blocked: false, unexpectedReported: false };
+  const writer: StdoutWriter = {
+    write(value: string): boolean {
+      if (state.blocked) return false;
+      try {
+        stream.write(value);
+        return true;
+      } catch (error) {
+        handleStreamError(state, asError(error), onUnexpectedError);
+        return false;
+      }
+    },
+  };
+  stream.on('error', (error: Error) =>
+    handleStreamError(state, error, onUnexpectedError));
+  writers.set(stream, { state, writer });
+  return writer;
+}

package/src/output/table-output.ts

@@ -1,13 +1,22 @@
 import type { TraceResult } from '../types.js';
 
 function location(evidence: Record<string, unknown>): string {
+  const selected = isRecord(evidence.selectedHandler)
+    ? evidence.selectedHandler : undefined;
+  const selectedFile = selected?.sourceFile;
+  const selectedLine = selected?.sourceLine;
+  if (selectedFile || selectedLine)
+    return `${String(selectedFile ?? '')}:${String(selectedLine ?? '')}`;
   const file = evidence.file ?? evidence.sourceFile ?? evidence.handlerSourceFile ?? evidence.operationSourceFile ?? evidence.registrationSourceFile;
   const line = evidence.line ?? evidence.sourceLine ?? evidence.handlerSourceLine ?? evidence.operationSourceLine ?? evidence.registrationSourceLine;
   if (file || line) return `${String(file ?? '')}:${String(line ?? '')}`;
   const candidates = evidence.candidates;
+  if (Array.isArray(candidates) && candidates.some((candidate) =>
+    isRecord(candidate) && candidate.methodId !== undefined)) return ':';
   if (Array.isArray(candidates) && candidates.length > 0) {
-    const first = candidates[0] as Record<string, unknown>;
-    return `${String(first.sourceFile ?? '')}:${String(first.sourceLine ?? '')}`;
+    const first = candidates.find(isRecord);
+    if (first)
+      return `${String(first.sourceFile ?? '')}:${String(first.sourceLine ?? '')}`;
   }
   return ':';
 }

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

@@ -40,19 +40,121 @@ function variableInitializers(source: ts.SourceFile): Map<string, ts.Expression>
   }
   return initializers;
 }
+function unwrapQueryExpression(expr: ts.Expression): ts.Expression {
+  if (ts.isParenthesizedExpression(expr) || ts.isAwaitExpression(expr)
+    || ts.isAsExpression(expr) || ts.isTypeAssertionExpression(expr)
+    || ts.isNonNullExpression(expr) || ts.isSatisfiesExpression(expr))
+    return unwrapQueryExpression(expr.expression);
+  return expr;
+}
 function queryEntityFromAst(expr: ts.Expression, initializers = new Map<string, ts.Expression>()): string | undefined {
-  if (ts.isParenthesizedExpression(expr) || ts.isAwaitExpression(expr)) return queryEntityFromAst(expr.expression, initializers);
-  if (ts.isIdentifier(expr) && initializers.has(expr.text)) return queryEntityFromAst(initializers.get(expr.text) as ts.Expression, initializers);
-  if (ts.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 = ts.isPropertyAccessExpression(expr.expression) ? expr.expression.expression : undefined;
+  const unwrapped = unwrapQueryExpression(expr);
+  if (ts.isIdentifier(unwrapped) && initializers.has(unwrapped.text)) return queryEntityFromAst(initializers.get(unwrapped.text) as ts.Expression, initializers);
+  if (ts.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 = ts.isPropertyAccessExpression(unwrapped.expression) ? unwrapped.expression.expression : undefined;
     if (receiver) return queryEntityFromAst(receiver, initializers);
   }
   return undefined;
 }
+const capQueryBuilderRoots = new Set([
+  'SELECT.from',
+  'SELECT.one.from',
+  'SELECT.one',
+  'INSERT.into',
+  'UPSERT.into',
+  'UPDATE.entity',
+  'UPDATE',
+  'DELETE.from',
+]);
+interface DirectQueryBuilderStatement {
+  root: ts.CallExpression;
+  logicalCall: ts.CallExpression;
+  awaitExpression: ts.AwaitExpression;
+}
+function wrapperParent(node: ts.Expression): ts.Expression | undefined {
+  const parent = node.parent;
+  if ((ts.isParenthesizedExpression(parent) || ts.isAsExpression(parent)
+    || ts.isTypeAssertionExpression(parent) || ts.isNonNullExpression(parent)
+    || ts.isSatisfiesExpression(parent)) && parent.expression === node)
+    return parent;
+  return undefined;
+}
+function fluentCallParent(node: ts.Expression): ts.CallExpression | undefined {
+  const property = node.parent;
+  if (!ts.isPropertyAccessExpression(property) || property.expression !== node) return undefined;
+  const call = property.parent;
+  return ts.isCallExpression(call) && call.expression === property ? call : undefined;
+}
+function queryBuilderRoot(expr: ts.Expression): ts.CallExpression | undefined {
+  const unwrapped = unwrapQueryExpression(expr);
+  if (!ts.isCallExpression(unwrapped)) return undefined;
+  if (capQueryBuilderRoots.has(expressionName(unwrapped.expression))) return unwrapped;
+  return ts.isPropertyAccessExpression(unwrapped.expression)
+    ? queryBuilderRoot(unwrapped.expression.expression)
+    : undefined;
+}
+function outerFluentQueryCall(root: ts.CallExpression): ts.CallExpression {
+  let current: ts.Expression = 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: ts.CallExpression): DirectQueryBuilderStatement | undefined {
+  const root = queryBuilderRoot(node);
+  if (!root) return undefined;
+  const logicalCall = outerFluentQueryCall(root);
+  if (logicalCall !== node) return undefined;
+  let current: ts.Expression = logicalCall;
+  while (true) {
+    const wrapper = wrapperParent(current);
+    if (wrapper) {
+      current = wrapper;
+      continue;
+    }
+    const parent = current.parent;
+    return ts.isAwaitExpression(parent) && parent.expression === current
+      ? { root, logicalCall, awaitExpression: parent }
+      : undefined;
+  }
+}
+function queryBuilderEvidence(source: ts.SourceFile, statement: DirectQueryBuilderStatement): Record<string, unknown> {
+  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: ts.SourceFile,
+  argument: ts.Expression | undefined,
+): Record<string, unknown> {
+  const root = argument ? queryBuilderRoot(argument) : undefined;
+  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: string): string | undefined {
   const source = ts.createSourceFile('query.ts', `const __query = (${expr});`, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
   const initializers = variableInitializers(source);
@@ -98,7 +200,6 @@ function nameOfProperty(name: ts.PropertyName): string | undefined {
   if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) return name.text;
   return undefined;
 }
-
 type ExpressionStatus = 'static' | 'dynamic' | 'ambiguous' | 'unknown';
 type ExpressionSourceKind = 'string_literal' | 'no_substitution_template' | 'template_with_substitutions' | 'const_alias' | 'conditional_candidates' | 'dynamic_expression';
 interface ExpressionResolution { status: ExpressionStatus; sourceKind: ExpressionSourceKind; value?: string; rawExpression?: string; placeholderKeys: string[]; evidence: string[]; constName?: string }
@@ -303,7 +404,6 @@ function externalHttpEvidence(node: ts.CallExpression, source: ts.SourceFile): {
   }
   return undefined;
 }
-
 function collectServiceVariables(source: ts.SourceFile): Set<string> {
   const vars = new Set<string>(['cds', 'messaging', 'messageClient', 'eventClient']);
   const visit = (node: ts.Node): void => {
@@ -423,11 +523,16 @@ export function classifyOutboundCallsInSource(source: ts.SourceFile, filePath: s
       }
       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) : undefined;
         const payload = arg?.getText(source) ?? '';
-        add(node, { callType: 'local_db_query', queryEntity: entity, payloadSummary: summarizeExpression(payload), confidence: entity ? 0.9 : 0.55, unresolvedReason: entity ? undefined : queryWarning(payload) });
+        add(node, { callType: 'local_db_query', queryEntity: entity, payloadSummary: summarizeExpression(payload), confidence: entity ? 0.9 : 0.55, unresolvedReason: entity ? undefined : 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 ? undefined : queryWarning(payload) }, queryBuilderEvidence(source, directQuery));
       } else if (ts.isPropertyAccessExpression(expr) && expr.name.text === 'send' && (ts.isIdentifier(expr.expression) || ts.isPropertyAccessExpression(expr.expression))) {
         const objectArg = node.arguments[0];
         if (objectArg && ts.isObjectLiteralExpression(objectArg)) {