footprintjs 4.14.0 → 4.15.0

package/CLAUDE.md

@@ -268,6 +268,83 @@ const llmCommit = findCommit(commitLog, 'call-llm', 'adapterRawResponse');
 | `findLastWriter(commitLog, key, beforeIdx?)` | `CommitBundle \| undefined` | Search backwards for who wrote a key |
 | `KeyedRecorder<T>` | abstract class | Base for 1:1 Map-based recorders |
 | `SequenceRecorder<T>` | abstract class | Base for 1:N ordered sequence recorders (has `getEntryRanges()` for O(1) time-travel) |
+| `topologyRecorder()` / `TopologyRecorder` | factory / class | Live composition graph for streaming consumers (subflow nodes + control-flow edges) |
+
+### TopologyRecorder — Composition Graph for Streaming Consumers
+
+**One-liner:** reconstructs a live, queryable mini-flowchart of what your run actually traced, built from the 3 primitive recorder channels during traversal.
+
+**Mental model:**
+
+```
+flowChart() builder      →  STATIC flowchart (design-time definition)
+                                       │
+                                       ▼ executor runs it
+                         Traversal emits events on 3 channels:
+                            Recorder · FlowRecorder · EmitRecorder
+                                       │
+                                       ▼ TopologyRecorder listens
+                         DYNAMIC flowchart (runtime shape):
+                            Nodes = composition points
+                               (subflow / fork-branch / decision-branch)
+                            Edges = transitions
+                               (next / fork / decision / loop)
+                            Queryable any moment — during or after run
+```
+
+**What it IS:**
+- Live composition graph derived from 3 primitive channels
+- Each node = one composition-significant moment (subflow entered, fork child, decision chosen)
+- Each edge = a control-flow transition, timestamped with `runtimeStageId`
+- Works identically during or after a run
+
+**What it ISN'T:**
+- Not a full execution tree — that's `StageContext` / `executor.getSnapshot()`
+- Not per-stage data — that's `MetricRecorder` / custom `KeyedRecorder<T>`
+- Not agent-specific — agentfootprint composes it; footprintjs owns it
+
+**Why live consumers need it:** The executor already has the topology internally (execution tree in `StageContext`). But streaming consumers can't access that tree mid-run — they only see events. `TopologyRecorder` = "the tree, reconstructed from events, live-queryable."
+
+Fills the gap between "post-run snapshot (full tree available)" and "live event stream (only point observations)." Attach once; query `getTopology()` anytime during or after a run.
+
+```typescript
+import { topologyRecorder } from 'footprintjs/trace';
+
+const topo = topologyRecorder();
+executor.attachCombinedRecorder(topo); // auto-routes to FlowRecorder channel
+
+await executor.run({ input });
+
+const { nodes, edges, activeNodeId, rootId } = topo.getTopology();
+topo.getSubflowNodes();          // agent-centric view
+topo.getByKind('fork-branch');   // all parallel branches
+topo.getParallelSiblings(id);    // siblings of a parallel branch
+```
+
+**Three node kinds — complete composition coverage:**
+
+| Kind | Fires on | Represents |
+|---|---|---|
+| `subflow` | `onSubflowEntry` | Mounted subflow boundary (with stable `subflowId`) |
+| `fork-branch` | `onFork` (synthesized one per child) | One branch of a parallel split — works for plain stages AND subflows |
+| `decision-branch` | `onDecision` (synthesized for chosen) | The chosen branch of a conditional |
+
+When a fork-branch or decision-branch target is also a subflow, the subsequent `onSubflowEntry` creates a subflow CHILD of the synthetic node. Layered shape preserves both "who branched" and "what the branch ran."
+
+**Edges:** one per control-flow transition. `edge.kind ∈ 'next' | 'fork-branch' | 'decision-branch' | 'loop-iteration'`. Each carries `at: runtimeStageId` for time correlation.
+
+**Correlation rules:**
+- `onFork({ parent, children })` → N `fork-branch` nodes synthesized up-front; subsequent matching `onSubflowEntry` nests under the right fork-branch
+- `onDecision({ chosen })` → `decision-branch` node synthesized up-front; matching `onSubflowEntry` nests under it
+- Pending correlation clears on `onSubflowExit` so state doesn't leak across scopes
+- `onLoop` → self-edge on the currently-active subflow (synthetic nodes don't participate)
+- Re-entry of same `subflowId` (loop body) disambiguates via `id#n` suffix
+
+**What it does NOT track:** plain sequential stages. Use `MetricRecorder` / `StageContext` for per-stage data. Topology is a graph of control-flow branching, not a full execution tree.
+
+**For downstream libraries:** compose, don't duplicate. An agent-shaped recorder should wrap a `topologyRecorder()` internally and translate topology nodes into agent semantics — not re-implement subflow-stack + fork + decision tracking.
+
+Example: [examples/flow-recorders/06-topology-recorder.ts](examples/flow-recorders/06-topology-recorder.ts)
 
 **Two recorder base classes** — choose based on data shape:
 

package/dist/esm/lib/recorder/TopologyRecorder.js

@@ -0,0 +1,272 @@
+/**
+ * TopologyRecorder — composition graph built during traversal.
+ *
+ * The gap this fills:
+ *   footprintjs fires atomic flow events (onSubflowEntry, onFork, onDecision,
+ *   onLoop) but the accumulated *shape* of a run — who nests inside whom,
+ *   which nodes are parallel siblings vs branches of a decision — is only
+ *   visible post-run via `executor.getSnapshot()` tree-walking.
+ *
+ *   Streaming consumers (live UIs, in-flight debuggers) see only the event
+ *   stream. Every such consumer has to rebuild subflow-stack + fork-map +
+ *   decision-tracker from scratch, usually slightly wrong in different ways.
+ *
+ *   TopologyRecorder is the standard accumulator: one subscription to the
+ *   three primitive channels, one live graph, queryable at any moment during
+ *   or after a run.
+ *
+ * What it records — THREE node kinds for complete composition coverage:
+ *   1. 'subflow'          — via onSubflowEntry (a mounted subflow boundary)
+ *   2. 'fork-branch'      — via onFork (one node per child, synthesized)
+ *   3. 'decision-branch'  — via onDecision (the chosen branch, synthesized)
+ *
+ *   When a fork-branch or decision-branch target IS ALSO a subflow, the
+ *   subsequent onSubflowEntry creates a subflow CHILD of the synthetic node.
+ *   The layered shape preserves both "who branched" and "what the branch ran."
+ *
+ *   Plain sequential stages are NOT nodes — that's StageContext's job.
+ *   Topology is a graph of control-flow branching, not a full execution tree.
+ *
+ * Edges:
+ *   One edge per traversal transition — `kind` matches the child's
+ *   `incomingKind`. A consumer rendering "parallel columns" filters edges
+ *   where `kind === 'fork-branch'` sharing the same `from`.
+ *
+ * @example
+ * ```typescript
+ * import { topologyRecorder } from 'footprintjs/trace';
+ *
+ * const topo = topologyRecorder();
+ * executor.attachCombinedRecorder(topo);  // auto-routes to FlowRecorder channel
+ *
+ * await executor.run();
+ *
+ * const { nodes, edges, activeNodeId, rootId } = topo.getTopology();
+ * // Consumer queries:
+ * topo.getChildren('sf-parent');              // direct children (any kind)
+ * topo.getByKind('fork-branch');              // all parallel branches
+ * topo.getSubflowNodes();                     // only mounted subflows
+ * ```
+ */
+let _counter = 0;
+/**
+ * Factory — matches the `narrative()` / `metrics()` style.
+ */
+export function topologyRecorder(options = {}) {
+    return new TopologyRecorder(options);
+}
+/**
+ * Stateful accumulator that watches FlowRecorder events and maintains a live
+ * composition graph. Attach via `executor.attachCombinedRecorder(recorder)` —
+ * footprintjs detects the `FlowRecorder` method shape and routes events.
+ */
+export class TopologyRecorder {
+    constructor(options = {}) {
+        var _a;
+        this.nodesById = new Map();
+        this.nodeOrder = [];
+        this.edges = [];
+        /** Stack of active SUBFLOW node ids. Fork/decision-branch nodes never push. */
+        this.subflowStack = [];
+        /** Map of childName → pending fork-branch synthetic node, consumed by
+         *  the next matching `onSubflowEntry`. */
+        this.pendingForkByName = new Map();
+        this.id = (_a = options.id) !== null && _a !== void 0 ? _a : `topology-${++_counter}`;
+    }
+    // ── FlowRecorder hooks ────────────────────────────────────────────────
+    onSubflowEntry(event) {
+        var _a, _b;
+        const subflowId = event.subflowId;
+        if (!subflowId)
+            return; // Need a stable id to track.
+        const enteredAt = (_b = (_a = event.traversalContext) === null || _a === void 0 ? void 0 : _a.runtimeStageId) !== null && _b !== void 0 ? _b : '';
+        // Determine the parent: prefer a pending fork/decision match by name,
+        // otherwise the current top-of-subflow-stack.
+        let parentId;
+        let incomingKind;
+        const pendingFork = this.pendingForkByName.get(event.name);
+        if (pendingFork) {
+            parentId = pendingFork.nodeId;
+            incomingKind = 'next'; // Child OF a fork-branch node; the fork semantic
+            // is captured by the fork-branch's own incomingKind.
+            this.pendingForkByName.delete(event.name);
+        }
+        else if (this.pendingDecision && this.pendingDecision.name === event.name) {
+            parentId = this.pendingDecision.nodeId;
+            incomingKind = 'next';
+            this.pendingDecision = undefined;
+        }
+        else {
+            parentId = this.subflowStack[this.subflowStack.length - 1];
+            incomingKind = parentId ? 'next' : 'root';
+        }
+        // Disambiguate re-entry (e.g., loop body re-enters the same subflow).
+        let nodeId = subflowId;
+        if (this.nodesById.has(nodeId)) {
+            let n = 1;
+            while (this.nodesById.has(`${subflowId}#${n}`))
+                n++;
+            nodeId = `${subflowId}#${n}`;
+        }
+        const depth = parentId ? this.nodesById.get(parentId).depth + 1 : 0;
+        const metadata = event.description ? { description: event.description } : undefined;
+        const node = {
+            id: nodeId,
+            kind: 'subflow',
+            name: event.name,
+            parentId,
+            depth,
+            incomingKind,
+            enteredAt,
+            metadata,
+        };
+        this.nodesById.set(nodeId, node);
+        this.nodeOrder.push(nodeId);
+        if (parentId && incomingKind !== 'root') {
+            this.edges.push({
+                from: parentId,
+                to: nodeId,
+                kind: incomingKind,
+                at: enteredAt,
+            });
+        }
+        this.subflowStack.push(nodeId);
+    }
+    onSubflowExit(event) {
+        var _a, _b;
+        const nodeId = this.subflowStack.pop();
+        if (!nodeId)
+            return;
+        const node = this.nodesById.get(nodeId);
+        if (node) {
+            node.exitedAt = (_b = (_a = event.traversalContext) === null || _a === void 0 ? void 0 : _a.runtimeStageId) !== null && _b !== void 0 ? _b : '';
+        }
+        // A subflow exit implies no more children are pending for this scope —
+        // clear stale pending state that belonged to the scope we just left.
+        this.pendingForkByName.clear();
+        this.pendingDecision = undefined;
+    }
+    onFork(event) {
+        var _a, _b;
+        const activeId = this.subflowStack[this.subflowStack.length - 1];
+        const at = (_b = (_a = event.traversalContext) === null || _a === void 0 ? void 0 : _a.runtimeStageId) !== null && _b !== void 0 ? _b : '';
+        const depth = activeId ? this.nodesById.get(activeId).depth + 1 : 0;
+        // Reset any prior pending fork state — a new fork starts fresh.
+        this.pendingForkByName.clear();
+        event.children.forEach((childName, i) => {
+            const nodeId = `fork-${at || event.parent}-${i}-${childName}`;
+            const node = {
+                id: nodeId,
+                kind: 'fork-branch',
+                name: childName,
+                parentId: activeId,
+                depth,
+                incomingKind: 'fork-branch',
+                enteredAt: at,
+                metadata: { forkParent: event.parent },
+            };
+            this.nodesById.set(nodeId, node);
+            this.nodeOrder.push(nodeId);
+            if (activeId) {
+                this.edges.push({ from: activeId, to: nodeId, kind: 'fork-branch', at });
+            }
+            this.pendingForkByName.set(childName, { nodeId, at });
+        });
+    }
+    onDecision(event) {
+        var _a, _b;
+        const activeId = this.subflowStack[this.subflowStack.length - 1];
+        const at = (_b = (_a = event.traversalContext) === null || _a === void 0 ? void 0 : _a.runtimeStageId) !== null && _b !== void 0 ? _b : '';
+        const depth = activeId ? this.nodesById.get(activeId).depth + 1 : 0;
+        // A new decision supersedes any prior unresolved pending one.
+        this.pendingDecision = undefined;
+        const nodeId = `decision-${at || event.decider}-${event.chosen}`;
+        const metadata = { decider: event.decider };
+        if (event.rationale)
+            metadata.rationale = event.rationale;
+        if (event.description)
+            metadata.description = event.description;
+        const node = {
+            id: nodeId,
+            kind: 'decision-branch',
+            name: event.chosen,
+            parentId: activeId,
+            depth,
+            incomingKind: 'decision-branch',
+            enteredAt: at,
+            metadata,
+        };
+        this.nodesById.set(nodeId, node);
+        this.nodeOrder.push(nodeId);
+        if (activeId) {
+            this.edges.push({ from: activeId, to: nodeId, kind: 'decision-branch', at });
+        }
+        this.pendingDecision = { name: event.chosen, nodeId, at };
+    }
+    onLoop(event) {
+        var _a, _b;
+        // loopTo jumps back inside the CURRENT subflow. Record a self-edge on the
+        // active subflow — synthetic fork/decision nodes don't participate in loops.
+        const activeId = this.subflowStack[this.subflowStack.length - 1];
+        if (!activeId)
+            return;
+        this.edges.push({
+            from: activeId,
+            to: activeId,
+            kind: 'loop-iteration',
+            at: (_b = (_a = event.traversalContext) === null || _a === void 0 ? void 0 : _a.runtimeStageId) !== null && _b !== void 0 ? _b : '',
+        });
+    }
+    /** Called by the executor before each `run()` — resets all state. */
+    clear() {
+        this.nodesById.clear();
+        this.nodeOrder.length = 0;
+        this.edges.length = 0;
+        this.subflowStack.length = 0;
+        this.pendingForkByName.clear();
+        this.pendingDecision = undefined;
+    }
+    // ── Query API ─────────────────────────────────────────────────────────
+    /** Live snapshot of the composition graph. Safe during or after a run. */
+    getTopology() {
+        var _a, _b;
+        const nodes = this.nodeOrder.map((id) => this.nodesById.get(id));
+        return {
+            nodes,
+            edges: [...this.edges],
+            activeNodeId: (_a = this.subflowStack[this.subflowStack.length - 1]) !== null && _a !== void 0 ? _a : null,
+            rootId: (_b = this.nodeOrder[0]) !== null && _b !== void 0 ? _b : null,
+        };
+    }
+    /** Direct children of a node — insertion-ordered. */
+    getChildren(nodeId) {
+        return this.nodeOrder.map((id) => this.nodesById.get(id)).filter((n) => n.parentId === nodeId);
+    }
+    /** All nodes of a given kind. */
+    getByKind(kind) {
+        return this.nodeOrder.map((id) => this.nodesById.get(id)).filter((n) => n.kind === kind);
+    }
+    /** All mounted subflow nodes. Convenience for agent-centric views. */
+    getSubflowNodes() {
+        return this.getByKind('subflow');
+    }
+    /** All fork-branch nodes sharing the same parent as `nodeId` — i.e.,
+     *  parallel siblings of a parallel branch. Empty if `nodeId` isn't a
+     *  fork-branch or has no parent. */
+    getParallelSiblings(nodeId) {
+        const node = this.nodesById.get(nodeId);
+        if (!node || node.kind !== 'fork-branch' || !node.parentId)
+            return [];
+        return this.getChildren(node.parentId).filter((n) => n.kind === 'fork-branch');
+    }
+    /** Emit a snapshot bundle for inclusion in `executor.getSnapshot()`. */
+    toSnapshot() {
+        return {
+            name: 'Topology',
+            description: 'Composition graph: subflow boundaries, fork branches, decision branches',
+            preferredOperation: 'translate',
+            data: this.getTopology(),
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"TopologyRecorder.js","sourceRoot":"","sources":["../../../../src/lib/recorder/TopologyRecorder.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * TopologyRecorder — composition graph built during traversal.\n *\n * The gap this fills:\n *   footprintjs fires atomic flow events (onSubflowEntry, onFork, onDecision,\n *   onLoop) but the accumulated *shape* of a run — who nests inside whom,\n *   which nodes are parallel siblings vs branches of a decision — is only\n *   visible post-run via `executor.getSnapshot()` tree-walking.\n *\n *   Streaming consumers (live UIs, in-flight debuggers) see only the event\n *   stream. Every such consumer has to rebuild subflow-stack + fork-map +\n *   decision-tracker from scratch, usually slightly wrong in different ways.\n *\n *   TopologyRecorder is the standard accumulator: one subscription to the\n *   three primitive channels, one live graph, queryable at any moment during\n *   or after a run.\n *\n * What it records — THREE node kinds for complete composition coverage:\n *   1. 'subflow'          — via onSubflowEntry (a mounted subflow boundary)\n *   2. 'fork-branch'      — via onFork (one node per child, synthesized)\n *   3. 'decision-branch'  — via onDecision (the chosen branch, synthesized)\n *\n *   When a fork-branch or decision-branch target IS ALSO a subflow, the\n *   subsequent onSubflowEntry creates a subflow CHILD of the synthetic node.\n *   The layered shape preserves both \"who branched\" and \"what the branch ran.\"\n *\n *   Plain sequential stages are NOT nodes — that's StageContext's job.\n *   Topology is a graph of control-flow branching, not a full execution tree.\n *\n * Edges:\n *   One edge per traversal transition — `kind` matches the child's\n *   `incomingKind`. A consumer rendering \"parallel columns\" filters edges\n *   where `kind === 'fork-branch'` sharing the same `from`.\n *\n * @example\n * ```typescript\n * import { topologyRecorder } from 'footprintjs/trace';\n *\n * const topo = topologyRecorder();\n * executor.attachCombinedRecorder(topo);  // auto-routes to FlowRecorder channel\n *\n * await executor.run();\n *\n * const { nodes, edges, activeNodeId, rootId } = topo.getTopology();\n * // Consumer queries:\n * topo.getChildren('sf-parent');              // direct children (any kind)\n * topo.getByKind('fork-branch');              // all parallel branches\n * topo.getSubflowNodes();                     // only mounted subflows\n * ```\n */\n\nimport type {\n  FlowDecisionEvent,\n  FlowForkEvent,\n  FlowLoopEvent,\n  FlowRecorder,\n  FlowSubflowEvent,\n} from '../engine/narrative/types.js';\n\n/** The kind of composition unit a node represents. */\nexport type TopologyNodeKind = 'subflow' | 'fork-branch' | 'decision-branch';\n\n/** How the traversal reached this node — drives consumer layout decisions. */\nexport type TopologyIncomingKind = 'root' | 'next' | 'fork-branch' | 'decision-branch' | 'loop-iteration';\n\n/** A composition-significant point in the graph. */\nexport interface TopologyNode {\n  /** Unique id. Subflows use their subflowId (with `#n` suffix on re-entry).\n   *  Synthetic nodes (fork-branch / decision-branch) use\n   *  `fork-${runtimeStageId}-${i}` / `decision-${runtimeStageId}` form. */\n  readonly id: string;\n  /** What this node represents. */\n  readonly kind: TopologyNodeKind;\n  /** Display name. For subflows: `FlowSubflowEvent.name`. For fork-branches:\n   *  the child name from `FlowForkEvent.children`. For decision-branches:\n   *  the chosen name from `FlowDecisionEvent.chosen`. */\n  readonly name: string;\n  /** Parent node id. Undefined when this node sits at the run's top level. */\n  readonly parentId?: string;\n  /** Depth in the topology tree (0 = top-level). */\n  readonly depth: number;\n  /** How the traversal reached this node. */\n  readonly incomingKind: TopologyIncomingKind;\n  /** runtimeStageId at the moment the node was created. */\n  readonly enteredAt: string;\n  /** runtimeStageId when the corresponding subflow exited. Only meaningful\n   *  for kind='subflow'; fork/decision-branch nodes are instantaneous. */\n  exitedAt?: string;\n  /** Kind-specific extras: forkParent, decider, rationale, description. */\n  readonly metadata?: Readonly<Record<string, unknown>>;\n}\n\n/** A traversal transition between two nodes. */\nexport interface TopologyEdge {\n  readonly from: string;\n  readonly to: string;\n  readonly kind: Exclude<TopologyIncomingKind, 'root'>;\n  readonly at: string;\n}\n\n/** Snapshot of the composition graph. */\nexport interface Topology {\n  readonly nodes: ReadonlyArray<TopologyNode>;\n  readonly edges: ReadonlyArray<TopologyEdge>;\n  /** Currently-active subflow (top of the subflow stack). Fork-branch and\n   *  decision-branch nodes are instantaneous — they don't affect activeNodeId. */\n  readonly activeNodeId: string | null;\n  /** First node inserted. null before any composition event fires. */\n  readonly rootId: string | null;\n}\n\nexport interface TopologyRecorderOptions {\n  /** Recorder id. Defaults to `topology-N` (auto-incremented). */\n  id?: string;\n}\n\n// Correlation state: maps a pending fork/decision child name to its synthetic\n// node id, so a subsequent onSubflowEntry matching that name can be nested\n// under the synthetic node (rather than creating a peer).\ninterface PendingChild {\n  nodeId: string;\n  at: string;\n}\n\nlet _counter = 0;\n\n/**\n * Factory — matches the `narrative()` / `metrics()` style.\n */\nexport function topologyRecorder(options: TopologyRecorderOptions = {}): TopologyRecorder {\n  return new TopologyRecorder(options);\n}\n\n/**\n * Stateful accumulator that watches FlowRecorder events and maintains a live\n * composition graph. Attach via `executor.attachCombinedRecorder(recorder)` —\n * footprintjs detects the `FlowRecorder` method shape and routes events.\n */\nexport class TopologyRecorder implements FlowRecorder {\n  readonly id: string;\n\n  private readonly nodesById = new Map<string, TopologyNode>();\n  private readonly nodeOrder: string[] = [];\n  private readonly edges: TopologyEdge[] = [];\n  /** Stack of active SUBFLOW node ids. Fork/decision-branch nodes never push. */\n  private readonly subflowStack: string[] = [];\n\n  /** Map of childName → pending fork-branch synthetic node, consumed by\n   *  the next matching `onSubflowEntry`. */\n  private readonly pendingForkByName = new Map<string, PendingChild>();\n  /** Pending decision-branch synthetic node, consumed by a matching entry. */\n  private pendingDecision?: { name: string } & PendingChild;\n\n  constructor(options: TopologyRecorderOptions = {}) {\n    this.id = options.id ?? `topology-${++_counter}`;\n  }\n\n  // ── FlowRecorder hooks ────────────────────────────────────────────────\n\n  onSubflowEntry(event: FlowSubflowEvent): void {\n    const subflowId = event.subflowId;\n    if (!subflowId) return; // Need a stable id to track.\n\n    const enteredAt = event.traversalContext?.runtimeStageId ?? '';\n\n    // Determine the parent: prefer a pending fork/decision match by name,\n    // otherwise the current top-of-subflow-stack.\n    let parentId: string | undefined;\n    let incomingKind: TopologyIncomingKind;\n\n    const pendingFork = this.pendingForkByName.get(event.name);\n    if (pendingFork) {\n      parentId = pendingFork.nodeId;\n      incomingKind = 'next'; // Child OF a fork-branch node; the fork semantic\n      // is captured by the fork-branch's own incomingKind.\n      this.pendingForkByName.delete(event.name);\n    } else if (this.pendingDecision && this.pendingDecision.name === event.name) {\n      parentId = this.pendingDecision.nodeId;\n      incomingKind = 'next';\n      this.pendingDecision = undefined;\n    } else {\n      parentId = this.subflowStack[this.subflowStack.length - 1];\n      incomingKind = parentId ? 'next' : 'root';\n    }\n\n    // Disambiguate re-entry (e.g., loop body re-enters the same subflow).\n    let nodeId = subflowId;\n    if (this.nodesById.has(nodeId)) {\n      let n = 1;\n      while (this.nodesById.has(`${subflowId}#${n}`)) n++;\n      nodeId = `${subflowId}#${n}`;\n    }\n\n    const depth = parentId ? this.nodesById.get(parentId)!.depth + 1 : 0;\n    const metadata = event.description ? { description: event.description } : undefined;\n\n    const node: TopologyNode = {\n      id: nodeId,\n      kind: 'subflow',\n      name: event.name,\n      parentId,\n      depth,\n      incomingKind,\n      enteredAt,\n      metadata,\n    };\n    this.nodesById.set(nodeId, node);\n    this.nodeOrder.push(nodeId);\n\n    if (parentId && incomingKind !== 'root') {\n      this.edges.push({\n        from: parentId,\n        to: nodeId,\n        kind: incomingKind,\n        at: enteredAt,\n      });\n    }\n\n    this.subflowStack.push(nodeId);\n  }\n\n  onSubflowExit(event: FlowSubflowEvent): void {\n    const nodeId = this.subflowStack.pop();\n    if (!nodeId) return;\n    const node = this.nodesById.get(nodeId);\n    if (node) {\n      node.exitedAt = event.traversalContext?.runtimeStageId ?? '';\n    }\n    // A subflow exit implies no more children are pending for this scope —\n    // clear stale pending state that belonged to the scope we just left.\n    this.pendingForkByName.clear();\n    this.pendingDecision = undefined;\n  }\n\n  onFork(event: FlowForkEvent): void {\n    const activeId = this.subflowStack[this.subflowStack.length - 1];\n    const at = event.traversalContext?.runtimeStageId ?? '';\n    const depth = activeId ? this.nodesById.get(activeId)!.depth + 1 : 0;\n\n    // Reset any prior pending fork state — a new fork starts fresh.\n    this.pendingForkByName.clear();\n\n    event.children.forEach((childName, i) => {\n      const nodeId = `fork-${at || event.parent}-${i}-${childName}`;\n      const node: TopologyNode = {\n        id: nodeId,\n        kind: 'fork-branch',\n        name: childName,\n        parentId: activeId,\n        depth,\n        incomingKind: 'fork-branch',\n        enteredAt: at,\n        metadata: { forkParent: event.parent },\n      };\n      this.nodesById.set(nodeId, node);\n      this.nodeOrder.push(nodeId);\n      if (activeId) {\n        this.edges.push({ from: activeId, to: nodeId, kind: 'fork-branch', at });\n      }\n      this.pendingForkByName.set(childName, { nodeId, at });\n    });\n  }\n\n  onDecision(event: FlowDecisionEvent): void {\n    const activeId = this.subflowStack[this.subflowStack.length - 1];\n    const at = event.traversalContext?.runtimeStageId ?? '';\n    const depth = activeId ? this.nodesById.get(activeId)!.depth + 1 : 0;\n\n    // A new decision supersedes any prior unresolved pending one.\n    this.pendingDecision = undefined;\n\n    const nodeId = `decision-${at || event.decider}-${event.chosen}`;\n    const metadata: Record<string, unknown> = { decider: event.decider };\n    if (event.rationale) metadata.rationale = event.rationale;\n    if (event.description) metadata.description = event.description;\n\n    const node: TopologyNode = {\n      id: nodeId,\n      kind: 'decision-branch',\n      name: event.chosen,\n      parentId: activeId,\n      depth,\n      incomingKind: 'decision-branch',\n      enteredAt: at,\n      metadata,\n    };\n    this.nodesById.set(nodeId, node);\n    this.nodeOrder.push(nodeId);\n    if (activeId) {\n      this.edges.push({ from: activeId, to: nodeId, kind: 'decision-branch', at });\n    }\n    this.pendingDecision = { name: event.chosen, nodeId, at };\n  }\n\n  onLoop(event: FlowLoopEvent): void {\n    // loopTo jumps back inside the CURRENT subflow. Record a self-edge on the\n    // active subflow — synthetic fork/decision nodes don't participate in loops.\n    const activeId = this.subflowStack[this.subflowStack.length - 1];\n    if (!activeId) return;\n    this.edges.push({\n      from: activeId,\n      to: activeId,\n      kind: 'loop-iteration',\n      at: event.traversalContext?.runtimeStageId ?? '',\n    });\n  }\n\n  /** Called by the executor before each `run()` — resets all state. */\n  clear(): void {\n    this.nodesById.clear();\n    this.nodeOrder.length = 0;\n    this.edges.length = 0;\n    this.subflowStack.length = 0;\n    this.pendingForkByName.clear();\n    this.pendingDecision = undefined;\n  }\n\n  // ── Query API ─────────────────────────────────────────────────────────\n\n  /** Live snapshot of the composition graph. Safe during or after a run. */\n  getTopology(): Topology {\n    const nodes = this.nodeOrder.map((id) => this.nodesById.get(id)!);\n    return {\n      nodes,\n      edges: [...this.edges],\n      activeNodeId: this.subflowStack[this.subflowStack.length - 1] ?? null,\n      rootId: this.nodeOrder[0] ?? null,\n    };\n  }\n\n  /** Direct children of a node — insertion-ordered. */\n  getChildren(nodeId: string): TopologyNode[] {\n    return this.nodeOrder.map((id) => this.nodesById.get(id)!).filter((n) => n.parentId === nodeId);\n  }\n\n  /** All nodes of a given kind. */\n  getByKind(kind: TopologyNodeKind): TopologyNode[] {\n    return this.nodeOrder.map((id) => this.nodesById.get(id)!).filter((n) => n.kind === kind);\n  }\n\n  /** All mounted subflow nodes. Convenience for agent-centric views. */\n  getSubflowNodes(): TopologyNode[] {\n    return this.getByKind('subflow');\n  }\n\n  /** All fork-branch nodes sharing the same parent as `nodeId` — i.e.,\n   *  parallel siblings of a parallel branch. Empty if `nodeId` isn't a\n   *  fork-branch or has no parent. */\n  getParallelSiblings(nodeId: string): TopologyNode[] {\n    const node = this.nodesById.get(nodeId);\n    if (!node || node.kind !== 'fork-branch' || !node.parentId) return [];\n    return this.getChildren(node.parentId).filter((n) => n.kind === 'fork-branch');\n  }\n\n  /** Emit a snapshot bundle for inclusion in `executor.getSnapshot()`. */\n  toSnapshot() {\n    return {\n      name: 'Topology',\n      description: 'Composition graph: subflow boundaries, fork branches, decision branches',\n      preferredOperation: 'translate' as const,\n      data: this.getTopology(),\n    };\n  }\n}\n"]}

package/dist/esm/trace.js

@@ -28,6 +28,7 @@ export { causalChain, flattenCausalDAG, formatCausalChain } from './lib/memory/b
 export { KeyedRecorder } from './lib/recorder/KeyedRecorder.js';
 // SequenceRecorder — base class for 1:N ordered sequence recorders with keyed index
 export { SequenceRecorder } from './lib/recorder/SequenceRecorder.js';
+export { TopologyRecorder, topologyRecorder } from './lib/recorder/TopologyRecorder.js';
 export { QualityRecorder } from './lib/recorder/QualityRecorder.js';
 export { formatQualityTrace, qualityTrace } from './lib/recorder/qualityTrace.js';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/recorder/TopologyRecorder.js

@@ -0,0 +1,277 @@
+"use strict";
+/**
+ * TopologyRecorder — composition graph built during traversal.
+ *
+ * The gap this fills:
+ *   footprintjs fires atomic flow events (onSubflowEntry, onFork, onDecision,
+ *   onLoop) but the accumulated *shape* of a run — who nests inside whom,
+ *   which nodes are parallel siblings vs branches of a decision — is only
+ *   visible post-run via `executor.getSnapshot()` tree-walking.
+ *
+ *   Streaming consumers (live UIs, in-flight debuggers) see only the event
+ *   stream. Every such consumer has to rebuild subflow-stack + fork-map +
+ *   decision-tracker from scratch, usually slightly wrong in different ways.
+ *
+ *   TopologyRecorder is the standard accumulator: one subscription to the
+ *   three primitive channels, one live graph, queryable at any moment during
+ *   or after a run.
+ *
+ * What it records — THREE node kinds for complete composition coverage:
+ *   1. 'subflow'          — via onSubflowEntry (a mounted subflow boundary)
+ *   2. 'fork-branch'      — via onFork (one node per child, synthesized)
+ *   3. 'decision-branch'  — via onDecision (the chosen branch, synthesized)
+ *
+ *   When a fork-branch or decision-branch target IS ALSO a subflow, the
+ *   subsequent onSubflowEntry creates a subflow CHILD of the synthetic node.
+ *   The layered shape preserves both "who branched" and "what the branch ran."
+ *
+ *   Plain sequential stages are NOT nodes — that's StageContext's job.
+ *   Topology is a graph of control-flow branching, not a full execution tree.
+ *
+ * Edges:
+ *   One edge per traversal transition — `kind` matches the child's
+ *   `incomingKind`. A consumer rendering "parallel columns" filters edges
+ *   where `kind === 'fork-branch'` sharing the same `from`.
+ *
+ * @example
+ * ```typescript
+ * import { topologyRecorder } from 'footprintjs/trace';
+ *
+ * const topo = topologyRecorder();
+ * executor.attachCombinedRecorder(topo);  // auto-routes to FlowRecorder channel
+ *
+ * await executor.run();
+ *
+ * const { nodes, edges, activeNodeId, rootId } = topo.getTopology();
+ * // Consumer queries:
+ * topo.getChildren('sf-parent');              // direct children (any kind)
+ * topo.getByKind('fork-branch');              // all parallel branches
+ * topo.getSubflowNodes();                     // only mounted subflows
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TopologyRecorder = exports.topologyRecorder = void 0;
+let _counter = 0;
+/**
+ * Factory — matches the `narrative()` / `metrics()` style.
+ */
+function topologyRecorder(options = {}) {
+    return new TopologyRecorder(options);
+}
+exports.topologyRecorder = topologyRecorder;
+/**
+ * Stateful accumulator that watches FlowRecorder events and maintains a live
+ * composition graph. Attach via `executor.attachCombinedRecorder(recorder)` —
+ * footprintjs detects the `FlowRecorder` method shape and routes events.
+ */
+class TopologyRecorder {
+    constructor(options = {}) {
+        var _a;
+        this.nodesById = new Map();
+        this.nodeOrder = [];
+        this.edges = [];
+        /** Stack of active SUBFLOW node ids. Fork/decision-branch nodes never push. */
+        this.subflowStack = [];
+        /** Map of childName → pending fork-branch synthetic node, consumed by
+         *  the next matching `onSubflowEntry`. */
+        this.pendingForkByName = new Map();
+        this.id = (_a = options.id) !== null && _a !== void 0 ? _a : `topology-${++_counter}`;
+    }
+    // ── FlowRecorder hooks ────────────────────────────────────────────────
+    onSubflowEntry(event) {
+        var _a, _b;
+        const subflowId = event.subflowId;
+        if (!subflowId)
+            return; // Need a stable id to track.
+        const enteredAt = (_b = (_a = event.traversalContext) === null || _a === void 0 ? void 0 : _a.runtimeStageId) !== null && _b !== void 0 ? _b : '';
+        // Determine the parent: prefer a pending fork/decision match by name,
+        // otherwise the current top-of-subflow-stack.
+        let parentId;
+        let incomingKind;
+        const pendingFork = this.pendingForkByName.get(event.name);
+        if (pendingFork) {
+            parentId = pendingFork.nodeId;
+            incomingKind = 'next'; // Child OF a fork-branch node; the fork semantic
+            // is captured by the fork-branch's own incomingKind.
+            this.pendingForkByName.delete(event.name);
+        }
+        else if (this.pendingDecision && this.pendingDecision.name === event.name) {
+            parentId = this.pendingDecision.nodeId;
+            incomingKind = 'next';
+            this.pendingDecision = undefined;
+        }
+        else {
+            parentId = this.subflowStack[this.subflowStack.length - 1];
+            incomingKind = parentId ? 'next' : 'root';
+        }
+        // Disambiguate re-entry (e.g., loop body re-enters the same subflow).
+        let nodeId = subflowId;
+        if (this.nodesById.has(nodeId)) {
+            let n = 1;
+            while (this.nodesById.has(`${subflowId}#${n}`))
+                n++;
+            nodeId = `${subflowId}#${n}`;
+        }
+        const depth = parentId ? this.nodesById.get(parentId).depth + 1 : 0;
+        const metadata = event.description ? { description: event.description } : undefined;
+        const node = {
+            id: nodeId,
+            kind: 'subflow',
+            name: event.name,
+            parentId,
+            depth,
+            incomingKind,
+            enteredAt,
+            metadata,
+        };
+        this.nodesById.set(nodeId, node);
+        this.nodeOrder.push(nodeId);
+        if (parentId && incomingKind !== 'root') {
+            this.edges.push({
+                from: parentId,
+                to: nodeId,
+                kind: incomingKind,
+                at: enteredAt,
+            });
+        }
+        this.subflowStack.push(nodeId);
+    }
+    onSubflowExit(event) {
+        var _a, _b;
+        const nodeId = this.subflowStack.pop();
+        if (!nodeId)
+            return;
+        const node = this.nodesById.get(nodeId);
+        if (node) {
+            node.exitedAt = (_b = (_a = event.traversalContext) === null || _a === void 0 ? void 0 : _a.runtimeStageId) !== null && _b !== void 0 ? _b : '';
+        }
+        // A subflow exit implies no more children are pending for this scope —
+        // clear stale pending state that belonged to the scope we just left.
+        this.pendingForkByName.clear();
+        this.pendingDecision = undefined;
+    }
+    onFork(event) {
+        var _a, _b;
+        const activeId = this.subflowStack[this.subflowStack.length - 1];
+        const at = (_b = (_a = event.traversalContext) === null || _a === void 0 ? void 0 : _a.runtimeStageId) !== null && _b !== void 0 ? _b : '';
+        const depth = activeId ? this.nodesById.get(activeId).depth + 1 : 0;
+        // Reset any prior pending fork state — a new fork starts fresh.
+        this.pendingForkByName.clear();
+        event.children.forEach((childName, i) => {
+            const nodeId = `fork-${at || event.parent}-${i}-${childName}`;
+            const node = {
+                id: nodeId,
+                kind: 'fork-branch',
+                name: childName,
+                parentId: activeId,
+                depth,
+                incomingKind: 'fork-branch',
+                enteredAt: at,
+                metadata: { forkParent: event.parent },
+            };
+            this.nodesById.set(nodeId, node);
+            this.nodeOrder.push(nodeId);
+            if (activeId) {
+                this.edges.push({ from: activeId, to: nodeId, kind: 'fork-branch', at });
+            }
+            this.pendingForkByName.set(childName, { nodeId, at });
+        });
+    }
+    onDecision(event) {
+        var _a, _b;
+        const activeId = this.subflowStack[this.subflowStack.length - 1];
+        const at = (_b = (_a = event.traversalContext) === null || _a === void 0 ? void 0 : _a.runtimeStageId) !== null && _b !== void 0 ? _b : '';
+        const depth = activeId ? this.nodesById.get(activeId).depth + 1 : 0;
+        // A new decision supersedes any prior unresolved pending one.
+        this.pendingDecision = undefined;
+        const nodeId = `decision-${at || event.decider}-${event.chosen}`;
+        const metadata = { decider: event.decider };
+        if (event.rationale)
+            metadata.rationale = event.rationale;
+        if (event.description)
+            metadata.description = event.description;
+        const node = {
+            id: nodeId,
+            kind: 'decision-branch',
+            name: event.chosen,
+            parentId: activeId,
+            depth,
+            incomingKind: 'decision-branch',
+            enteredAt: at,
+            metadata,
+        };
+        this.nodesById.set(nodeId, node);
+        this.nodeOrder.push(nodeId);
+        if (activeId) {
+            this.edges.push({ from: activeId, to: nodeId, kind: 'decision-branch', at });
+        }
+        this.pendingDecision = { name: event.chosen, nodeId, at };
+    }
+    onLoop(event) {
+        var _a, _b;
+        // loopTo jumps back inside the CURRENT subflow. Record a self-edge on the
+        // active subflow — synthetic fork/decision nodes don't participate in loops.
+        const activeId = this.subflowStack[this.subflowStack.length - 1];
+        if (!activeId)
+            return;
+        this.edges.push({
+            from: activeId,
+            to: activeId,
+            kind: 'loop-iteration',
+            at: (_b = (_a = event.traversalContext) === null || _a === void 0 ? void 0 : _a.runtimeStageId) !== null && _b !== void 0 ? _b : '',
+        });
+    }
+    /** Called by the executor before each `run()` — resets all state. */
+    clear() {
+        this.nodesById.clear();
+        this.nodeOrder.length = 0;
+        this.edges.length = 0;
+        this.subflowStack.length = 0;
+        this.pendingForkByName.clear();
+        this.pendingDecision = undefined;
+    }
+    // ── Query API ─────────────────────────────────────────────────────────
+    /** Live snapshot of the composition graph. Safe during or after a run. */
+    getTopology() {
+        var _a, _b;
+        const nodes = this.nodeOrder.map((id) => this.nodesById.get(id));
+        return {
+            nodes,
+            edges: [...this.edges],
+            activeNodeId: (_a = this.subflowStack[this.subflowStack.length - 1]) !== null && _a !== void 0 ? _a : null,
+            rootId: (_b = this.nodeOrder[0]) !== null && _b !== void 0 ? _b : null,
+        };
+    }
+    /** Direct children of a node — insertion-ordered. */
+    getChildren(nodeId) {
+        return this.nodeOrder.map((id) => this.nodesById.get(id)).filter((n) => n.parentId === nodeId);
+    }
+    /** All nodes of a given kind. */
+    getByKind(kind) {
+        return this.nodeOrder.map((id) => this.nodesById.get(id)).filter((n) => n.kind === kind);
+    }
+    /** All mounted subflow nodes. Convenience for agent-centric views. */
+    getSubflowNodes() {
+        return this.getByKind('subflow');
+    }
+    /** All fork-branch nodes sharing the same parent as `nodeId` — i.e.,
+     *  parallel siblings of a parallel branch. Empty if `nodeId` isn't a
+     *  fork-branch or has no parent. */
+    getParallelSiblings(nodeId) {
+        const node = this.nodesById.get(nodeId);
+        if (!node || node.kind !== 'fork-branch' || !node.parentId)
+            return [];
+        return this.getChildren(node.parentId).filter((n) => n.kind === 'fork-branch');
+    }
+    /** Emit a snapshot bundle for inclusion in `executor.getSnapshot()`. */
+    toSnapshot() {
+        return {
+            name: 'Topology',
+            description: 'Composition graph: subflow boundaries, fork branches, decision branches',
+            preferredOperation: 'translate',
+            data: this.getTopology(),
+        };
+    }
+}
+exports.TopologyRecorder = TopologyRecorder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"TopologyRecorder.js","sourceRoot":"","sources":["../../../src/lib/recorder/TopologyRecorder.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * TopologyRecorder — composition graph built during traversal.\n *\n * The gap this fills:\n *   footprintjs fires atomic flow events (onSubflowEntry, onFork, onDecision,\n *   onLoop) but the accumulated *shape* of a run — who nests inside whom,\n *   which nodes are parallel siblings vs branches of a decision — is only\n *   visible post-run via `executor.getSnapshot()` tree-walking.\n *\n *   Streaming consumers (live UIs, in-flight debuggers) see only the event\n *   stream. Every such consumer has to rebuild subflow-stack + fork-map +\n *   decision-tracker from scratch, usually slightly wrong in different ways.\n *\n *   TopologyRecorder is the standard accumulator: one subscription to the\n *   three primitive channels, one live graph, queryable at any moment during\n *   or after a run.\n *\n * What it records — THREE node kinds for complete composition coverage:\n *   1. 'subflow'          — via onSubflowEntry (a mounted subflow boundary)\n *   2. 'fork-branch'      — via onFork (one node per child, synthesized)\n *   3. 'decision-branch'  — via onDecision (the chosen branch, synthesized)\n *\n *   When a fork-branch or decision-branch target IS ALSO a subflow, the\n *   subsequent onSubflowEntry creates a subflow CHILD of the synthetic node.\n *   The layered shape preserves both \"who branched\" and \"what the branch ran.\"\n *\n *   Plain sequential stages are NOT nodes — that's StageContext's job.\n *   Topology is a graph of control-flow branching, not a full execution tree.\n *\n * Edges:\n *   One edge per traversal transition — `kind` matches the child's\n *   `incomingKind`. A consumer rendering \"parallel columns\" filters edges\n *   where `kind === 'fork-branch'` sharing the same `from`.\n *\n * @example\n * ```typescript\n * import { topologyRecorder } from 'footprintjs/trace';\n *\n * const topo = topologyRecorder();\n * executor.attachCombinedRecorder(topo);  // auto-routes to FlowRecorder channel\n *\n * await executor.run();\n *\n * const { nodes, edges, activeNodeId, rootId } = topo.getTopology();\n * // Consumer queries:\n * topo.getChildren('sf-parent');              // direct children (any kind)\n * topo.getByKind('fork-branch');              // all parallel branches\n * topo.getSubflowNodes();                     // only mounted subflows\n * ```\n */\n\nimport type {\n  FlowDecisionEvent,\n  FlowForkEvent,\n  FlowLoopEvent,\n  FlowRecorder,\n  FlowSubflowEvent,\n} from '../engine/narrative/types.js';\n\n/** The kind of composition unit a node represents. */\nexport type TopologyNodeKind = 'subflow' | 'fork-branch' | 'decision-branch';\n\n/** How the traversal reached this node — drives consumer layout decisions. */\nexport type TopologyIncomingKind = 'root' | 'next' | 'fork-branch' | 'decision-branch' | 'loop-iteration';\n\n/** A composition-significant point in the graph. */\nexport interface TopologyNode {\n  /** Unique id. Subflows use their subflowId (with `#n` suffix on re-entry).\n   *  Synthetic nodes (fork-branch / decision-branch) use\n   *  `fork-${runtimeStageId}-${i}` / `decision-${runtimeStageId}` form. */\n  readonly id: string;\n  /** What this node represents. */\n  readonly kind: TopologyNodeKind;\n  /** Display name. For subflows: `FlowSubflowEvent.name`. For fork-branches:\n   *  the child name from `FlowForkEvent.children`. For decision-branches:\n   *  the chosen name from `FlowDecisionEvent.chosen`. */\n  readonly name: string;\n  /** Parent node id. Undefined when this node sits at the run's top level. */\n  readonly parentId?: string;\n  /** Depth in the topology tree (0 = top-level). */\n  readonly depth: number;\n  /** How the traversal reached this node. */\n  readonly incomingKind: TopologyIncomingKind;\n  /** runtimeStageId at the moment the node was created. */\n  readonly enteredAt: string;\n  /** runtimeStageId when the corresponding subflow exited. Only meaningful\n   *  for kind='subflow'; fork/decision-branch nodes are instantaneous. */\n  exitedAt?: string;\n  /** Kind-specific extras: forkParent, decider, rationale, description. */\n  readonly metadata?: Readonly<Record<string, unknown>>;\n}\n\n/** A traversal transition between two nodes. */\nexport interface TopologyEdge {\n  readonly from: string;\n  readonly to: string;\n  readonly kind: Exclude<TopologyIncomingKind, 'root'>;\n  readonly at: string;\n}\n\n/** Snapshot of the composition graph. */\nexport interface Topology {\n  readonly nodes: ReadonlyArray<TopologyNode>;\n  readonly edges: ReadonlyArray<TopologyEdge>;\n  /** Currently-active subflow (top of the subflow stack). Fork-branch and\n   *  decision-branch nodes are instantaneous — they don't affect activeNodeId. */\n  readonly activeNodeId: string | null;\n  /** First node inserted. null before any composition event fires. */\n  readonly rootId: string | null;\n}\n\nexport interface TopologyRecorderOptions {\n  /** Recorder id. Defaults to `topology-N` (auto-incremented). */\n  id?: string;\n}\n\n// Correlation state: maps a pending fork/decision child name to its synthetic\n// node id, so a subsequent onSubflowEntry matching that name can be nested\n// under the synthetic node (rather than creating a peer).\ninterface PendingChild {\n  nodeId: string;\n  at: string;\n}\n\nlet _counter = 0;\n\n/**\n * Factory — matches the `narrative()` / `metrics()` style.\n */\nexport function topologyRecorder(options: TopologyRecorderOptions = {}): TopologyRecorder {\n  return new TopologyRecorder(options);\n}\n\n/**\n * Stateful accumulator that watches FlowRecorder events and maintains a live\n * composition graph. Attach via `executor.attachCombinedRecorder(recorder)` —\n * footprintjs detects the `FlowRecorder` method shape and routes events.\n */\nexport class TopologyRecorder implements FlowRecorder {\n  readonly id: string;\n\n  private readonly nodesById = new Map<string, TopologyNode>();\n  private readonly nodeOrder: string[] = [];\n  private readonly edges: TopologyEdge[] = [];\n  /** Stack of active SUBFLOW node ids. Fork/decision-branch nodes never push. */\n  private readonly subflowStack: string[] = [];\n\n  /** Map of childName → pending fork-branch synthetic node, consumed by\n   *  the next matching `onSubflowEntry`. */\n  private readonly pendingForkByName = new Map<string, PendingChild>();\n  /** Pending decision-branch synthetic node, consumed by a matching entry. */\n  private pendingDecision?: { name: string } & PendingChild;\n\n  constructor(options: TopologyRecorderOptions = {}) {\n    this.id = options.id ?? `topology-${++_counter}`;\n  }\n\n  // ── FlowRecorder hooks ────────────────────────────────────────────────\n\n  onSubflowEntry(event: FlowSubflowEvent): void {\n    const subflowId = event.subflowId;\n    if (!subflowId) return; // Need a stable id to track.\n\n    const enteredAt = event.traversalContext?.runtimeStageId ?? '';\n\n    // Determine the parent: prefer a pending fork/decision match by name,\n    // otherwise the current top-of-subflow-stack.\n    let parentId: string | undefined;\n    let incomingKind: TopologyIncomingKind;\n\n    const pendingFork = this.pendingForkByName.get(event.name);\n    if (pendingFork) {\n      parentId = pendingFork.nodeId;\n      incomingKind = 'next'; // Child OF a fork-branch node; the fork semantic\n      // is captured by the fork-branch's own incomingKind.\n      this.pendingForkByName.delete(event.name);\n    } else if (this.pendingDecision && this.pendingDecision.name === event.name) {\n      parentId = this.pendingDecision.nodeId;\n      incomingKind = 'next';\n      this.pendingDecision = undefined;\n    } else {\n      parentId = this.subflowStack[this.subflowStack.length - 1];\n      incomingKind = parentId ? 'next' : 'root';\n    }\n\n    // Disambiguate re-entry (e.g., loop body re-enters the same subflow).\n    let nodeId = subflowId;\n    if (this.nodesById.has(nodeId)) {\n      let n = 1;\n      while (this.nodesById.has(`${subflowId}#${n}`)) n++;\n      nodeId = `${subflowId}#${n}`;\n    }\n\n    const depth = parentId ? this.nodesById.get(parentId)!.depth + 1 : 0;\n    const metadata = event.description ? { description: event.description } : undefined;\n\n    const node: TopologyNode = {\n      id: nodeId,\n      kind: 'subflow',\n      name: event.name,\n      parentId,\n      depth,\n      incomingKind,\n      enteredAt,\n      metadata,\n    };\n    this.nodesById.set(nodeId, node);\n    this.nodeOrder.push(nodeId);\n\n    if (parentId && incomingKind !== 'root') {\n      this.edges.push({\n        from: parentId,\n        to: nodeId,\n        kind: incomingKind,\n        at: enteredAt,\n      });\n    }\n\n    this.subflowStack.push(nodeId);\n  }\n\n  onSubflowExit(event: FlowSubflowEvent): void {\n    const nodeId = this.subflowStack.pop();\n    if (!nodeId) return;\n    const node = this.nodesById.get(nodeId);\n    if (node) {\n      node.exitedAt = event.traversalContext?.runtimeStageId ?? '';\n    }\n    // A subflow exit implies no more children are pending for this scope —\n    // clear stale pending state that belonged to the scope we just left.\n    this.pendingForkByName.clear();\n    this.pendingDecision = undefined;\n  }\n\n  onFork(event: FlowForkEvent): void {\n    const activeId = this.subflowStack[this.subflowStack.length - 1];\n    const at = event.traversalContext?.runtimeStageId ?? '';\n    const depth = activeId ? this.nodesById.get(activeId)!.depth + 1 : 0;\n\n    // Reset any prior pending fork state — a new fork starts fresh.\n    this.pendingForkByName.clear();\n\n    event.children.forEach((childName, i) => {\n      const nodeId = `fork-${at || event.parent}-${i}-${childName}`;\n      const node: TopologyNode = {\n        id: nodeId,\n        kind: 'fork-branch',\n        name: childName,\n        parentId: activeId,\n        depth,\n        incomingKind: 'fork-branch',\n        enteredAt: at,\n        metadata: { forkParent: event.parent },\n      };\n      this.nodesById.set(nodeId, node);\n      this.nodeOrder.push(nodeId);\n      if (activeId) {\n        this.edges.push({ from: activeId, to: nodeId, kind: 'fork-branch', at });\n      }\n      this.pendingForkByName.set(childName, { nodeId, at });\n    });\n  }\n\n  onDecision(event: FlowDecisionEvent): void {\n    const activeId = this.subflowStack[this.subflowStack.length - 1];\n    const at = event.traversalContext?.runtimeStageId ?? '';\n    const depth = activeId ? this.nodesById.get(activeId)!.depth + 1 : 0;\n\n    // A new decision supersedes any prior unresolved pending one.\n    this.pendingDecision = undefined;\n\n    const nodeId = `decision-${at || event.decider}-${event.chosen}`;\n    const metadata: Record<string, unknown> = { decider: event.decider };\n    if (event.rationale) metadata.rationale = event.rationale;\n    if (event.description) metadata.description = event.description;\n\n    const node: TopologyNode = {\n      id: nodeId,\n      kind: 'decision-branch',\n      name: event.chosen,\n      parentId: activeId,\n      depth,\n      incomingKind: 'decision-branch',\n      enteredAt: at,\n      metadata,\n    };\n    this.nodesById.set(nodeId, node);\n    this.nodeOrder.push(nodeId);\n    if (activeId) {\n      this.edges.push({ from: activeId, to: nodeId, kind: 'decision-branch', at });\n    }\n    this.pendingDecision = { name: event.chosen, nodeId, at };\n  }\n\n  onLoop(event: FlowLoopEvent): void {\n    // loopTo jumps back inside the CURRENT subflow. Record a self-edge on the\n    // active subflow — synthetic fork/decision nodes don't participate in loops.\n    const activeId = this.subflowStack[this.subflowStack.length - 1];\n    if (!activeId) return;\n    this.edges.push({\n      from: activeId,\n      to: activeId,\n      kind: 'loop-iteration',\n      at: event.traversalContext?.runtimeStageId ?? '',\n    });\n  }\n\n  /** Called by the executor before each `run()` — resets all state. */\n  clear(): void {\n    this.nodesById.clear();\n    this.nodeOrder.length = 0;\n    this.edges.length = 0;\n    this.subflowStack.length = 0;\n    this.pendingForkByName.clear();\n    this.pendingDecision = undefined;\n  }\n\n  // ── Query API ─────────────────────────────────────────────────────────\n\n  /** Live snapshot of the composition graph. Safe during or after a run. */\n  getTopology(): Topology {\n    const nodes = this.nodeOrder.map((id) => this.nodesById.get(id)!);\n    return {\n      nodes,\n      edges: [...this.edges],\n      activeNodeId: this.subflowStack[this.subflowStack.length - 1] ?? null,\n      rootId: this.nodeOrder[0] ?? null,\n    };\n  }\n\n  /** Direct children of a node — insertion-ordered. */\n  getChildren(nodeId: string): TopologyNode[] {\n    return this.nodeOrder.map((id) => this.nodesById.get(id)!).filter((n) => n.parentId === nodeId);\n  }\n\n  /** All nodes of a given kind. */\n  getByKind(kind: TopologyNodeKind): TopologyNode[] {\n    return this.nodeOrder.map((id) => this.nodesById.get(id)!).filter((n) => n.kind === kind);\n  }\n\n  /** All mounted subflow nodes. Convenience for agent-centric views. */\n  getSubflowNodes(): TopologyNode[] {\n    return this.getByKind('subflow');\n  }\n\n  /** All fork-branch nodes sharing the same parent as `nodeId` — i.e.,\n   *  parallel siblings of a parallel branch. Empty if `nodeId` isn't a\n   *  fork-branch or has no parent. */\n  getParallelSiblings(nodeId: string): TopologyNode[] {\n    const node = this.nodesById.get(nodeId);\n    if (!node || node.kind !== 'fork-branch' || !node.parentId) return [];\n    return this.getChildren(node.parentId).filter((n) => n.kind === 'fork-branch');\n  }\n\n  /** Emit a snapshot bundle for inclusion in `executor.getSnapshot()`. */\n  toSnapshot() {\n    return {\n      name: 'Topology',\n      description: 'Composition graph: subflow boundaries, fork branches, decision branches',\n      preferredOperation: 'translate' as const,\n      data: this.getTopology(),\n    };\n  }\n}\n"]}

package/dist/trace.js

@@ -22,7 +22,7 @@
  * ```
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.qualityTrace = exports.formatQualityTrace = exports.QualityRecorder = exports.SequenceRecorder = exports.KeyedRecorder = exports.formatCausalChain = exports.flattenCausalDAG = exports.causalChain = exports.findLastWriter = exports.findCommits = exports.findCommit = exports.parseRuntimeStageId = exports.createExecutionCounter = exports.buildRuntimeStageId = void 0;
+exports.qualityTrace = exports.formatQualityTrace = exports.QualityRecorder = exports.topologyRecorder = exports.TopologyRecorder = exports.SequenceRecorder = exports.KeyedRecorder = exports.formatCausalChain = exports.flattenCausalDAG = exports.causalChain = exports.findLastWriter = exports.findCommits = exports.findCommit = exports.parseRuntimeStageId = exports.createExecutionCounter = exports.buildRuntimeStageId = void 0;
 var runtimeStageId_js_1 = require("./lib/engine/runtimeStageId.js");
 Object.defineProperty(exports, "buildRuntimeStageId", { enumerable: true, get: function () { return runtimeStageId_js_1.buildRuntimeStageId; } });
 Object.defineProperty(exports, "createExecutionCounter", { enumerable: true, get: function () { return runtimeStageId_js_1.createExecutionCounter; } });
@@ -42,9 +42,12 @@ Object.defineProperty(exports, "KeyedRecorder", { enumerable: true, get: functio
 // SequenceRecorder — base class for 1:N ordered sequence recorders with keyed index
 var SequenceRecorder_js_1 = require("./lib/recorder/SequenceRecorder.js");
 Object.defineProperty(exports, "SequenceRecorder", { enumerable: true, get: function () { return SequenceRecorder_js_1.SequenceRecorder; } });
+var TopologyRecorder_js_1 = require("./lib/recorder/TopologyRecorder.js");
+Object.defineProperty(exports, "TopologyRecorder", { enumerable: true, get: function () { return TopologyRecorder_js_1.TopologyRecorder; } });
+Object.defineProperty(exports, "topologyRecorder", { enumerable: true, get: function () { return TopologyRecorder_js_1.topologyRecorder; } });
 var QualityRecorder_js_1 = require("./lib/recorder/QualityRecorder.js");
 Object.defineProperty(exports, "QualityRecorder", { enumerable: true, get: function () { return QualityRecorder_js_1.QualityRecorder; } });
 var qualityTrace_js_1 = require("./lib/recorder/qualityTrace.js");
 Object.defineProperty(exports, "formatQualityTrace", { enumerable: true, get: function () { return qualityTrace_js_1.formatQualityTrace; } });
 Object.defineProperty(exports, "qualityTrace", { enumerable: true, get: function () { return qualityTrace_js_1.qualityTrace; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/types/lib/recorder/TopologyRecorder.d.ts

@@ -0,0 +1,151 @@
+/**
+ * TopologyRecorder — composition graph built during traversal.
+ *
+ * The gap this fills:
+ *   footprintjs fires atomic flow events (onSubflowEntry, onFork, onDecision,
+ *   onLoop) but the accumulated *shape* of a run — who nests inside whom,
+ *   which nodes are parallel siblings vs branches of a decision — is only
+ *   visible post-run via `executor.getSnapshot()` tree-walking.
+ *
+ *   Streaming consumers (live UIs, in-flight debuggers) see only the event
+ *   stream. Every such consumer has to rebuild subflow-stack + fork-map +
+ *   decision-tracker from scratch, usually slightly wrong in different ways.
+ *
+ *   TopologyRecorder is the standard accumulator: one subscription to the
+ *   three primitive channels, one live graph, queryable at any moment during
+ *   or after a run.
+ *
+ * What it records — THREE node kinds for complete composition coverage:
+ *   1. 'subflow'          — via onSubflowEntry (a mounted subflow boundary)
+ *   2. 'fork-branch'      — via onFork (one node per child, synthesized)
+ *   3. 'decision-branch'  — via onDecision (the chosen branch, synthesized)
+ *
+ *   When a fork-branch or decision-branch target IS ALSO a subflow, the
+ *   subsequent onSubflowEntry creates a subflow CHILD of the synthetic node.
+ *   The layered shape preserves both "who branched" and "what the branch ran."
+ *
+ *   Plain sequential stages are NOT nodes — that's StageContext's job.
+ *   Topology is a graph of control-flow branching, not a full execution tree.
+ *
+ * Edges:
+ *   One edge per traversal transition — `kind` matches the child's
+ *   `incomingKind`. A consumer rendering "parallel columns" filters edges
+ *   where `kind === 'fork-branch'` sharing the same `from`.
+ *
+ * @example
+ * ```typescript
+ * import { topologyRecorder } from 'footprintjs/trace';
+ *
+ * const topo = topologyRecorder();
+ * executor.attachCombinedRecorder(topo);  // auto-routes to FlowRecorder channel
+ *
+ * await executor.run();
+ *
+ * const { nodes, edges, activeNodeId, rootId } = topo.getTopology();
+ * // Consumer queries:
+ * topo.getChildren('sf-parent');              // direct children (any kind)
+ * topo.getByKind('fork-branch');              // all parallel branches
+ * topo.getSubflowNodes();                     // only mounted subflows
+ * ```
+ */
+import type { FlowDecisionEvent, FlowForkEvent, FlowLoopEvent, FlowRecorder, FlowSubflowEvent } from '../engine/narrative/types.js';
+/** The kind of composition unit a node represents. */
+export type TopologyNodeKind = 'subflow' | 'fork-branch' | 'decision-branch';
+/** How the traversal reached this node — drives consumer layout decisions. */
+export type TopologyIncomingKind = 'root' | 'next' | 'fork-branch' | 'decision-branch' | 'loop-iteration';
+/** A composition-significant point in the graph. */
+export interface TopologyNode {
+    /** Unique id. Subflows use their subflowId (with `#n` suffix on re-entry).
+     *  Synthetic nodes (fork-branch / decision-branch) use
+     *  `fork-${runtimeStageId}-${i}` / `decision-${runtimeStageId}` form. */
+    readonly id: string;
+    /** What this node represents. */
+    readonly kind: TopologyNodeKind;
+    /** Display name. For subflows: `FlowSubflowEvent.name`. For fork-branches:
+     *  the child name from `FlowForkEvent.children`. For decision-branches:
+     *  the chosen name from `FlowDecisionEvent.chosen`. */
+    readonly name: string;
+    /** Parent node id. Undefined when this node sits at the run's top level. */
+    readonly parentId?: string;
+    /** Depth in the topology tree (0 = top-level). */
+    readonly depth: number;
+    /** How the traversal reached this node. */
+    readonly incomingKind: TopologyIncomingKind;
+    /** runtimeStageId at the moment the node was created. */
+    readonly enteredAt: string;
+    /** runtimeStageId when the corresponding subflow exited. Only meaningful
+     *  for kind='subflow'; fork/decision-branch nodes are instantaneous. */
+    exitedAt?: string;
+    /** Kind-specific extras: forkParent, decider, rationale, description. */
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+/** A traversal transition between two nodes. */
+export interface TopologyEdge {
+    readonly from: string;
+    readonly to: string;
+    readonly kind: Exclude<TopologyIncomingKind, 'root'>;
+    readonly at: string;
+}
+/** Snapshot of the composition graph. */
+export interface Topology {
+    readonly nodes: ReadonlyArray<TopologyNode>;
+    readonly edges: ReadonlyArray<TopologyEdge>;
+    /** Currently-active subflow (top of the subflow stack). Fork-branch and
+     *  decision-branch nodes are instantaneous — they don't affect activeNodeId. */
+    readonly activeNodeId: string | null;
+    /** First node inserted. null before any composition event fires. */
+    readonly rootId: string | null;
+}
+export interface TopologyRecorderOptions {
+    /** Recorder id. Defaults to `topology-N` (auto-incremented). */
+    id?: string;
+}
+/**
+ * Factory — matches the `narrative()` / `metrics()` style.
+ */
+export declare function topologyRecorder(options?: TopologyRecorderOptions): TopologyRecorder;
+/**
+ * Stateful accumulator that watches FlowRecorder events and maintains a live
+ * composition graph. Attach via `executor.attachCombinedRecorder(recorder)` —
+ * footprintjs detects the `FlowRecorder` method shape and routes events.
+ */
+export declare class TopologyRecorder implements FlowRecorder {
+    readonly id: string;
+    private readonly nodesById;
+    private readonly nodeOrder;
+    private readonly edges;
+    /** Stack of active SUBFLOW node ids. Fork/decision-branch nodes never push. */
+    private readonly subflowStack;
+    /** Map of childName → pending fork-branch synthetic node, consumed by
+     *  the next matching `onSubflowEntry`. */
+    private readonly pendingForkByName;
+    /** Pending decision-branch synthetic node, consumed by a matching entry. */
+    private pendingDecision?;
+    constructor(options?: TopologyRecorderOptions);
+    onSubflowEntry(event: FlowSubflowEvent): void;
+    onSubflowExit(event: FlowSubflowEvent): void;
+    onFork(event: FlowForkEvent): void;
+    onDecision(event: FlowDecisionEvent): void;
+    onLoop(event: FlowLoopEvent): void;
+    /** Called by the executor before each `run()` — resets all state. */
+    clear(): void;
+    /** Live snapshot of the composition graph. Safe during or after a run. */
+    getTopology(): Topology;
+    /** Direct children of a node — insertion-ordered. */
+    getChildren(nodeId: string): TopologyNode[];
+    /** All nodes of a given kind. */
+    getByKind(kind: TopologyNodeKind): TopologyNode[];
+    /** All mounted subflow nodes. Convenience for agent-centric views. */
+    getSubflowNodes(): TopologyNode[];
+    /** All fork-branch nodes sharing the same parent as `nodeId` — i.e.,
+     *  parallel siblings of a parallel branch. Empty if `nodeId` isn't a
+     *  fork-branch or has no parent. */
+    getParallelSiblings(nodeId: string): TopologyNode[];
+    /** Emit a snapshot bundle for inclusion in `executor.getSnapshot()`. */
+    toSnapshot(): {
+        name: string;
+        description: string;
+        preferredOperation: "translate";
+        data: Topology;
+    };
+}

package/dist/types/trace.d.ts

@@ -27,6 +27,8 @@ export type { CausalChainOptions, CausalNode, KeysReadLookup } from './lib/memor
 export { causalChain, flattenCausalDAG, formatCausalChain } from './lib/memory/backtrack.js';
 export { KeyedRecorder } from './lib/recorder/KeyedRecorder.js';
 export { SequenceRecorder } from './lib/recorder/SequenceRecorder.js';
+export type { Topology, TopologyEdge, TopologyIncomingKind, TopologyNode, TopologyRecorderOptions, } from './lib/recorder/TopologyRecorder.js';
+export { TopologyRecorder, topologyRecorder } from './lib/recorder/TopologyRecorder.js';
 export type { QualityEntry, QualityRecorderOptions, QualityScoringFn } from './lib/recorder/QualityRecorder.js';
 export { QualityRecorder } from './lib/recorder/QualityRecorder.js';
 export type { QualityFrame, QualityStackTrace } from './lib/recorder/qualityTrace.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "footprintjs",
-  "version": "4.14.0",
+  "version": "4.15.0",
   "description": "Explainable backend flows — automatic causal traces, decision evidence, and MCP tool generation for AI agents",
   "license": "MIT",
   "author": "Sanjay Krishna Anbalagan",