@saptools/service-flow 0.1.69 → 0.1.72

package/src/trace/event-shape-candidate-trace.ts

@@ -0,0 +1,172 @@
+import type { Db } from '../db/connection.js';
+import type { TraceOptions } from '../types.js';
+import {
+  operationNode,
+  symbolNode,
+  type TraceGraphEdgeRow,
+} from './trace-graph-lookups.js';
+import type { TraceGraphRow } from './evidence.js';
+import {
+  eventMissingVariableNames,
+  eventTemplateVariables,
+  parseEventSkeletonFact,
+} from '../utils/event-skeleton.js';
+
+const defaultEventShapeCandidateCap = 5;
+const maximumEventShapeCandidateCap = 50;
+
+function candidateCap(options: TraceOptions): number {
+  const value = options.maxDynamicCandidates
+    ?? defaultEventShapeCandidateCap;
+  if (!Number.isSafeInteger(value) || value < 1)
+    return defaultEventShapeCandidateCap;
+  return Math.min(value, maximumEventShapeCandidateCap);
+}
+
+function withCandidateCounts(
+  row: TraceGraphEdgeRow,
+  total: number,
+  shown: number,
+): TraceGraphEdgeRow {
+  let evidence: Record<string, unknown> = {};
+  try {
+    const parsed: unknown = JSON.parse(row.evidence_json);
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed))
+      evidence = parsed as Record<string, unknown>;
+  } catch {
+    evidence = {};
+  }
+  return {
+    ...row,
+    evidence_json: JSON.stringify({
+      ...evidence,
+      eventShapeCandidateCount: total,
+      shownEventShapeCandidateCount: shown,
+      omittedEventShapeCandidateCount: Math.max(0, total - shown),
+    }),
+  };
+}
+
+export function visibleEventShapeRows(
+  rows: readonly TraceGraphEdgeRow[],
+  options: TraceOptions,
+): TraceGraphEdgeRow[] {
+  const regular = rows.filter((row) =>
+    row.edge_type !== 'EVENT_SHAPE_CANDIDATE_SUBSCRIBER');
+  if ((options.dynamicMode ?? 'strict') !== 'candidates') return regular;
+  const candidates = rows.filter((row) =>
+    row.edge_type === 'EVENT_SHAPE_CANDIDATE_SUBSCRIBER');
+  const shown = candidates.slice(0, candidateCap(options));
+  return [
+    ...regular,
+    ...shown.map((row) =>
+      withCandidateCounts(row, candidates.length, shown.length)),
+  ];
+}
+
+export function outboundTraceEdgeType(
+  call: { call_type: string },
+  row: { edge_type: string; to_kind: string },
+): string {
+  if (row.edge_type === 'EVENT_SHAPE_CANDIDATE_SUBSCRIBER')
+    return 'event_shape_candidate_subscriber';
+  if (row.to_kind === 'operation'
+    && row.edge_type === 'REMOTE_CALL_RESOLVES_TO_OPERATION')
+    return 'remote_action';
+  if (row.to_kind === 'operation'
+    && row.edge_type === 'LOCAL_CALL_RESOLVES_TO_OPERATION')
+    return 'local_service_call';
+  return call.call_type;
+}
+
+export function outboundTraceTargetNode(
+  db: Db,
+  id: string,
+  row: TraceGraphRow,
+): Record<string, unknown> {
+  const operation = row.to_kind === 'operation'
+    ? operationNode(db, row.to_id) : undefined;
+  const candidate = row.edge_type === 'EVENT_SHAPE_CANDIDATE_SUBSCRIBER'
+    ? symbolNode(db, Number(row.to_id)) : undefined;
+  return operation ?? candidate ?? {
+    id,
+    kind: row.to_kind,
+    label: row.to_kind === 'db_entity'
+      ? `Entity: ${row.to_id || 'unknown'}` : row.to_id,
+  };
+}
+
+function stringArray(value: unknown): string[] {
+  return Array.isArray(value)
+    ? value.filter((item): item is string => typeof item === 'string') : [];
+}
+
+function subscriberSkeletons(
+  db: Db,
+  workspaceId: number,
+  publishCallId: number,
+): unknown[] {
+  return db.prepare(`SELECT subscription.event_skeleton_json skeleton
+    FROM outbound_calls publication
+    JOIN repositories publication_repo ON publication_repo.id=publication.repo_id
+    JOIN outbound_calls subscription
+      ON subscription.call_type='async_subscribe'
+      AND subscription.event_skeleton_signature
+        =publication.event_skeleton_signature
+    JOIN repositories subscription_repo
+      ON subscription_repo.id=subscription.repo_id
+      AND subscription_repo.workspace_id=publication_repo.workspace_id
+    WHERE publication.id=? AND publication_repo.workspace_id=?
+      AND publication.event_skeleton_signature IS NOT NULL
+    ORDER BY subscription_repo.name COLLATE BINARY,
+      subscription.repo_id,subscription.source_file COLLATE BINARY,
+      subscription.call_site_start_offset,subscription.id`).all(
+    publishCallId, workspaceId,
+  ).map((row) => row.skeleton);
+}
+
+export function eventShapeMissingVariableEvidence(
+  db: Db,
+  workspaceId: number,
+  publishCallId: number,
+  evidence: Record<string, unknown>,
+  variables: Record<string, string> | undefined,
+): Record<string, unknown> {
+  const current = stringArray(evidence.missingRuntimeVariables);
+  if (current.length === 0) return evidence;
+  const names = new Set(current);
+  let matchingSubscriptions = 0;
+  for (const value of subscriberSkeletons(db, workspaceId, publishCallId)) {
+    const skeleton = parseEventSkeletonFact(value);
+    if (!skeleton?.candidateEligible) continue;
+    matchingSubscriptions += 1;
+    const expanded = eventTemplateVariables(skeleton, variables ?? {});
+    const missing = skeleton.sourceKeys.filter((key) =>
+      !Object.hasOwn(expanded, key));
+    for (const name of eventMissingVariableNames(skeleton, missing))
+      names.add(name);
+  }
+  const missing = [...names].sort((left, right) =>
+    left < right ? -1 : left > right ? 1 : 0);
+  return {
+    ...evidence,
+    missingRuntimeVariables: missing,
+    missingVariableCount: missing.length,
+    eventShapeMatchingSubscriptionCount: matchingSubscriptions,
+  };
+}
+
+export function eventShapeRuntimeEvidence(
+  db: Db,
+  workspaceId: number,
+  callId: number,
+  callType: string,
+  evidence: Record<string, unknown>,
+  variables: Record<string, string> | undefined,
+): Record<string, unknown> {
+  return callType === 'async_emit'
+    ? eventShapeMissingVariableEvidence(
+        db, workspaceId, callId, evidence, variables,
+      )
+    : evidence;
+}

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

@@ -7,7 +7,11 @@ import {
   compareBinary,
   type TraversalScopeScheduler,
   type TraversalScopeState,
-} from './010-traversal-scope.js';
+} from './traversal-scope.js';
+import {
+  eventTemplateVariables,
+  parseEventSkeletonFact,
+} from '../utils/event-skeleton.js';
 
 export type EventSubscriberTransitionStatus =
   | 'resolved'
@@ -96,7 +100,8 @@ export function planEventSubscriberTransitions(
 ): PlannedEventSubscriberTransition[] {
   return loadEventSubscriberTransitions(db, query).map((transition) => {
     const handler = transition.handler;
-    if (!handler) return plannedTransition(transition, 'not_resolved');
+    if (transition.status !== 'resolved' || !handler)
+      return plannedTransition(transition, 'not_resolved');
     if (depth >= maxDepth)
       return plannedTransition(transition, 'depth_limited');
     const state = scheduler.schedule({
@@ -245,13 +250,15 @@ function eventRowForQuery(
   row: Record<string, unknown>,
   query: EventSubscriberTransitionQuery,
 ): Record<string, unknown> | undefined {
+  const exact = exactPersistedEventRow(row, query);
+  if (exact) return exact;
   const variables = query.vars;
-  if (variables === undefined) return exactPersistedEventRow(row, query);
+  if (variables === undefined) return undefined;
   const evidence = parseEvidence(row.evidenceJson);
   const resolution = isRecord(evidence.eventTemplateResolution)
     ? evidence.eventTemplateResolution : {};
   if (typeof resolution.original !== 'string')
-    return exactPersistedEventRow(row, query);
+    return undefined;
   return runtimeMatchedEventRow(
     row, query, evidence, resolution.original, variables,
   );
@@ -272,7 +279,10 @@ function runtimeMatchedEventRow(
   template: string,
   variables: Record<string, string>,
 ): Record<string, unknown> | undefined {
-  const substitution = substituteVariables(template, variables);
+  const skeleton = parseEventSkeletonFact(evidence.eventSkeleton);
+  const substitution = substituteVariables(
+    template, eventTemplateVariables(skeleton, variables),
+  );
   if (substitution.missing.length > 0
     || substitution.effective !== query.eventName) return undefined;
   const resolvedAssociation = evidence.associationStatus === 'resolved';
@@ -295,8 +305,7 @@ export function eventSubscriberMissingVariables(
   db: Db,
   query: EventSubscriberTransitionQuery,
 ): string[] {
-  if (query.vars === undefined) return [];
-  const variables = query.vars;
+  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=?
@@ -311,7 +320,10 @@ export function eventSubscriberMissingVariables(
     const template = typeof resolution.original === 'string'
       ? resolution.original : undefined;
     if (!template) return [];
-    const substitution = substituteVariables(template, variables);
+    const skeleton = parseEventSkeletonFact(evidence.eventSkeleton);
+    const substitution = substituteVariables(
+      template, eventTemplateVariables(skeleton, variables),
+    );
     if (substitution.missing.length === 0
       || matchRuntimeTemplate(
         substitution.effective, query.eventName,

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;
@@ -262,6 +262,8 @@ function runtimeDiagnosticTotals(
     const effective = parseObject(edge.evidence.effectiveResolution);
     if (!['dynamic', 'unresolved', 'ambiguous'].includes(String(effective.status ?? '')))
       continue;
+    for (const key of stringArray(edge.evidence.missingRuntimeVariables))
+      missing.add(key);
     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>))
@@ -648,6 +650,11 @@ function stringValue(value: unknown): string | undefined {
   return typeof value === 'string' ? value : undefined;
 }
 
+function stringArray(value: unknown): string[] {
+  return Array.isArray(value)
+    ? value.filter((item): item is string => typeof item === 'string') : [];
+}
+
 function numeric(value: unknown): number {
   return typeof value === 'number' && Number.isFinite(value) ? value : 0;
 }

package/src/trace/implementation-hints.ts

@@ -1,6 +1,6 @@
 import type { ImplementationHint } from '../types.js';
-import { projectBounded } from '../utils/000-bounded-projection.js';
-import { compareBinary } from './010-traversal-scope.js';
+import { projectBounded } from '../utils/bounded-projection.js';
+import { compareBinary } from './traversal-scope.js';
 
 interface Candidate {
   accepted?: boolean;

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/{031-local-call-expansion.ts → local-call-expansion.ts}

@@ -1,13 +1,13 @@
 import type { Db } from '../db/connection.js';
 import {
   type ContextBinding,
-} from './008-contextual-runtime-state.js';
+} from './contextual-runtime-state.js';
 import {
   type TraversalScheduleDecision,
   type TraversalScopeScheduler,
   type TraversalScopeState,
-} from './010-traversal-scope.js';
-import { contextForSymbolCall } from './017-trace-context.js';
+} from './traversal-scope.js';
+import { contextForSymbolCall } from './trace-context.js';
 
 export interface LocalCallExpansion {
   repoId: number;

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>;

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,13 +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 './021-compact-decision-normalization.js';
+} from './compact-decision-normalization.js';
 
 export interface TraceEdgeSemantics {
   source: CompactSemanticEndpoint;

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

@@ -1,5 +1,5 @@
 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,
@@ -17,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 {

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;

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

@@ -12,32 +12,31 @@ 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 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 {
   knownBindingsForCalls,
   knownBindingsForScope,
   parseTraceEvidence,
   receiverFromTraceEvidence,
-} from './017-trace-context.js';
+} from './trace-context.js';
 import {
   recordCycleObservation,
   recordDynamicBranchObservation,
@@ -45,12 +44,18 @@ 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';
-import { runtimeEventResolution, runtimeEventSubscriberPlans } from './030-event-runtime-resolution.js';
-import { planLocalCallExpansion } from './031-local-call-expansion.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';
+import {
+  eventShapeRuntimeEvidence,
+  outboundTraceEdgeType,
+  outboundTraceTargetNode,
+  visibleEventShapeRows,
+} from './event-shape-candidate-trace.js';
 
 export interface CallRow extends Record<string, unknown> {
   id: number;
@@ -90,16 +95,6 @@ export interface TraceExecutionRuntime {
   recorder: TraceEdgeRecorder;
 }
 
-function traceEdgeType(call: CallRow, row: TraceGraphRow): string {
-  if (row.to_kind === 'operation'
-    && row.edge_type === 'REMOTE_CALL_RESOLVES_TO_OPERATION')
-    return 'remote_action';
-  if (row.to_kind === 'operation'
-    && row.edge_type === 'LOCAL_CALL_RESOLVES_TO_OPERATION')
-    return 'local_service_call';
-  return String(call.call_type);
-}
-
 function includeCall(type: string, options: TraceOptions): boolean {
   if (!options.includeDb && type === 'local_db_query') return false;
   if (!options.includeExternal && type === 'external_http') return false;
@@ -339,7 +334,9 @@ function processOutboundCall(
   const contextual = contextualRuntimeResolution(
     runtime.db, call, bindings.get(receiver), call.workspaceId, persistedRows,
   );
-  const rows = contextual.row ? [contextual.row] : persistedRows;
+  const rows = contextual.row
+    ? [contextual.row]
+    : visibleEventShapeRows(persistedRows, runtime.options);
   for (const row of rows)
     processOutboundRow(runtime, current, call, { ...row }, contextual);
 }
@@ -385,16 +382,23 @@ function recordEffectiveOutbound(
 ): EffectiveOutbound {
   const persisted = parseTraceEvidence(row.evidence_json);
   const raw = baseTraceEvidence(row, call, persisted, contextual.evidence);
-  const effective = runtimeEventResolution(row, raw, runtime.options.vars)
+  const resolved = 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 effective = {
+    ...resolved,
+    evidence: eventShapeRuntimeEvidence(
+      runtime.db, call.workspaceId, call.id, call.call_type,
+      resolved.evidence, runtime.options.vars,
+    ),
+  };
   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;
-  runtime.nodes.set(target, operation ?? targetNode(target, effective.row));
+  runtime.nodes.set(
+    target, outboundTraceTargetNode(runtime.db, target, effective.row),
+  );
   const to = edgeTarget(effective.row, effective.evidence);
   const edge = outboundTraceEdge(
     current.depth, call, effective.row, to,
@@ -418,18 +422,6 @@ function recordEffectiveOutbound(
   };
 }
 
-function targetNode(
-  id: string,
-  row: TraceGraphRow,
-): Record<string, unknown> {
-  return {
-    id,
-    kind: row.to_kind,
-    label: row.to_kind === 'db_entity'
-      ? `Entity: ${row.to_id || 'unknown'}` : row.to_id,
-  };
-}
-
 function outboundTraceEdge(
   depth: number,
   call: CallRow,
@@ -440,7 +432,7 @@ function outboundTraceEdge(
 ): TraceEdge {
   return {
     step: depth,
-    type: traceEdgeType(call, row),
+    type: outboundTraceEdgeType(call, row),
     from: `${call.repoName}:${call.source_file}:${call.source_line}`,
     to,
     evidence,