@saptools/service-flow 0.1.68 → 0.1.70

package/src/trace/implementation-hints.ts

@@ -1,5 +1,6 @@
 import type { ImplementationHint } from '../types.js';
-import { projectBounded } from '../utils/000-bounded-projection.js';
+import { projectBounded } from '../utils/bounded-projection.js';
+import { compareBinary } from './traversal-scope.js';
 
 interface Candidate {
   accepted?: boolean;
@@ -106,6 +107,7 @@ export function implementationHintSuggestions(rawEvidence: Record<string, unknow
 
 export function implementationHintSuggestionProjection(
   rawEvidence: Record<string, unknown>,
+  limit?: number,
 ): ImplementationHintSuggestionProjection {
   const evidence = asEvidence(rawEvidence);
   const accepted = (evidence.candidates ?? []).filter((candidate) => candidate.accepted);
@@ -119,7 +121,7 @@ export function implementationHintSuggestionProjection(
   }
   const repos = selectableRepositories(accepted);
   const repositoryProjection = projectBounded(
-    repos, (left, right) => left.localeCompare(right),
+    repos, compareBinary, limit,
   );
   const suggestions = accepted
     .flatMap((candidate) => {
@@ -142,7 +144,7 @@ export function implementationHintSuggestionProjection(
         cli: `--implementation-hint ${hintString(hint)}`,
       }];
     });
-  const projection = projectBounded(suggestions, compareSuggestion);
+  const projection = projectBounded(suggestions, compareSuggestion, limit);
   return {
     suggestions: projection.items,
     suggestionCount: projection.totalCount,
@@ -170,15 +172,16 @@ function projectedSuggestions(value: unknown): ImplementationHintSuggestionProje
 }
 
 function compareHints(left: ImplementationHint, right: ImplementationHint): number {
-  return hintString(left).localeCompare(hintString(right));
+  return compareBinary(hintString(left), hintString(right));
 }
 
 function compareSuggestion(
   left: Record<string, unknown>,
   right: Record<string, unknown>,
 ): number {
-  return String(left.cli ?? '').localeCompare(String(right.cli ?? ''))
-    || String(left.implementationRepo ?? '').localeCompare(
+  return compareBinary(String(left.cli ?? ''), String(right.cli ?? ''))
+    || compareBinary(
+      String(left.implementationRepo ?? ''),
       String(right.implementationRepo ?? ''),
     );
 }
@@ -202,7 +205,7 @@ function selectableRepositories(candidates: Candidate[]): string[] {
   const repos = new Set(candidates.flatMap((candidate) => candidate.handlerPackage?.name ? [candidate.handlerPackage.name] : []));
   return [...repos]
     .filter((repo) => candidates.filter((candidate) => candidateMatchesRepo(candidate, repo)).length === 1)
-    .sort();
+    .sort(compareBinary);
 }
 
 function assignHintField(hint: Partial<ImplementationHint>, key: string, value: string): void {

package/src/trace/{005-implementation-selection.ts → implementation-selection.ts}

@@ -1,7 +1,7 @@
 import type { Db } from '../db/connection.js';
-import { canonicalImplementationEvidence } from '../linker/000-implementation-candidates.js';
+import { canonicalImplementationEvidence } from '../linker/implementation-candidates.js';
 import type { ImplementationHint } from '../types.js';
-import { projectBounded } from '../utils/000-bounded-projection.js';
+import { projectBounded } from '../utils/bounded-projection.js';
 import {
   selectImplementation,
   type ImplementationSelection,

package/src/trace/{007-implementation-start-diagnostic.ts → implementation-start-diagnostic.ts}

@@ -15,6 +15,7 @@ export function implementationStartDiagnostic(
     message: `Indexed operation matched but implementation edge is ${String(
       edge.status ?? 'unresolved',
     )}`,
+    selectorKind: 'operation',
     resolutionStage: 'implementation',
     resolutionStatus: edge.status === 'ambiguous'
       ? 'ambiguous_implementation'

package/src/trace/local-call-expansion.ts

@@ -0,0 +1,37 @@
+import type { Db } from '../db/connection.js';
+import {
+  type ContextBinding,
+} from './contextual-runtime-state.js';
+import {
+  type TraversalScheduleDecision,
+  type TraversalScopeScheduler,
+  type TraversalScopeState,
+} from './traversal-scope.js';
+import { contextForSymbolCall } from './trace-context.js';
+
+export interface LocalCallExpansion {
+  repoId: number;
+  files: Set<string>;
+  symbols: Set<number>;
+  context: Map<string, ContextBinding>;
+  scheduling: TraversalScheduleDecision;
+}
+
+export function planLocalCallExpansion(
+  db: Db,
+  scheduler: TraversalScopeScheduler,
+  workspaceId: number | undefined,
+  parent: TraversalScopeState,
+  row: Record<string, unknown>,
+  bindings: Map<string, ContextBinding>,
+  symbolId: number,
+): LocalCallExpansion {
+  const symbols = new Set([symbolId]);
+  const files = new Set([String(row.calleeFile)]);
+  const repoId = Number(row.calleeRepoId);
+  const context = contextForSymbolCall(db, row, bindings);
+  const scheduling = scheduler.schedule({
+    workspaceId, repoId, files, symbolIds: symbols, context,
+  }, parent);
+  return { repoId, files, symbols, context, scheduling };
+}

package/src/trace/{009-selected-handler-provenance.ts → selected-handler-provenance.ts}

@@ -3,7 +3,7 @@ import {
   selectedHandlerProvenance,
   type SelectedHandlerProvenance,
   type SelectedHandlerSource,
-} from '../linker/001-implementation-evidence-projection.js';
+} from '../linker/implementation-evidence-projection.js';
 
 export interface HandlerMethodNode extends Record<string, unknown> {
   id: string;

package/src/trace/selectors.ts

@@ -3,7 +3,7 @@ import type { TraceStart } from '../types.js';
 import {
   projectBounded,
   type BoundedProjection,
-} from '../utils/000-bounded-projection.js';
+} from '../utils/bounded-projection.js';
 
 export interface SelectorSourceScope {
   files?: Set<string>;
@@ -550,6 +550,7 @@ export function ambiguousStartDiagnostic(
     severity: 'warning',
     code: 'trace_start_ambiguous',
     message,
+    selectorKind: 'operation',
     normalizedSelectorValue: requested,
     resolutionStage: 'operation',
     resolutionStatus: 'ambiguous_operation',

package/src/trace/{017-trace-context.ts → trace-context.ts}

@@ -1,7 +1,7 @@
 import type { Db } from '../db/connection.js';
 import { extractPlaceholders } from '../linker/dynamic-edge-resolver.js';
-import { boundCandidateLikeEvidence } from '../utils/000-bounded-projection.js';
-import type { ContextBinding } from './008-contextual-runtime-state.js';
+import { boundCandidateLikeEvidence } from '../utils/bounded-projection.js';
+import type { ContextBinding } from './contextual-runtime-state.js';
 
 export interface TraceContextCall extends Record<string, unknown> {
   service_binding_id?: number;

package/src/trace/{015-trace-edge-recorder.ts → trace-edge-recorder.ts}

@@ -7,7 +7,13 @@ import type {
   CompactSourceSite,
   CompactStatus,
   CompactTraceObserver,
-} from './014-compact-contract.js';
+} from './compact-contract.js';
+import { implementationHintSuggestionProjection } from
+  './implementation-hints.js';
+import {
+  isSafeCompactReferenceName,
+  projectCompactReferenceGroup,
+} from './compact-decision-normalization.js';
 
 export interface TraceEdgeSemantics {
   source: CompactSemanticEndpoint;
@@ -111,8 +117,7 @@ export function semanticGraphTarget(
 ): CompactSemanticEndpoint {
   if (row.to_kind === 'event') return {
     kind: 'event', workspaceId,
-    eventName: typeof call.event_name_expr === 'string'
-      ? call.event_name_expr : row.to_id,
+    eventName: row.to_id,
   };
   const id = positiveNumber(row.to_id);
   if (row.to_kind === 'operation')
@@ -198,7 +203,7 @@ export function compactDecisionFromEvidence(
   const authoritativeMissingCount = finiteNumber(
     dynamic.missingVariableCount ?? evidence.missingVariableCount,
   );
-  return {
+  const decision: CompactDecisionInput = {
     effectiveResolutionStatus: stringValue(effective.status),
     effectiveTarget: targetSummary(effective),
     persistedResolutionStatus: stringValue(persisted.status),
@@ -221,7 +226,7 @@ export function compactDecisionFromEvidence(
     implementationGuided: booleanValue(implementation.guided),
     implementationContextual: booleanValue(
       evidence.contextualImplementationSelected),
-    reasonCode: stringValue(evidence.reasonCode ?? evidence.cycleReason),
+    reasonCode: compactEvidenceReasonCode(evidence),
     eventMatchStrategy: stringValue(evidence.matchStrategy),
     dispatchCertainty: stringValue(evidence.dispatchCertainty),
     associationStatus: stringValue(evidence.associationStatus),
@@ -233,6 +238,7 @@ export function compactDecisionFromEvidence(
     bodyExpansion: stringValue(evidence.bodyExpansion),
     ...overrides,
   };
+  return decisionWithTiedCandidates(evidence, decision);
 }
 
 export function compactRefs(
@@ -334,3 +340,54 @@ function firstNumber(...values: unknown[]): number | undefined {
   }
   return undefined;
 }
+
+export function compactEvidenceReasonCode(
+  evidence: Record<string, unknown>,
+): string | undefined {
+  return stringValue(evidence.reasonCode ?? evidence.cycleReason)
+    ?? parserWarningReason(evidence.parserWarning);
+}
+
+function parserWarningReason(value: unknown): string | undefined {
+  const warning = recordValue(value);
+  const code = stringValue(warning.code);
+  if (code && code !== 'parser_warning') return code;
+  return stringValue(warning.message);
+}
+
+function tiedCandidateRepositoryGroup(
+  evidence: Record<string, unknown>,
+  decision: CompactDecisionInput,
+): CompactDecisionInput['tiedCandidateRepos'] {
+  if (decision.effectiveResolutionStatus !== 'ambiguous'
+    || (decision.candidateCount ?? 0) <= 1) return undefined;
+  const persisted = Array.isArray(evidence.implementationHintSuggestions)
+    ? evidence.implementationHintSuggestions.filter(
+        (value): value is Record<string, unknown> =>
+          Boolean(value && typeof value === 'object' && !Array.isArray(value)),
+      )
+    : [];
+  const projection = persisted.length > 0 ? {
+    suggestions: persisted,
+    suggestionCount: finiteNumber(
+      evidence.implementationHintSuggestionCount,
+    ) ?? persisted.length,
+  } : implementationHintSuggestionProjection(
+    evidence, Number.MAX_SAFE_INTEGER,
+  );
+  const repos = projection.suggestions.flatMap((suggestion) =>
+    typeof suggestion.implementationRepo === 'string'
+      ? [suggestion.implementationRepo] : []);
+  const group = projectCompactReferenceGroup(
+    repos, projection.suggestionCount, isSafeCompactReferenceName,
+  );
+  return group && group.total > 1 ? group : undefined;
+}
+
+function decisionWithTiedCandidates(
+  evidence: Record<string, unknown>,
+  decision: CompactDecisionInput,
+): CompactDecisionInput {
+  const tiedCandidateRepos = tiedCandidateRepositoryGroup(evidence, decision);
+  return tiedCandidateRepos ? { ...decision, tiedCandidateRepos } : decision;
+}

package/src/trace/{019-trace-edge-semantics.ts → trace-edge-semantics.ts}

@@ -1,7 +1,8 @@
 import type { TraceEdge } from '../types.js';
-import type { CompactSemanticEndpoint, CompactStatus } from './014-compact-contract.js';
+import type { CompactSemanticEndpoint, CompactStatus } from './compact-contract.js';
 import {
   compactDecisionFromEvidence,
+  compactEvidenceReasonCode,
   compactEventStatus,
   compactGraphStatus,
   compactRefs,
@@ -16,8 +17,8 @@ import {
   type SemanticCallRow,
   type SemanticTargetRow,
   type TraceEdgeRecorder,
-} from './015-trace-edge-recorder.js';
-import type { PlannedEventSubscriberTransition } from './011-event-subscriber-traversal.js';
+} from './trace-edge-recorder.js';
+import type { PlannedEventSubscriberTransition } from './event-subscriber-traversal.js';
 import type { DynamicCandidateBranch } from './dynamic-branches.js';
 
 interface ImplementationObservation {
@@ -157,11 +158,11 @@ export function recordOutboundObservation(
     source, target,
     status: compactGraphStatus(input.row, input.evidence,
       input.unresolvedReason, input.dynamicMode),
-    decision: compactDecisionFromEvidence(input.evidence, {
-      reasonCode: input.unresolvedReason
-        ? safeReasonCode(input.evidence.reasonCode, 'outbound_target_unresolved')
-        : undefined,
-    }),
+    decision: compactDecisionFromEvidence(input.evidence,
+      input.unresolvedReason ? {
+        reasonCode: compactEvidenceReasonCode(input.evidence)
+          ?? 'outbound_target_unresolved',
+      } : {}),
     refs: compactRefs({
       graphEdgeId: positiveId(input.evidence.persistedGraphEdgeId),
       outboundCallId: input.call.id,
@@ -295,11 +296,6 @@ function eventSite(
     endOffset: plan.transition.callSiteEndOffset });
 }
 
-function safeReasonCode(value: unknown, fallback: string): string {
-  return typeof value === 'string' && /^[a-z][a-z0-9_.-]{0,79}$/.test(value)
-    ? value : fallback;
-}
-
 function positiveId(value: unknown): number | string | undefined {
   if (typeof value === 'number') return Number.isFinite(value) && value > 0
     ? value : undefined;

package/src/trace/trace-engine.ts

@@ -1,5 +1,5 @@
 import type { Db } from '../db/connection.js';
-import { schemaLifecycleDiagnostic } from '../db/001-fact-lifecycle.js';
+import { schemaLifecycleDiagnostic } from '../db/fact-lifecycle.js';
 import type {
   TraceEdge,
   TraceOptions,
@@ -13,21 +13,21 @@ import {
 import {
   loadTraceDiagnostics,
   prependTraceDiagnostic,
-} from './002-trace-diagnostics.js';
-import { TraversalScopeScheduler } from './010-traversal-scope.js';
-import { createTraceRootPlan } from './013-trace-root-scopes.js';
-import type { CompactTraceObserver } from './014-compact-contract.js';
-import { TraceEdgeRecorder } from './015-trace-edge-recorder.js';
-import type { ImplementationHintOptions } from './025-trace-implementation-scope.js';
+} from './trace-diagnostics.js';
+import { TraversalScopeScheduler } from './traversal-scope.js';
+import { createTraceRootPlan } from './trace-root-scopes.js';
+import type { CompactTraceObserver } from './compact-contract.js';
+import { TraceEdgeRecorder } from './trace-edge-recorder.js';
+import type { ImplementationHintOptions } from './trace-implementation-scope.js';
 import {
   resolveTraceStartScope,
   type TraceStartScope,
-} from './026-trace-start-scope.js';
+} from './trace-start-scope.js';
 import {
   executeTraceScopes,
   type TraceExecutionRuntime,
-} from './027-trace-scope-execution.js';
-import { recordTraceStartImplementation } from './029-trace-start-implementation.js';
+} from './trace-scope-execution.js';
+import { recordTraceStartImplementation } from './trace-start-implementation.js';
 import { selectorNotFoundDiagnostic } from './selectors.js';
 
 const compactObserverKey = Symbol('service-flow.compact-trace-observer');

package/src/trace/{022-trace-fact-preflight.ts → trace-fact-preflight.ts}

@@ -1,6 +1,6 @@
 import type { Db } from '../db/connection.js';
-import { currentFactLifecycleDiagnostic } from '../db/001-fact-lifecycle.js';
-import { resolveTraversalWorkspaceId } from './010-traversal-scope.js';
+import { currentFactLifecycleDiagnostic } from '../db/fact-lifecycle.js';
+import { resolveTraversalWorkspaceId } from './traversal-scope.js';
 
 function workspaceScopeIsAmbiguous(db: Db): boolean {
   const rows = db.prepare(`SELECT DISTINCT workspace_id workspaceId

package/src/trace/{025-trace-implementation-scope.ts → trace-implementation-scope.ts}

@@ -1,6 +1,6 @@
 import type { Db } from '../db/connection.js';
 import type { ImplementationHint } from '../types.js';
-import type { TraceGraphEdgeRow } from './012-trace-graph-lookups.js';
+import type { TraceGraphEdgeRow } from './trace-graph-lookups.js';
 
 export interface ImplementationHintOptions {
   implementationRepo?: string;

package/src/trace/{028-trace-operation-execution.ts → trace-operation-execution.ts}

@@ -1,34 +1,34 @@
 import type { Db } from '../db/connection.js';
 import type { TraceEdge } from '../types.js';
 import { implementationHintDiagnostic } from './implementation-hints.js';
-import { contextualImplementationSelection } from './005-implementation-selection.js';
-import type { ContextBinding } from './008-contextual-runtime-state.js';
+import { contextualImplementationSelection } from './implementation-selection.js';
+import type { ContextBinding } from './contextual-runtime-state.js';
 import {
   handlerMethodNode,
   withSelectedHandlerProvenance,
   type SelectedHandlerEvidence,
-} from './009-selected-handler-provenance.js';
-import type { TraversalScopeState } from './010-traversal-scope.js';
-import type { TraceGraphEdgeRow } from './012-trace-graph-lookups.js';
+} from './selected-handler-provenance.js';
+import type { TraversalScopeState } from './traversal-scope.js';
+import type { TraceGraphEdgeRow } from './trace-graph-lookups.js';
 import {
   enqueueCausalScope,
   type TraceQueueScope,
-} from './013-trace-root-scopes.js';
-import { parseTraceEvidence } from './017-trace-context.js';
+} from './trace-root-scopes.js';
+import { parseTraceEvidence } from './trace-context.js';
 import {
   recordCycleObservation,
   recordImplementationObservation,
-} from './019-trace-edge-semantics.js';
+} from './trace-edge-semantics.js';
 import {
   handlerFilesForOperation,
   handlerScope,
   implementationScope,
-} from './025-trace-implementation-scope.js';
+} from './trace-implementation-scope.js';
 import type {
   CallRow,
   EffectiveOutbound,
   TraceExecutionRuntime,
-} from './027-trace-scope-execution.js';
+} from './trace-scope-execution.js';
 
 interface OperationSelection {
   implementation: ReturnType<typeof implementationScope>;

package/src/trace/{013-trace-root-scopes.ts → trace-root-scopes.ts}

@@ -1,11 +1,11 @@
 import type { Db } from '../db/connection.js';
-import { currentFactLifecycleDiagnostic } from '../db/001-fact-lifecycle.js';
-import type { ContextBinding } from './008-contextual-runtime-state.js';
+import { currentFactLifecycleDiagnostic } from '../db/fact-lifecycle.js';
+import type { ContextBinding } from './contextual-runtime-state.js';
 import {
   resolveTraversalWorkspaceId,
   type TraversalScopeScheduler,
   type TraversalScopeState,
-} from './010-traversal-scope.js';
+} from './traversal-scope.js';
 
 export interface TraceQueueScope {
   repoId?: number;
@@ -253,12 +253,11 @@ function hasExactDispatch(db: Db, calls: RootCallRow[]): boolean {
           AND subscriber.generation=emitted.generation
           AND subscriber.edge_type='EVENT_SUBSCRIPTION_HANDLED_BY'
           AND subscriber.from_kind='event'
-          AND subscriber.from_id COLLATE BINARY=? COLLATE BINARY)
+          AND subscriber.from_id COLLATE BINARY=emitted.to_id COLLATE BINARY)
     LIMIT 1`);
   return calls.some((call) => call.callType === 'async_emit'
-    && typeof call.eventName === 'string'
     && Boolean(match.get(call.workspaceId, call.graphGeneration,
-      String(call.id), call.eventName)));
+      String(call.id))));
 }
 
 function workspaceAmbiguityDiagnostic(db: Db): Record<string, unknown> {

package/src/trace/{027-trace-scope-execution.ts → trace-scope-execution.ts}

@@ -12,36 +12,32 @@ import {
   type ContextBinding,
   type ContextualGraphRow,
   type ContextualRuntimeResolution,
-} from './008-contextual-runtime-state.js';
+} from './contextual-runtime-state.js';
 import {
   TraversalScopeScheduler,
   type TraversalScopeState,
-} from './010-traversal-scope.js';
-import {
-  planEventSubscriberTransitions,
-  type PlannedEventSubscriberTransition,
-} from './011-event-subscriber-traversal.js';
+} from './traversal-scope.js';
+import type { PlannedEventSubscriberTransition } from './event-subscriber-traversal.js';
 import {
   graphForCalls,
   operationNode,
   symbolNode,
   type TraceGraphEdgeRow,
-} from './012-trace-graph-lookups.js';
+} from './trace-graph-lookups.js';
 import {
   enqueueCausalScope,
   nextPendingRoot,
   type PendingTraceRootScope,
   type TraceQueueScope,
-} from './013-trace-root-scopes.js';
-import type { CompactSemanticEndpoint } from './014-compact-contract.js';
-import { TraceEdgeRecorder } from './015-trace-edge-recorder.js';
+} from './trace-root-scopes.js';
+import type { CompactSemanticEndpoint } from './compact-contract.js';
+import { TraceEdgeRecorder } from './trace-edge-recorder.js';
 import {
-  contextForSymbolCall,
   knownBindingsForCalls,
   knownBindingsForScope,
   parseTraceEvidence,
   receiverFromTraceEvidence,
-} from './017-trace-context.js';
+} from './trace-context.js';
 import {
   recordCycleObservation,
   recordDynamicBranchObservation,
@@ -49,10 +45,12 @@ import {
   recordEventCycleObservation,
   recordLocalCallObservation,
   recordOutboundObservation,
-} from './019-trace-edge-semantics.js';
-import { outboundScopeSymbolIds } from './023-nested-event-scopes.js';
-import type { ImplementationHintOptions } from './025-trace-implementation-scope.js';
-import { processOperationTarget } from './028-trace-operation-execution.js';
+} from './trace-edge-semantics.js';
+import { outboundScopeSymbolIds } from './nested-event-scopes.js';
+import type { ImplementationHintOptions } from './trace-implementation-scope.js';
+import { processOperationTarget } from './trace-operation-execution.js';
+import { runtimeEventResolution, runtimeEventSubscriberPlans } from './event-runtime-resolution.js';
+import { planLocalCallExpansion } from './local-call-expansion.js';
 
 export interface CallRow extends Record<string, unknown> {
   id: number;
@@ -226,20 +224,10 @@ function processLocalCall(
   bindings: Map<string, ContextBinding>,
   row: Record<string, unknown>,
 ): void {
-  if (!row.callee_symbol_id) return;
-  const symbolId = Number(row.callee_symbol_id);
-  const symbols = new Set([symbolId]);
-  const files = new Set([String(row.calleeFile)]);
-  const repoId = Number(row.calleeRepoId);
-  const context = contextForSymbolCall(runtime.db, row, bindings);
-  const scheduling = runtime.scheduler.schedule({
-    workspaceId: runtime.workspaceId,
-    repoId,
-    files,
-    symbolIds: symbols,
-    context,
-  }, current.state);
-  const node = symbolNode(runtime.db, symbolId);
+  const symbolId = row.callee_symbol_id
+    ? Number(row.callee_symbol_id) : undefined;
+  const node = symbolId === undefined
+    ? undefined : symbolNode(runtime.db, symbolId);
   if (node) runtime.nodes.set(String(node.id), node);
   const evidence = localCallEvidence(row, node);
   const unresolvedReason = localCallUnresolvedReason(row);
@@ -247,6 +235,12 @@ function processLocalCall(
   const target = recordLocalCallObservation(runtime.recorder, edge, {
     symbolCall: row, evidence, unresolvedReason,
   });
+  if (symbolId === undefined || row.status !== 'resolved' || !node) return;
+  const { repoId, files, symbols, context, scheduling } =
+    planLocalCallExpansion(
+      runtime.db, runtime.scheduler, runtime.workspaceId, current.state,
+      row, bindings, symbolId,
+    );
   if (scheduling.kind === 'cycle')
     recordLocalCycle(runtime, current, row, target, scheduling.state,
       repoId, files, symbols);
@@ -291,7 +285,8 @@ function localTraceEdge(
     type: 'local_symbol_call',
     from: String(row.callee_expression),
     to: node?.label
-      ? String(node.label) : `symbol:${String(row.callee_symbol_id)}`,
+      ? String(node.label)
+      : `${String(row.status)}:${String(row.callee_expression)}`,
     evidence,
     confidence: Number(row.confidence ?? 0.8),
     unresolvedReason,
@@ -390,11 +385,12 @@ function recordEffectiveOutbound(
 ): EffectiveOutbound {
   const persisted = parseTraceEvidence(row.evidence_json);
   const raw = baseTraceEvidence(row, call, persisted, contextual.evidence);
-  const effective = runtimeResolution(runtime.db, row, raw, {
-    vars: runtime.options.vars,
-    dynamicMode: runtime.options.dynamicMode ?? 'strict',
-    maxDynamicCandidates: runtime.options.maxDynamicCandidates,
-  }, call.workspaceId, contextual.state);
+  const effective = runtimeEventResolution(row, raw, runtime.options.vars)
+    ?? runtimeResolution(runtime.db, row, raw, {
+      vars: runtime.options.vars,
+      dynamicMode: runtime.options.dynamicMode ?? 'strict',
+      maxDynamicCandidates: runtime.options.maxDynamicCandidates,
+    }, call.workspaceId, contextual.state);
   const target = `${effective.row.to_kind}:${effective.row.to_id}`;
   const operation = effective.row.to_kind === 'operation'
     ? operationNode(runtime.db, effective.row.to_id) : undefined;
@@ -461,15 +457,19 @@ function processEventTransitions(
 ): void {
   if (!runtime.options.includeAsync || call.call_type !== 'async_emit'
     || effective.row.edge_type !== 'HANDLER_EMITS_EVENT'
-    || typeof call.event_name_expr !== 'string') return;
-  const plans = planEventSubscriberTransitions(runtime.db, {
-    workspaceId: runtime.workspaceId ?? call.workspaceId,
-    graphGeneration: call.graphGeneration,
-    eventName: call.event_name_expr,
-  }, runtime.scheduler, current.state, current.depth, runtime.maxDepth);
-  for (const plan of plans)
+    || effective.row.to_kind !== 'event') return;
+  const planned = runtimeEventSubscriberPlans(
+    runtime.db, {
+      workspaceId: runtime.workspaceId ?? call.workspaceId,
+      graphGeneration: call.graphGeneration,
+      eventName: effective.row.to_id,
+      vars: runtime.options.vars ?? {},
+    }, runtime.scheduler, current.state, current.depth, runtime.maxDepth,
+  );
+  if (planned.diagnostic) runtime.diagnostics.push(planned.diagnostic);
+  for (const plan of planned.plans)
     recordEventTransition(runtime, current, plan,
-      effective.semanticWorkspaceId, plans.length);
+      effective.semanticWorkspaceId, planned.plans.length);
 }
 
 function recordEventTransition(

package/src/trace/{029-trace-start-implementation.ts → trace-start-implementation.ts}

@@ -1,22 +1,22 @@
 import type { Db } from '../db/connection.js';
 import type { TraceEdge } from '../types.js';
-import { hintedImplementationSelection } from './005-implementation-selection.js';
+import { hintedImplementationSelection } from './implementation-selection.js';
 import {
   handlerMethodNode,
   withSelectedHandlerProvenance,
   type SelectedHandlerEvidence,
-} from './009-selected-handler-provenance.js';
+} from './selected-handler-provenance.js';
 import {
   operationNode,
   type TraceGraphEdgeRow,
-} from './012-trace-graph-lookups.js';
-import { parseTraceEvidence } from './017-trace-context.js';
-import { recordImplementationObservation } from './019-trace-edge-semantics.js';
+} from './trace-graph-lookups.js';
+import { parseTraceEvidence } from './trace-context.js';
+import { recordImplementationObservation } from './trace-edge-semantics.js';
 import {
   handlerScope,
   implementationScope,
-} from './025-trace-implementation-scope.js';
-import type { TraceExecutionRuntime } from './027-trace-scope-execution.js';
+} from './trace-implementation-scope.js';
+import type { TraceExecutionRuntime } from './trace-scope-execution.js';
 
 interface StartImplementationSelection {
   edge: TraceGraphEdgeRow;