@saptools/service-flow 0.1.68 → 0.1.70

package/src/trace/{020-compact-field-projection.ts → compact-field-projection.ts}

@@ -4,7 +4,7 @@ import type {
   TraceOptions,
   TraceStart,
 } from '../types.js';
-import { compareBinary } from './010-traversal-scope.js';
+import { compareBinary } from './traversal-scope.js';
 import type {
   CompactDecisionInput,
   CompactDecisionV1,
@@ -16,12 +16,15 @@ import type {
   CompactQueryV1,
   CompactStartV1,
   CompactStatusCountsV1,
-} from './014-compact-contract.js';
+} from './compact-contract.js';
 import {
   compactMissingRemediation,
+  isSafeCompactReferenceName,
+  isSafeCompactSelectorSuggestion,
+  projectCompactReferenceGroup,
   projectCompactMissingNames,
   type CompactMissingNameProjection,
-} from './021-compact-decision-normalization.js';
+} from './compact-decision-normalization.js';
 
 const compactDiagnosticMessages: Readonly<Record<string, string>> = {
   schema_upgrade_required: 'The database schema must be upgraded before tracing.',
@@ -31,8 +34,19 @@ const compactDiagnosticMessages: Readonly<Record<string, string>> = {
   implementation_hint_mismatch: 'The implementation hint did not select one implementation.',
   selected_handler_provenance_mismatch: 'Selected handler provenance did not match its graph target.',
   selected_handler_target_not_found: 'The selected handler target is not indexed.',
+  trace_start_ambiguous: 'The trace start selector is ambiguous.',
+  trace_start_not_found: 'The trace start selector did not match an indexed start.',
   trace_start_implementation_unresolved: 'The trace start implementation is unresolved.',
 };
+const selectorDiagnosticCodes = new Set([
+  'handler_decorators_not_indexed',
+  'handler_methods_not_indexed',
+  'selector_repo_ambiguous',
+  'selector_repo_not_found',
+  'trace_start_ambiguous',
+  'trace_start_implementation_unresolved',
+  'trace_start_not_found',
+]);
 
 export function projectCompactDecision(
   input: CompactDecisionInput | undefined,
@@ -87,6 +101,8 @@ function addImplementationDecision(
     out.implementationGuided = input.implementationGuided;
   if (input.implementationContextual !== undefined)
     out.implementationContextual = input.implementationContextual;
+  if (input.tiedCandidateRepos)
+    out.tiedCandidateRepos = input.tiedCandidateRepos;
 }
 
 function addEventDecision(out: CompactDecisionV1, input: CompactDecisionInput): void {
@@ -243,6 +259,10 @@ function compactDiagnosticDetails(
   const out: CompactDiagnosticDetailsV1 = {};
   const reasonCode = compactSafeCode(value.reasonCode);
   if (reasonCode) out.reasonCode = reasonCode;
+  if (selectorDiagnosticCodes.has(code)) addDiagnosticSelector(out, value);
+  if (code === 'reindex_required') addInvalidFactCategories(out, value);
+  if (code === 'implementation_hint_mismatch')
+    addImplementationHintCandidates(out, value);
   if (code === 'trace_runtime_variables_missing') addDiagnosticNames(out, value);
   addDiagnosticCounts(out, value);
   const hint = compactDiagnosticRemediation(code, out);
@@ -255,6 +275,51 @@ function compactDiagnosticDetails(
   return out;
 }
 
+function addDiagnosticSelector(
+  out: CompactDiagnosticDetailsV1,
+  value: Record<string, unknown>,
+): void {
+  const selectorKind = compactSafeCode(value.selectorKind);
+  if (selectorKind) out.selectorKind = selectorKind;
+  const suggestions = projectCompactReferenceGroup(
+    compactStringArray(value.selectorSuggestions),
+    value.selectorSuggestionCount,
+    isSafeCompactSelectorSuggestion,
+  );
+  if (suggestions) out.selectorSuggestions = suggestions;
+}
+
+function addInvalidFactCategories(
+  out: CompactDiagnosticDetailsV1,
+  value: Record<string, unknown>,
+): void {
+  const categories = compactRecordArray(value.invalidFactCategories)
+    .flatMap((item) =>
+      typeof item.category === 'string' ? [item.category] : []);
+  const projection = projectCompactReferenceGroup(
+    categories, value.invalidFactCategoryCount,
+    (item) => compactSafeCode(item) === item,
+  );
+  if (projection) out.invalidFactCategories = projection;
+}
+
+function addImplementationHintCandidates(
+  out: CompactDiagnosticDetailsV1,
+  value: Record<string, unknown>,
+): void {
+  const repos = compactRecordArray(value.implementationHintSuggestions)
+    .flatMap((item) =>
+      typeof item.implementationRepo === 'string'
+        ? [item.implementationRepo] : []);
+  const uniqueCount = new Set(repos.map((repo) => repo.trim())).size;
+  if (uniqueCount < 2) return;
+  const projection = projectCompactReferenceGroup(
+    repos, value.implementationHintSuggestionCount,
+    isSafeCompactReferenceName,
+  );
+  if (projection) out.tiedCandidateRepos = projection;
+}
+
 function addDiagnosticNames(
   out: CompactDiagnosticDetailsV1,
   value: Record<string, unknown>,
@@ -345,7 +410,8 @@ function compactDiagnosticHintCount(
 
 function compactRemediationHint(code: string): string | undefined {
   if (code === 'provide_runtime_variables') return 'Provide the missing variable names listed in details.';
-  if (code === 'select_implementation') return 'Select one implementation with a scoped implementation hint.';
+  if (code === 'select_implementation')
+    return 'Use --implementation-hint with service, operation, package, repository, family, and repo keys; repo is required.';
   if (code === 'reindex_and_link') return 'Force reindex, then force relink the workspace.';
   if (code === 'inspect_detailed_edge') return 'Inspect the correlated detailed trace edge.';
   return undefined;
@@ -389,6 +455,13 @@ function compactStringArray(value: unknown): string[] {
     ? value.filter((item): item is string => typeof item === 'string') : [];
 }
 
+function compactRecordArray(value: unknown): Array<Record<string, unknown>> {
+  return Array.isArray(value)
+    ? value.filter((item): item is Record<string, unknown> =>
+        Boolean(item && typeof item === 'object' && !Array.isArray(item)))
+    : [];
+}
+
 function compactArrayLength(value: unknown): number {
   return Array.isArray(value) ? value.length : 0;
 }

package/src/trace/{024-compact-observation-decision.ts → compact-observation-decision.ts}

@@ -2,14 +2,15 @@ import type {
   CompactDecisionTargetInput,
   CompactDecisionV1,
   CompactEdgeObservation,
-} from './014-compact-contract.js';
-import { projectCompactDecision } from './020-compact-field-projection.js';
+} from './compact-contract.js';
+import { projectCompactDecision } from './compact-field-projection.js';
 import { normalizeCompactDecisionEquivalence } from
-  './021-compact-decision-normalization.js';
+  './compact-decision-normalization.js';
 
 export interface CompactDecisionNode {
   key?: string;
   decisionTarget?: string;
+  projectedIdentity?: boolean;
 }
 
 function resolvedNode(
@@ -40,7 +41,10 @@ function sameCanonicalNode(
   left: CompactDecisionNode | undefined,
   right: CompactDecisionNode,
 ): boolean {
-  return left?.key !== undefined && left.key === right.key;
+  if (left?.key === undefined) return false;
+  return left.projectedIdentity === true
+    ? left.key === right.decisionTarget
+    : left.key === right.key;
 }
 
 function persistedCanonical(
@@ -49,7 +53,7 @@ function persistedCanonical(
   target: CompactDecisionNode,
 ): boolean {
   if (!sameCanonicalNode(persisted, target)) return false;
-  return effective?.key === undefined || effective.key === target.key;
+  return effective?.key === undefined || sameCanonicalNode(effective, target);
 }
 
 export function projectObservationDecision(
@@ -71,6 +75,7 @@ export function projectObservationDecision(
     target.decisionTarget,
     sameCanonicalNode(effective, target),
     persistedCanonical(persisted, effective, target),
+    source?.persistedResolutionStatus,
   );
   return decision;
 }

package/src/trace/{016-compact-projector.ts → compact-projector.ts}

@@ -1,6 +1,6 @@
 import type { Db } from '../db/connection.js';
 import { redactText } from '../utils/redaction.js';
-import { compareBinary as binaryCompare } from './010-traversal-scope.js';
+import { compareBinary as binaryCompare } from './traversal-scope.js';
 import {
   type CompactDecisionTargetInput,
   type CompactProjectedDiagnostic,
@@ -17,16 +17,16 @@ import {
   type CompactSemanticEndpoint,
   type CompactSourceSite,
   type CompactStatus,
-} from './014-compact-contract.js';
+} from './compact-contract.js';
 import {
   compactCompleteness, compactSafeCode, compactStatusCounts, compactStatusTotal,
   projectCompactDecisionTarget, projectCompactDiagnostics,
   projectCompactQuery, projectCompactStart,
-} from './020-compact-field-projection.js';
+} from './compact-field-projection.js';
 import {
   projectObservationDecision,
   type CompactDecisionNode,
-} from './024-compact-observation-decision.js';
+} from './compact-observation-decision.js';
 
 const REFERENCE_LIMIT = 5;
 
@@ -111,9 +111,8 @@ function decisionInputNode(
     return symbolNode(db, numeric) ?? {};
   if (target.kind === 'handler_method' && numeric !== undefined)
     return handlerNode(db, numeric) ?? {};
-  return {
-    decisionTarget: projectCompactDecisionTarget(target.kind, target.id),
-  };
+  const decisionTarget = projectCompactDecisionTarget(target.kind, target.id);
+  return { key: decisionTarget, decisionTarget, projectedIdentity: true };
 }
 
 function resolveEndpoint(

package/src/trace/{018-compact-trace.ts → compact-trace.ts}

@@ -1,8 +1,8 @@
 import type { Db } from '../db/connection.js';
 import { CURRENT_SCHEMA_VERSION } from '../db/migrations.js';
-import type { CompactGraphV1, CompactSourceContext } from './014-compact-contract.js';
-import { CompactObservationCollector } from './014-compact-contract.js';
-import { projectCompactGraph } from './016-compact-projector.js';
+import type { CompactGraphV1, CompactSourceContext } from './compact-contract.js';
+import { CompactObservationCollector } from './compact-contract.js';
+import { projectCompactGraph } from './compact-projector.js';
 import { traceWithObserver } from './trace-engine.js';
 import type { TraceOptions, TraceResult, TraceStart } from '../types.js';
 

package/src/trace/{006-contextual-projection.ts → contextual-projection.ts}

@@ -1,4 +1,4 @@
-import { projectBounded } from '../utils/000-bounded-projection.js';
+import { projectBounded } from '../utils/bounded-projection.js';
 
 export function boundedContextCandidates(values: unknown[]): {
   candidates: Array<Record<string, unknown>>;

package/src/trace/{008-contextual-runtime-state.ts → contextual-runtime-state.ts}

@@ -1,7 +1,7 @@
 import type { Db } from '../db/connection.js';
 import { normalizeODataOperationInvocationPath } from '../linker/odata-path-normalizer.js';
 import { resolveOperation, type OperationResolution } from '../linker/service-resolver.js';
-import { boundedContextCandidates } from './006-contextual-projection.js';
+import { boundedContextCandidates } from './contextual-projection.js';
 
 export interface ContextBinding {
   bindingId?: number;

package/src/trace/{001-dynamic-identity.ts → dynamic-identity.ts}

@@ -1,10 +1,10 @@
 import type { Db } from '../db/connection.js';
-import { scanPlaceholders } from '../utils/001-placeholders.js';
+import { scanPlaceholders } from '../utils/placeholders.js';
 import type {
   DynamicTargetCandidate,
   DynamicTemplates,
   DynamicVariableProvenance,
-} from './000-dynamic-target-types.js';
+} from './dynamic-target-types.js';
 
 interface RouteImplementationEvidence {
   routeRepoId?: number;

package/src/trace/{003-dynamic-references.ts → dynamic-references.ts}

@@ -2,8 +2,8 @@ import type { Db } from '../db/connection.js';
 import {
   projectBounded,
   type BoundedProjection,
-} from '../utils/000-bounded-projection.js';
-import type { DynamicVariableProvenance } from './000-dynamic-target-types.js';
+} from '../utils/bounded-projection.js';
+import type { DynamicVariableProvenance } from './dynamic-target-types.js';
 
 export interface DynamicReferenceRow {
   bindingId?: number;

package/src/trace/dynamic-targets.ts

@@ -7,25 +7,25 @@ import {
 import { normalizeODataOperationInvocationPath } from '../linker/odata-path-normalizer.js';
 import type { OperationTarget } from '../linker/service-resolver.js';
 import type { DynamicMode } from '../types.js';
-import { dynamicCandidateTargets } from './004-dynamic-candidate-sources.js';
-import { projectBounded } from '../utils/000-bounded-projection.js';
-import { uniqueIdentityDerivations } from './001-dynamic-identity.js';
+import { dynamicCandidateTargets } from './dynamic-candidate-sources.js';
+import { projectBounded } from '../utils/bounded-projection.js';
+import { uniqueIdentityDerivations } from './dynamic-identity.js';
 import {
   dynamicReferenceProvenance,
   dynamicRoutingContext,
   type DynamicReferenceRow,
   type DynamicRoutingContext,
-} from './003-dynamic-references.js';
+} from './dynamic-references.js';
 import type {
   DynamicTargetAnalysis,
   DynamicTargetCandidate,
   DynamicTemplates,
   DynamicVariableProvenance,
-} from './000-dynamic-target-types.js';
+} from './dynamic-target-types.js';
 export type {
   DynamicTargetAnalysis,
   DynamicTargetCandidate,
-} from './000-dynamic-target-types.js';
+} from './dynamic-target-types.js';
 type Templates = DynamicTemplates;
 type VariableProvenance = DynamicVariableProvenance;
 interface AnalysisInputs {

package/src/trace/event-runtime-resolution.ts

@@ -0,0 +1,151 @@
+import {
+  substituteVariables,
+  type RuntimeSubstitution,
+} from '../linker/dynamic-edge-resolver.js';
+import type { Db } from '../db/connection.js';
+import {
+  eventSubscriberMissingVariables,
+  planEventSubscriberTransitions,
+  type EventSubscriberTransitionQuery,
+  type PlannedEventSubscriberTransition,
+} from './event-subscriber-traversal.js';
+import type {
+  TraversalScopeScheduler,
+  TraversalScopeState,
+} from './traversal-scope.js';
+import type { TraceGraphRow } from './evidence.js';
+
+export interface EventRuntimeResolution {
+  row: TraceGraphRow;
+  evidence: Record<string, unknown>;
+  unresolvedReason?: string;
+}
+
+export interface EventSubscriberRuntimePlan {
+  plans: PlannedEventSubscriberTransition[];
+  diagnostic?: Record<string, unknown>;
+}
+
+function record(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? value as Record<string, unknown> : undefined;
+}
+
+function eventTemplate(evidence: Record<string, unknown>): string | undefined {
+  const resolution = record(evidence.eventTemplateResolution);
+  return typeof resolution?.original === 'string'
+    ? resolution.original : undefined;
+}
+
+function missingReason(substitution: RuntimeSubstitution): string {
+  return `Dynamic target requires runtime variable overrides: ${
+    substitution.missing.join(', ')}`;
+}
+
+function missingSubscriberDiagnostic(
+  missing: readonly string[],
+): Record<string, unknown> | undefined {
+  if (missing.length === 0) return undefined;
+  return {
+    severity: 'warning',
+    code: 'trace_runtime_variables_missing',
+    message: `Runtime variables are required to resolve dynamic event subscribers: ${
+      missing.join(', ')}`,
+    missingVariables: missing,
+    suggestions: missing.map((key) => `--var ${key}=<value>`),
+    source: 'event_subscription',
+  };
+}
+
+export function runtimeEventSubscriberPlans(
+  db: Db,
+  query: EventSubscriberTransitionQuery,
+  scheduler: TraversalScopeScheduler,
+  parent: TraversalScopeState,
+  depth: number,
+  maxDepth: number,
+): EventSubscriberRuntimePlan {
+  const missing = eventSubscriberMissingVariables(db, query);
+  return {
+    plans: planEventSubscriberTransitions(
+      db, query, scheduler, parent, depth, maxDepth,
+    ),
+    diagnostic: missingSubscriberDiagnostic(missing),
+  };
+}
+
+function eventEvidence(
+  evidence: Record<string, unknown>,
+  substitution: RuntimeSubstitution,
+  row: TraceGraphRow,
+  unresolvedReason?: string,
+): Record<string, unknown> {
+  const effectiveResolution = {
+    status: unresolvedReason ? 'dynamic' : 'terminal',
+    targetKind: row.to_kind,
+    targetId: row.to_id,
+    confidence: row.confidence,
+    unresolvedReason,
+    edgeType: row.edge_type,
+  };
+  return {
+    ...evidence,
+    runtimeSubstitutions: { eventName: substitution },
+    suppliedRuntimeVariables: Object.fromEntries(
+      substitution.supplied.map((key) => [key, true]),
+    ),
+    ...(substitution.supplied.length > 0
+      ? { runtimeVariablesApplied: true } : {}),
+    ...(substitution.missing.length > 0
+      ? { missingRuntimeVariables: substitution.missing } : {}),
+    effectiveResolution,
+    linker: {
+      status: effectiveResolution.status,
+      confidence: row.confidence,
+      reason: unresolvedReason,
+      edgeType: row.edge_type,
+    },
+  };
+}
+
+function runtimeEventRow(
+  row: TraceGraphRow,
+  evidence: Record<string, unknown>,
+  substitution: RuntimeSubstitution,
+  template: string,
+): TraceGraphRow {
+  const missing = substitution.missing.length > 0;
+  const eventName = substitution.effective ?? template;
+  const callType = evidence.callType;
+  const edgeType = callType === 'async_emit'
+    ? 'HANDLER_EMITS_EVENT' : 'EVENT_CONSUMED_BY_HANDLER';
+  return {
+    ...row,
+    edge_type: missing ? 'DYNAMIC_EDGE_CANDIDATE' : edgeType,
+    status: missing ? 'dynamic' : 'terminal',
+    to_kind: missing ? 'event_candidate' : 'event',
+    to_id: missing ? `Event: ${eventName}` : eventName,
+    unresolved_reason: missing ? missingReason(substitution) : undefined,
+  };
+}
+
+export function runtimeEventResolution(
+  row: TraceGraphRow,
+  evidence: Record<string, unknown>,
+  variables: Record<string, string> | undefined,
+): EventRuntimeResolution | undefined {
+  const template = eventTemplate(evidence);
+  if (!template || row.to_kind === 'event' && variables === undefined)
+    return undefined;
+  const substitution = substituteVariables(template, variables ?? {});
+  const effectiveRow = runtimeEventRow(
+    row, evidence, substitution, template,
+  );
+  return {
+    row: effectiveRow,
+    evidence: eventEvidence(
+      evidence, substitution, effectiveRow, effectiveRow.unresolved_reason,
+    ),
+    unresolvedReason: effectiveRow.unresolved_reason,
+  };
+}

package/src/trace/{011-event-subscriber-traversal.ts → event-subscriber-traversal.ts}

@@ -1,8 +1,13 @@
 import type { Db } from '../db/connection.js';
 import {
+  matchRuntimeTemplate,
+  substituteVariables,
+} from '../linker/dynamic-edge-resolver.js';
+import {
+  compareBinary,
   type TraversalScopeScheduler,
   type TraversalScopeState,
-} from './010-traversal-scope.js';
+} from './traversal-scope.js';
 
 export type EventSubscriberTransitionStatus =
   | 'resolved'
@@ -53,6 +58,8 @@ export interface EventSubscriberTransition {
   candidateCount: number;
   symbolCallUnresolvedReason?: string;
   omittedSymbolCallUnresolvedReasonCharacterCount?: number;
+  matchStrategy?: string;
+  dispatchCertainty?: string;
   handler?: EventSubscriberSymbolTarget;
 }
 
@@ -60,6 +67,7 @@ export interface EventSubscriberTransitionQuery {
   workspaceId: number;
   graphGeneration: number;
   eventName: string;
+  vars?: Record<string, string>;
 }
 
 export type EventBodyExpansion =
@@ -156,8 +164,8 @@ export function eventTransitionEvidence(
     subscribeCallId: transition.subscribeCallId,
     symbolCallId: transition.symbolCallId,
     eventName: transition.eventName,
-    matchStrategy: 'workspace_exact_event_name',
-    dispatchCertainty: 'static_name_only',
+    matchStrategy: transition.matchStrategy ?? 'workspace_exact_event_name',
+    dispatchCertainty: transition.dispatchCertainty ?? 'static_name_only',
     associationBasis: transition.associationBasis,
     dispatchScope: transition.dispatchScope,
     roleSiteMatchCount: transition.roleSiteMatchCount,
@@ -194,7 +202,8 @@ export function loadEventSubscriberTransitions(
   query: EventSubscriberTransitionQuery,
 ): EventSubscriberTransition[] {
   const rows = db.prepare(`SELECT ge.id graphEdgeId,ge.generation graphGeneration,
-      ge.from_id eventName,ge.status,ge.to_kind targetKind,ge.to_id targetId,
+      ge.from_kind fromKind,ge.from_id eventName,ge.status,
+      ge.to_kind targetKind,ge.to_id targetId,
       ge.confidence,ge.unresolved_reason unresolvedReason,ge.evidence_json evidenceJson,
       subscribe.id subscribeCallId,subscribe.repo_id subscriptionRepoId,
       subscribe.source_file sourceFile,subscribe.source_line sourceLine,
@@ -218,19 +227,100 @@ export function loadEventSubscriberTransitions(
     LEFT JOIN repositories handler_repo
       ON handler_repo.id=handler.repo_id AND handler_repo.workspace_id=ge.workspace_id
     WHERE ge.workspace_id=? AND ge.generation=?
-      AND ge.edge_type='EVENT_SUBSCRIPTION_HANDLED_BY' AND ge.from_kind='event'
-      AND ge.from_id COLLATE BINARY=? COLLATE BINARY
+      AND ge.edge_type='EVENT_SUBSCRIPTION_HANDLED_BY'
+      AND ge.from_kind IN ('event','event_candidate')
     ORDER BY COALESCE(subscription_repo.name,'') COLLATE BINARY,
       COALESCE(subscription_repo.id,0),COALESCE(subscribe.source_file,'') COLLATE BINARY,
       subscribe.call_site_start_offset,subscribe.call_site_end_offset,ge.id`).all(
-    query.workspaceId, query.graphGeneration, query.eventName,
+    query.workspaceId, query.graphGeneration,
   );
-  return rows.flatMap((row) => {
-    const transition = transitionFromRow(row);
+  return rows.flatMap((raw) => {
+    const row = eventRowForQuery(raw, query);
+    const transition = row ? transitionFromRow(row) : undefined;
     return transition ? [transition] : [];
   });
 }
 
+function eventRowForQuery(
+  row: Record<string, unknown>,
+  query: EventSubscriberTransitionQuery,
+): Record<string, unknown> | undefined {
+  const variables = query.vars;
+  if (variables === undefined) return exactPersistedEventRow(row, query);
+  const evidence = parseEvidence(row.evidenceJson);
+  const resolution = isRecord(evidence.eventTemplateResolution)
+    ? evidence.eventTemplateResolution : {};
+  if (typeof resolution.original !== 'string')
+    return exactPersistedEventRow(row, query);
+  return runtimeMatchedEventRow(
+    row, query, evidence, resolution.original, variables,
+  );
+}
+
+function exactPersistedEventRow(
+  row: Record<string, unknown>,
+  query: EventSubscriberTransitionQuery,
+): Record<string, unknown> | undefined {
+  return row.fromKind === 'event' && row.eventName === query.eventName
+    ? row : undefined;
+}
+
+function runtimeMatchedEventRow(
+  row: Record<string, unknown>,
+  query: EventSubscriberTransitionQuery,
+  evidence: Record<string, unknown>,
+  template: string,
+  variables: Record<string, string>,
+): Record<string, unknown> | undefined {
+  const substitution = substituteVariables(template, variables);
+  if (substitution.missing.length > 0
+    || substitution.effective !== query.eventName) return undefined;
+  const resolvedAssociation = evidence.associationStatus === 'resolved';
+  return {
+    ...row,
+    eventName: query.eventName,
+    status: typeof evidence.associationStatus === 'string'
+      ? evidence.associationStatus : row.status,
+    unresolvedReason: resolvedAssociation ? null : row.unresolvedReason,
+    evidenceJson: JSON.stringify({
+      ...evidence,
+      eventSubscriptionRuntimeSubstitution: substitution,
+      matchStrategy: 'workspace_exact_event_name_after_runtime_substitution',
+      dispatchCertainty: 'runtime_variables_exact',
+    }),
+  };
+}
+
+export function eventSubscriberMissingVariables(
+  db: Db,
+  query: EventSubscriberTransitionQuery,
+): string[] {
+  if (query.vars === undefined) return [];
+  const variables = query.vars;
+  const rows = db.prepare(`SELECT ge.from_id eventName,
+    ge.evidence_json evidenceJson FROM graph_edges ge
+    WHERE ge.workspace_id=? AND ge.generation=?
+      AND ge.edge_type='EVENT_SUBSCRIPTION_HANDLED_BY'
+      AND ge.from_kind='event_candidate'`).all(
+    query.workspaceId, query.graphGeneration,
+  );
+  const missing = rows.flatMap((row) => {
+    const evidence = parseEvidence(row.evidenceJson);
+    const resolution = isRecord(evidence.eventTemplateResolution)
+      ? evidence.eventTemplateResolution : {};
+    const template = typeof resolution.original === 'string'
+      ? resolution.original : undefined;
+    if (!template) return [];
+    const substitution = substituteVariables(template, variables);
+    if (substitution.missing.length === 0
+      || matchRuntimeTemplate(
+        substitution.effective, query.eventName,
+      ) === undefined) return [];
+    return substitution.missing;
+  });
+  return [...new Set(missing)].sort(compareBinary);
+}
+
 function transitionFromRow(
   row: Record<string, unknown>,
 ): EventSubscriberTransition | undefined {
@@ -290,6 +380,8 @@ function associationEvidence(
     omittedSymbolCallUnresolvedReasonCharacterCount: symbolCallUnresolvedReason
       ? nonNegativeCount(evidence.omittedSymbolCallUnresolvedReasonCharacterCount)
       : undefined,
+    matchStrategy: stringValue(evidence.matchStrategy),
+    dispatchCertainty: stringValue(evidence.dispatchCertainty),
   };
 }
 

package/src/trace/evidence.ts

@@ -4,12 +4,12 @@ import { normalizeODataOperationInvocationPath } from '../linker/odata-path-norm
 import { resolveOperation, type OperationTarget } from '../linker/service-resolver.js';
 import type { DynamicMode } from '../types.js';
 import { analyzeDynamicTargetCandidates, type DynamicTargetAnalysis, type DynamicTargetCandidate } from './dynamic-targets.js';
-import { boundCandidateLikeEvidence } from '../utils/000-bounded-projection.js';
+import { boundCandidateLikeEvidence } from '../utils/bounded-projection.js';
 import {
   dynamicMissingReason,
   isStructuralContextualBlocker,
   type ContextualRuntimeState,
-} from './008-contextual-runtime-state.js';
+} from './contextual-runtime-state.js';
 
 export interface TraceGraphRow extends Record<string, unknown> {
   id: number;