capdag 0.109.248 → 0.119.263

package/cap-graph-renderer.js

@@ -271,7 +271,11 @@ function buildStylesheet() {
     {
       selector: 'node.show-more',
       style: {
-        'background-color': getCssVar('--graph-bg'),
+        // Use the normal node fill; the dashed border is what
+        // distinguishes a show-more node from a regular cap.
+        // The renderer never reads `--graph-bg` — the graph
+        // canvas background is entirely the host's concern.
+        'background-color': nodeBg,
         'border-style': 'dashed',
         'border-width': '2px',
         'border-color': nodeBorderHighlighted,
@@ -739,7 +743,8 @@ function buildStrandGraphData(data) {
     });
   }
   let edgeCounter = 0;
-  function addEdge(source, target, label, title, fullUrn, edgeClass) {
+  function addEdge(source, target, label, title, fullUrn, edgeClass, meta) {
+    const m = meta || {};
     edges.push({
       id: `strand-edge-${edgeCounter}`,
       source,
@@ -749,9 +754,32 @@ function buildStrandGraphData(data) {
       fullUrn: fullUrn || '',
       edgeClass: edgeClass || '',
       color: edgeHueColor(edgeCounter),
+      // `foreachEntry` flags a cap edge as the first cap entering a
+      // ForEach body (the "phantom direct edge" in plan builder's
+      // terminology). Render-time collapse uses this to relabel the
+      // edge with the cap title + (1→n) marker. Defaults to false.
+      foreachEntry: m.foreachEntry === true,
+      // `singleCapClosedBody` flags a foreach-entry cap edge whose
+      // body is closed by a Collect AND contains exactly one cap.
+      // Such a cap is both the body entry and the body exit; the
+      // render labels the edge with (n→n) to combine iterate+collect.
+      singleCapClosedBody: m.singleCapClosedBody === true,
     });
     edgeCounter++;
   }
+  // Find the most recently added cap edge whose target is `nodeId`
+  // and stamp it with `singleCapClosedBody=true`. Used by the Collect
+  // handler when a closed body has exactly one cap (bodyEntry === bodyExit).
+  function markSingleCapClosedBody(nodeId) {
+    if (!nodeId) return;
+    for (let idx = edges.length - 1; idx >= 0; idx--) {
+      const e = edges[idx];
+      if (e.edgeClass === 'strand-cap-edge' && e.target === nodeId) {
+        e.singleCapClosedBody = true;
+        return;
+      }
+    }
+  }
 
   // Entry node — the strand's source media spec.
   const inputSlotId = 'input_slot';
@@ -768,13 +796,14 @@ function buildStrandGraphData(data) {
   let bodyExit = null;
 
   // Finalize an outer ForEach body when a nested ForEach starts before
-  // the outer's Collect. Mirrors plan_builder.rs:238-289.
+  // the outer's Collect. Mirrors plan_builder.rs:238-289. The render
+  // collapse will later drop the ForEach node and synthesize the
+  // bridging edges, so we only need to emit the plan-builder
+  // topology here.
   function finalizeOuterForEach(outerForEach, outerEntry, outerExit) {
     const outerForEachInput = outerForEach.index === 0
       ? inputSlotId
       : `step_${outerForEach.index - 1}`;
-    // Create the ForEach node + direct edge from its input + iteration
-    // edge into the body's first cap.
     addNode(outerForEach.nodeId, 'for each', '', 'strand-foreach');
     addEdge(outerForEachInput, outerForEach.nodeId, 'for each', 'for each', '', 'strand-iteration');
     addEdge(outerForEach.nodeId, outerEntry, '', '', '', 'strand-iteration');
@@ -790,12 +819,27 @@ function buildStrandGraphData(data) {
       const toCanonical = canonicalMediaUrn(step.to_spec);
       addNode(nodeId, displayNameFor(toCanonical), toCanonical, 'strand-cap');
 
+      // The first cap inside a ForEach body is the "foreach entry"
+      // — its incoming edge crosses the foreach boundary. Strand
+      // mode's render collapse relabels that edge with a (1→n)
+      // cardinality marker regardless of the cap's own sequence
+      // flags, because visually the transition IS the foreach.
+      const isForeachEntry = insideForEachBody !== null && bodyEntry === null;
+
       let label = body.title;
       const cardinality = cardinalityLabel(body.input_is_sequence, body.output_is_sequence);
       if (cardinality !== '1\u21921') {
         label = `${label} (${cardinality})`;
       }
-      addEdge(prevNodeId, nodeId, label, body.title, body.cap_urn, 'strand-cap-edge');
+      addEdge(
+        prevNodeId,
+        nodeId,
+        label,
+        body.title,
+        body.cap_urn,
+        'strand-cap-edge',
+        { foreachEntry: isForeachEntry }
+      );
 
       if (insideForEachBody !== null) {
         if (bodyEntry === null) bodyEntry = nodeId;
@@ -848,13 +892,26 @@ function buildStrandGraphData(data) {
         addNode(nodeId, 'collect', '', 'strand-collect');
         addEdge(exit, nodeId, 'collect', 'collect', '', 'strand-collection');
 
+        // Single-cap closed body: the single cap serves as both the
+        // body entry and the body exit. The render collapse uses
+        // this flag to pick the (n→n) combined cardinality marker
+        // for the entry edge and emit a plain unlabeled connector
+        // for the synthesized exit edge.
+        if (bodyEntry !== null && bodyEntry === bodyExit) {
+          markSingleCapClosedBody(bodyEntry);
+        }
+
         insideForEachBody = null;
         bodyEntry = null;
         bodyExit = null;
         prevNodeId = nodeId;
       } else {
         // Standalone Collect — scalar → list-of-one. Mirrors
-        // plan_builder.rs:333-355.
+        // plan_builder.rs:333-355. There is no enclosing foreach
+        // body, so the preceding cap is NOT flagged as a
+        // foreach-exit; the render-time collapse will synthesize a
+        // plain "collect" marker on the synthesized edge replacing
+        // the dropped Collect node.
         addNode(nodeId, 'collect', '', 'strand-collect');
         addEdge(prevNodeId, nodeId, 'collect', 'collect', '', 'strand-collection');
         prevNodeId = nodeId;
@@ -866,6 +923,10 @@ function buildStrandGraphData(data) {
   });
 
   // Handle unclosed ForEach after the walk. Mirrors plan_builder.rs:362-428.
+  // An unclosed ForEach with a body is NOT marked as `singleCapClosedBody`
+  // because there's no Collect closing it — the body "fans out" but
+  // never converges. The body entry still gets (1→n) on its incoming
+  // edge via the foreachEntry flag set in the Cap handler.
   if (insideForEachBody !== null) {
     const outer = insideForEachBody;
     const hasBodyEntry = bodyEntry !== null;
@@ -892,11 +953,264 @@ function buildStrandGraphData(data) {
   addNode(outputId, displayNameFor(targetSpec), targetSpec, 'strand-target');
   addEdge(prevNodeId, outputId, '', '', '', 'strand-cap-edge');
 
+  // Return the raw plan-builder topology. Strand mode collapses
+  // ForEach/Collect nodes into edge labels at render time (see
+  // `strandCytoscapeElements`); run mode keeps them as explicit
+  // nodes because body replicas anchor at the ForEach/Collect
+  // junctions.
   return { nodes, edges, sourceSpec, targetSpec };
 }
 
-function strandCytoscapeElements(built) {
-  const nodeElements = built.nodes.map(node => ({
+// Transform the plan-builder strand topology into the render shape
+// strand mode actually displays. Pure function; does NOT mutate the
+// input. Run mode bypasses this transform and consumes the raw
+// topology directly (see `runCytoscapeElements`).
+//
+// The display rules (per user spec):
+//
+//   1. ForEach and Collect are NOT rendered as nodes. They're
+//      execution-layer concepts; the visible semantic is carried on
+//      the surrounding cap edges.
+//
+//   2. The first cap edge entering a ForEach body is relabeled to
+//      `<cap_title> (1→n)`. The builder flags those edges with
+//      `foreachEntry: true`. The (1→n) overrides whatever cardinality
+//      the cap's own `input_is_sequence`/`output_is_sequence` would
+//      produce, because visually the transition is the foreach.
+//
+//   3. The last cap edge exiting a ForEach body is replaced by a
+//      synthesized bridging edge labeled `<cap_title> (n→1)` — the
+//      symmetric counterpart of the foreach-entry (1→n) label.
+//      For a single-cap body (same cap is entry and exit) the flag
+//      `singleCapClosedBody` collapses both markers into a single
+//      `(n→n)` label on the entry edge, and the exit side becomes
+//      a plain unlabeled connector.
+//
+//   4. Standalone Collect (not wrapping a ForEach) synthesizes a
+//      plain edge labeled `"collect"` — the Collect is rendered
+//      as a transition, not the preceding cap's own label.
+//
+//   4. If the last cap step's `to_spec` is semantically equivalent
+//      to the strand's `target_spec` (via MediaUrn.isEquivalent),
+//      the separate `output` target node is dropped and the last
+//      cap edge lands on that merged endpoint. Removes the visible
+//      duplicate node.
+function collapseStrandShapeTransitions(built) {
+  const MediaUrn = requireHostDependency('MediaUrn');
+  const foreachCardinality = cardinalityLabel(false, true); // "1→n"
+  const collectCardinality = cardinalityLabel(true, false); // "n→1"
+
+  // Index for lookups.
+  const nodeById = new Map();
+  for (const n of built.nodes) nodeById.set(n.id, n);
+
+  // Step 1: before dropping Collect nodes, synthesize the
+  // bridging edge that replaces each dropped Collect. For a
+  // Collect node C the plan builder produced:
+  //   body_exit → C   (strand-collection, label="collect")
+  //   C → next        (strand-cap-edge, label="")
+  // The collapse drops C and its two touching edges. To preserve
+  // the flow from body_exit to `next`, we synthesize a new edge
+  // body_exit → next. Its label depends on the Collect's
+  // context (determined by inspecting the body_exit cap's own
+  // incoming edge):
+  //
+  //   * Standalone Collect (no enclosing foreach; body_exit is a
+  //     plain cap with no foreach markers): synthesize a plain
+  //     edge labeled "collect" — the Collect itself is the
+  //     transition the user sees.
+  //
+  //   * Closed-body Collect with a single-cap body (the body_exit
+  //     cap edge is flagged `singleCapClosedBody`): synthesize an
+  //     unlabeled connector. The single cap's own entry edge is
+  //     relabeled with (n→n) in step 2 and carries both the
+  //     iterate and collect semantics at once.
+  //
+  //   * Closed-body Collect with a multi-cap body (body_exit cap
+  //     edge is a plain cap edge inside the body, NOT marked as
+  //     foreachEntry or singleCapClosedBody): label the synth
+  //     edge with the body-exit cap's title + (n→1) — the
+  //     symmetric counterpart of the foreach-entry (1→n) label.
+  const synthesizedExitEdges = [];
+  for (const node of built.nodes) {
+    if (node.nodeClass !== 'strand-collect') continue;
+    const incoming = built.edges.filter(e =>
+      e.target === node.id && e.edgeClass === 'strand-collection');
+    const outgoing = built.edges.filter(e =>
+      e.source === node.id && e.edgeClass === 'strand-cap-edge');
+    for (const inEdge of incoming) {
+      for (const outEdge of outgoing) {
+        const bodyExitNodeId = inEdge.source;
+        const bodyExitCapEdge = built.edges.find(e =>
+          e.edgeClass === 'strand-cap-edge' && e.target === bodyExitNodeId);
+        // Is the Collect part of a closed foreach body? A Collect
+        // is "closed" when the body_exit cap is reachable from the
+        // same foreach that the Collect closes. We detect this by
+        // checking whether the Collect's target node has any
+        // incoming iteration edge (i.e. there's a strand-foreach
+        // node whose outgoing iteration reaches the body_exit or
+        // one of its upstream cap nodes). Simpler heuristic that
+        // works for every shape we emit: the body_exit has an
+        // ancestor that is a strand-foreach node.
+        let hasEnclosingForeach = false;
+        {
+          const visited = new Set();
+          const stack = [bodyExitNodeId];
+          while (stack.length > 0) {
+            const cur = stack.pop();
+            if (visited.has(cur)) continue;
+            visited.add(cur);
+            const curNode = built.nodes.find(n => n.id === cur);
+            if (curNode && curNode.nodeClass === 'strand-foreach') {
+              hasEnclosingForeach = true;
+              break;
+            }
+            for (const up of built.edges) {
+              if (up.target === cur) stack.push(up.source);
+            }
+          }
+        }
+        let synthLabel;
+        let synthTitle;
+        let synthFullUrn;
+        if (!hasEnclosingForeach) {
+          // Standalone Collect.
+          synthLabel = 'collect';
+          synthTitle = 'collect';
+          synthFullUrn = '';
+        } else if (bodyExitCapEdge && bodyExitCapEdge.singleCapClosedBody) {
+          // Single-cap closed body. The cap's own entry edge is
+          // relabeled with (n→n) in step 2; the exit side is just
+          // a connector with no duplicate label.
+          synthLabel = '';
+          synthTitle = '';
+          synthFullUrn = '';
+        } else {
+          // Multi-cap closed body. The body_exit cap's own
+          // incoming edge stays unmodified (carrying just the
+          // cap title, no cardinality markers). The synthesized
+          // exit edge carries the (n→1) collect marker.
+          const title = bodyExitCapEdge ? bodyExitCapEdge.title : '';
+          synthLabel = `${title} (${collectCardinality})`;
+          synthTitle = title;
+          synthFullUrn = bodyExitCapEdge ? bodyExitCapEdge.fullUrn : '';
+        }
+        synthesizedExitEdges.push({
+          id: `${node.id}-collapsed-exit-${synthesizedExitEdges.length}`,
+          source: bodyExitNodeId,
+          target: outEdge.target,
+          label: synthLabel,
+          title: synthTitle,
+          fullUrn: synthFullUrn,
+          edgeClass: 'strand-cap-edge',
+          color: bodyExitCapEdge ? bodyExitCapEdge.color : inEdge.color,
+          foreachEntry: false,
+          singleCapClosedBody: false,
+        });
+      }
+    }
+  }
+
+  // Drop all ForEach/Collect nodes and every edge that touches
+  // them (direct, iteration, collection, and the trailing collect
+  // cap-edge connector). The render never shows those nodes.
+  const dropNodeIds = new Set();
+  for (const node of built.nodes) {
+    if (node.nodeClass === 'strand-foreach' || node.nodeClass === 'strand-collect') {
+      dropNodeIds.add(node.id);
+    }
+  }
+  let nodes = built.nodes.filter(n => !dropNodeIds.has(n.id));
+  let edges = built.edges.filter(e =>
+    !dropNodeIds.has(e.source) &&
+    !dropNodeIds.has(e.target) &&
+    e.edgeClass !== 'strand-iteration' &&
+    e.edgeClass !== 'strand-collection');
+  edges = edges.concat(synthesizedExitEdges);
+
+  // Step 2: relabel flagged foreach-entry cap edges with the
+  // cap title + cardinality marker.
+  //
+  // When the body is a single cap (bodyEntry === bodyExit under a
+  // closed Collect), the cap edge has `singleCapClosedBody: true`
+  // and we use (n→n) — the outer sequence is iterated, the cap
+  // runs per-item, and the result is collected back into a
+  // sequence. Otherwise we use plain (1→n) for the foreach entry.
+  const iterAndCollectCardinality = cardinalityLabel(true, true); // "n→n"
+  edges = edges.map(e => {
+    if (e.edgeClass !== 'strand-cap-edge') return e;
+    if (e.foreachEntry && e.singleCapClosedBody) {
+      return Object.assign({}, e, {
+        label: `${e.title} (${iterAndCollectCardinality})`,
+      });
+    }
+    if (e.foreachEntry) {
+      return Object.assign({}, e, {
+        label: `${e.title} (${foreachCardinality})`,
+      });
+    }
+    return e;
+  });
+
+  // Step 3: merge the trailing `step_N → output` edge when step_N
+  // and output represent the same media URN. The strand builder
+  // always emits a separate `output` node with a (possibly empty)
+  // connector edge from the last prev; when the URNs coincide the
+  // output is a visible duplicate.
+  //
+  // Find the `strand-target` node and look for a single incoming
+  // edge from a `strand-cap` (or `strand-source`) node. Compare the
+  // endpoints' `fullUrn` semantically.
+  const targetNode = nodes.find(n => n.nodeClass === 'strand-target');
+  if (targetNode) {
+    const incomingToTarget = edges.filter(e => e.target === targetNode.id);
+    if (incomingToTarget.length === 1) {
+      const trailing = incomingToTarget[0];
+      const upstreamNode = nodes.find(n => n.id === trailing.source);
+      if (upstreamNode && upstreamNode.fullUrn && targetNode.fullUrn) {
+        let equivalent = false;
+        try {
+          const a = MediaUrn.fromString(upstreamNode.fullUrn);
+          const b = MediaUrn.fromString(targetNode.fullUrn);
+          equivalent = a.isEquivalent(b);
+        } catch (_) {
+          equivalent = false;
+        }
+        // Merge only if the trailing edge is the unadorned connector
+        // (empty label). A labeled last-cap edge carries meaningful
+        // info and must not be collapsed away.
+        if (equivalent && (!trailing.label || trailing.label.length === 0)) {
+          // Drop the trailing connector edge and the target node.
+          // The upstream node effectively becomes the target visually.
+          // Rename its display label to the target's display to
+          // preserve the user-configured media_display_names entry.
+          edges = edges.filter(e => e.id !== trailing.id);
+          nodes = nodes
+            .filter(n => n.id !== targetNode.id)
+            .map(n => n.id === upstreamNode.id
+              ? Object.assign({}, n, { label: targetNode.label, nodeClass: 'strand-target' })
+              : n);
+        }
+      }
+    }
+  }
+
+  return { nodes, edges };
+}
+
+function strandCytoscapeElements(built, options) {
+  // Strand mode presents ForEach and Collect as edge labels, not as
+  // boxed nodes. Apply the cosmetic collapse right before emitting
+  // cytoscape elements so the underlying plan-builder topology stays
+  // intact for any callers that need it.
+  //
+  // Run mode opts out (`options.collapse === false`) because its body
+  // replicas visually fan out from the ForEach node and merge at the
+  // Collect node — those junctions must remain as explicit graph
+  // nodes for the fan-in/fan-out to be visible.
+  const shouldCollapse = !(options && options.collapse === false);
+  const source = shouldCollapse ? collapseStrandShapeTransitions(built) : built;
+  const nodeElements = source.nodes.map(node => ({
     group: 'nodes',
     data: {
       id: node.id,
@@ -905,7 +1219,7 @@ function strandCytoscapeElements(built) {
     },
     classes: node.nodeClass || '',
   }));
-  const edgeElements = built.edges.map(edge => ({
+  const edgeElements = source.edges.map(edge => ({
     group: 'edges',
     data: {
       id: edge.id,
@@ -938,31 +1252,74 @@ function findCapStepIndexByUrn(steps, targetUrnString) {
   return -1;
 }
 
-// Remove nodes and edges belonging to the ForEach body's interior cap
-// steps from a strand backbone. In run mode, these are replaced by
-// per-body replicas; keeping the prototype chain alongside the
-// replicas produces a confusing double-render. The ForEach and Collect
-// nodes themselves, plus their iteration/collection edges, stay.
-function stripBodyInteriorFromStrandBackbone(built, steps, foreachStepIdx, collectStepIdx) {
+// Remove body-interior cap nodes (caps strictly AFTER the first
+// body cap) from a COLLAPSED strand backbone so that per-body
+// replicas are the only visible path through the foreach body.
+// The FIRST body cap node is retained — its incoming foreachEntry
+// edge is the backbone "fallback connector" that keeps the graph
+// connected when zero bodies succeed.
+//
+// Dropping interior body caps also drops their outgoing edges,
+// including any synthesized collect-exit edge that would have
+// connected the last body cap to the post-collect target. To
+// preserve connectivity, the function replaces those with a
+// plain bridging edge from the first body cap directly to the
+// post-collect target.
+function stripRunBackboneBodyInterior(built, steps, foreachStepIdx, collectStepIdx) {
+  if (foreachStepIdx < 0) return built;
   const bodyEnd = collectStepIdx >= 0 ? collectStepIdx : steps.length;
-  // Collect the positional IDs of body-interior cap steps (the caps
-  // strictly between ForEach and Collect).
-  const interiorIds = new Set();
+
+  const interiorStepIdxs = [];
   for (let i = foreachStepIdx + 1; i < bodyEnd; i++) {
     if (Object.keys(steps[i].step_type)[0] === 'Cap') {
-      interiorIds.add(`step_${i}`);
+      interiorStepIdxs.push(i);
+    }
+  }
+  if (interiorStepIdxs.length <= 1) {
+    // Zero or one body cap — no prototype chain to strip.
+    return built;
+  }
+
+  const firstBodyStepId = `step_${interiorStepIdxs[0]}`;
+  const lastBodyStepId = `step_${interiorStepIdxs[interiorStepIdxs.length - 1]}`;
+  const dropInteriorIds = new Set();
+  for (let i = 1; i < interiorStepIdxs.length; i++) {
+    dropInteriorIds.add(`step_${interiorStepIdxs[i]}`);
+  }
+
+  // Find the post-body target: the node that the last body cap's
+  // outgoing edge points at in the collapsed backbone. This is
+  // usually `output` or (after the collect-exit synth) the merged
+  // target node.
+  const postBodyEdge = built.edges.find(e => e.source === lastBodyStepId);
+  const postBodyTarget = postBodyEdge ? postBodyEdge.target : null;
+
+  const keptNodes = built.nodes.filter(n => !dropInteriorIds.has(n.id));
+  let keptEdges = built.edges.filter(e =>
+    !dropInteriorIds.has(e.source) && !dropInteriorIds.has(e.target));
+
+  // Bridge firstBody → postBodyTarget directly with a plain
+  // unlabeled connector so the graph stays connected. Replicas
+  // will overlay labeled chains alongside this connector.
+  if (postBodyTarget && postBodyTarget !== firstBodyStepId) {
+    const bridgeExists = keptEdges.some(e =>
+      e.source === firstBodyStepId && e.target === postBodyTarget);
+    if (!bridgeExists) {
+      keptEdges = keptEdges.concat([{
+        id: `run-bridge-${firstBodyStepId}-${postBodyTarget}`,
+        source: firstBodyStepId,
+        target: postBodyTarget,
+        label: '',
+        title: '',
+        fullUrn: '',
+        edgeClass: 'strand-cap-edge',
+        color: postBodyEdge ? postBodyEdge.color : edgeHueColor(0),
+        foreachEntry: false,
+        singleCapClosedBody: false,
+      }]);
     }
   }
-  if (interiorIds.size === 0) return built;
-
-  const keptNodes = built.nodes.filter(n => !interiorIds.has(n.id));
-  const keptEdges = built.edges.filter(e =>
-    !interiorIds.has(e.source) && !interiorIds.has(e.target));
 
-  // After stripping, the ForEach node and the Collect node (or the
-  // output node if no Collect) may become disconnected — the body
-  // replicas will bridge them. That's fine; cytoscape's ELK layout
-  // handles disconnected subgraphs.
   return {
     nodes: keptNodes,
     edges: keptEdges,
@@ -974,20 +1331,19 @@ function stripBodyInteriorFromStrandBackbone(built, steps, foreachStepIdx, colle
 function buildRunGraphData(data) {
   validateRunPayload(data);
 
-  // The backbone is rendered with the same rules as strand mode. Feed
-  // the strand portion to the strand builder to inherit all its
-  // ForEach/Collect labeling and cardinality-marker logic.
+  // Build the raw strand topology and then apply the cosmetic
+  // collapse — run mode uses the SAME cleaned-up backbone that
+  // strand mode uses (no ForEach/Collect nodes). Replicas are an
+  // additional overlay on top of that collapsed backbone.
   const strandInput = Object.assign({}, data.resolved_strand, {
     media_display_names: data.media_display_names,
   });
   const strandBuiltRaw = buildStrandGraphData(strandInput);
+  const strandBuiltCollapsed = collapseStrandShapeTransitions(strandBuiltRaw);
 
-  // Locate the ForEach/Collect span in the backbone for body-replica
-  // placement. The strand builder uses positional node IDs mirroring
-  // the plan builder (`step_0`, `step_1`, …). The ForEach node at
-  // step index i has id `step_i`; body replicas fan out from that
-  // ForEach node and (when a Collect closes the body) merge into the
-  // Collect node at `step_j`.
+  // Locate the ForEach/Collect span in the raw steps. Positional IDs
+  // survive the collapse (node IDs are `step_${i}` from the builder),
+  // so we can still identify which collapsed nodes are the body caps.
   const steps = data.resolved_strand.steps;
   let foreachStepIdx = -1;
   let collectStepIdx = -1;
@@ -998,16 +1354,14 @@ function buildRunGraphData(data) {
   }
   const hasForeach = foreachStepIdx >= 0;
 
-  // In run mode we want per-body replicas to REPLACE the prototype cap
-  // chain inside the ForEach body, not sit alongside it. Strip the
-  // backbone nodes and edges that correspond to body-interior Cap
-  // steps and their direct edges, keeping only the input slot, the
-  // ForEach node, the Collect node (if any), the output node, and any
-  // caps OUTSIDE the body span. Body replicas will connect from the
-  // ForEach node and merge at the Collect node.
-  const strandBuilt = hasForeach
-    ? stripBodyInteriorFromStrandBackbone(strandBuiltRaw, steps, foreachStepIdx, collectStepIdx)
-    : strandBuiltRaw;
+  // Drop interior body-cap nodes (caps 2..N inside the body) from
+  // the collapsed backbone so the prototype chain doesn't duplicate
+  // the per-body replicas visually. The FIRST body cap is retained
+  // as the body-entry node so the backbone's foreachEntry edge
+  // (`<cap_title> (1→n)`) still has a landing point.
+  let strandBuilt = hasForeach
+    ? stripRunBackboneBodyInterior(strandBuiltCollapsed, steps, foreachStepIdx, collectStepIdx)
+    : strandBuiltCollapsed;
 
   // Filter and bound the outcomes.
   const allOutcomes = data.body_outcomes.slice().sort((a, b) => a.body_index - b.body_index);
@@ -1029,12 +1383,82 @@ function buildRunGraphData(data) {
     }
   }
 
-  // Body replicas fan out from the ForEach node. If no ForEach, fall
-  // back to the input_slot. When the strand closes the body with a
-  // Collect, replicas merge into that Collect node; otherwise
-  // (unclosed ForEach) they merge into the `output` node.
-  const anchorNodeId = hasForeach ? `step_${foreachStepIdx}` : 'input_slot';
-  const mergeNodeId = collectStepIdx >= 0 ? `step_${collectStepIdx}` : 'output';
+  // Body replicas fan out from the node BEFORE the foreach (which,
+  // in the collapsed backbone, is the source of the foreachEntry
+  // edge). For a foreach at step index k, the pre-foreach node is
+  // `step_${k-1}` when k > 0, or `input_slot` when k == 0. This
+  // node survives the collapse as a regular `strand-cap` or
+  // `strand-source` node.
+  //
+  // Replicas merge back at the node AFTER the body. After collapse,
+  // this is the FIRST body cap node (`step_${bodyCapSteps[0]}`)
+  // when the ForEach has a single-cap body, or the post-collect
+  // node for multi-cap bodies. The post-collect node is whatever
+  // the plan builder's Collect step connected to downstream, which
+  // after collapse is either the next cap (`step_${collectStepIdx+1}`)
+  // or the target/output node (possibly merged into the last body
+  // cap if their URNs are equivalent).
+  const anchorNodeId = hasForeach && foreachStepIdx > 0
+    ? `step_${foreachStepIdx - 1}`
+    : 'input_slot';
+
+  // Find the merge node by scanning the collapsed backbone for the
+  // node the body reaches after the foreach body. Start from the
+  // first body cap node and follow forward edges until we leave
+  // the body. For a single-body-cap strand where the body cap IS
+  // the merged target, `mergeNodeId` resolves to that node.
+  let mergeNodeId;
+  {
+    // Find body cap step indices in the resolved strand so we can
+    // identify which step IDs are "inside body" (should be skipped
+    // when finding the merge target).
+    const bodyInteriorSet = new Set();
+    const bodyEnd = collectStepIdx >= 0 ? collectStepIdx : steps.length;
+    for (let i = foreachStepIdx + 1; i < bodyEnd; i++) {
+      if (Object.keys(steps[i].step_type)[0] === 'Cap') {
+        bodyInteriorSet.add(`step_${i}`);
+      }
+    }
+    // Start from the first body cap and walk forward.
+    const firstBodyCapIdx = (() => {
+      for (let i = foreachStepIdx + 1; i < bodyEnd; i++) {
+        if (Object.keys(steps[i].step_type)[0] === 'Cap') return i;
+      }
+      return -1;
+    })();
+    if (firstBodyCapIdx < 0) {
+      mergeNodeId = 'output';
+    } else {
+      // Walk the collapsed strand's edges starting from the first
+      // body cap node; the merge target is the first node reached
+      // that isn't inside the body.
+      let cursor = `step_${firstBodyCapIdx}`;
+      let guard = 64;
+      const collapsedNodeIds = new Set(strandBuilt.nodes.map(n => n.id));
+      while (guard-- > 0) {
+        // If the cursor is itself outside the body, we've found it.
+        if (!bodyInteriorSet.has(cursor) && collapsedNodeIds.has(cursor)) {
+          mergeNodeId = cursor;
+          break;
+        }
+        // Otherwise follow the cursor's outgoing edge.
+        const out = strandBuilt.edges.find(e => e.source === cursor);
+        if (!out) {
+          // Nothing to follow — the body cap IS the end of the
+          // strand. Use the cursor as the merge point (it's
+          // typically the merged target node).
+          mergeNodeId = cursor;
+          break;
+        }
+        cursor = out.target;
+      }
+      if (mergeNodeId === undefined) {
+        // Guard exhausted — fall back to output. This is impossible
+        // for any well-formed strand but keeps the runtime safe.
+        mergeNodeId = 'output';
+      }
+    }
+  }
 
   const replicaNodes = [];
   const replicaEdges = [];
@@ -1088,7 +1512,12 @@ function buildRunGraphData(data) {
           id: `${bodyKey}-e-${i}`,
           source: prevBodyNodeId,
           target: replicaNodeId,
-          label: i === 0 ? body.title : '',
+          // Replica edges carry no inline label — the cap title is
+          // identical across every visible replica and would just
+          // pile up as unreadable rotated text over the fan-out.
+          // Hover tooltip exposes the title via `title`; the edge
+          // color + the replica node identify the body.
+          label: '',
           title: body.title,
           fullUrn: body.cap_urn,
           color: `var(${colorVar})`,
@@ -1124,6 +1553,44 @@ function buildRunGraphData(data) {
   visibleSuccess.forEach((o) => buildBodyReplica(o));
   visibleFailure.forEach((o) => buildBodyReplica(o));
 
+  // Once any replicas are rendered (success or failure), the
+  // backbone foreach-entry edge becomes a stale placeholder — the
+  // replicas ARE the actual execution traces, so the user
+  // shouldn't see a duplicate labeled "1→n" edge alongside them.
+  // Drop the backbone foreach-entry edge whenever we emit
+  // replicas, AND if there were zero successful replicas also
+  // drop the orphaned merge node: nothing reached it, and
+  // showing a disconnected node misleads the user into thinking
+  // the target was reached.
+  if (hasForeach && (visibleSuccess.length > 0 || visibleFailure.length > 0)) {
+    const backboneForeachEntry = strandBuilt.edges.find(e =>
+      e.edgeClass === 'strand-cap-edge' &&
+      e.source === anchorNodeId &&
+      e.foreachEntry === true);
+    let newEdges = strandBuilt.edges;
+    let newNodes = strandBuilt.nodes;
+    if (backboneForeachEntry) {
+      newEdges = newEdges.filter(e => e.id !== backboneForeachEntry.id);
+    }
+    // If no successful replica will merge into `mergeNodeId`, and
+    // the merge node is now only reachable via the (just-dropped)
+    // backbone edge, drop the merge node itself.
+    if (visibleSuccess.length === 0 && mergeNodeId) {
+      const stillIncoming = newEdges.some(e => e.target === mergeNodeId);
+      const replicaIncoming = replicaEdges.some(e => e.data && e.data.target === mergeNodeId);
+      if (!stillIncoming && !replicaIncoming) {
+        newNodes = newNodes.filter(n => n.id !== mergeNodeId);
+        newEdges = newEdges.filter(e => e.source !== mergeNodeId && e.target !== mergeNodeId);
+      }
+    }
+    strandBuilt = {
+      nodes: newNodes,
+      edges: newEdges,
+      sourceSpec: strandBuilt.sourceSpec,
+      targetSpec: strandBuilt.targetSpec,
+    };
+  }
+
   // Build success and failure "show more" nodes when there are hidden
   // outcomes. Anchored at the ForEach node (or input_slot if none).
   const showMoreNodes = [];
@@ -1200,7 +1667,10 @@ function buildRunGraphData(data) {
 }
 
 function runCytoscapeElements(built) {
-  const strandElements = strandCytoscapeElements(built.strandBuilt);
+  // Do NOT collapse ForEach/Collect nodes in run mode — body replicas
+  // anchor at the ForEach node (fan-out) and merge at the Collect
+  // node (fan-in). Those junctions must stay visible.
+  const strandElements = strandCytoscapeElements(built.strandBuilt, { collapse: false });
   return strandElements
     .concat(built.replicaNodes)
     .concat(built.showMoreNodes)
@@ -2103,6 +2573,7 @@ if (typeof module !== 'undefined' && module.exports) {
     mediaNodeLabel,
     buildBrowseGraphData,
     buildStrandGraphData,
+    collapseStrandShapeTransitions,
     buildRunGraphData,
     buildMachineGraphData,
     classifyStrandCapSteps,

package/capdag.test.js

@@ -3755,6 +3755,7 @@ const {
   canonicalMediaUrn: rendererCanonicalMediaUrn,
   mediaNodeLabel: rendererMediaNodeLabel,
   buildStrandGraphData: rendererBuildStrandGraphData,
+  collapseStrandShapeTransitions: rendererCollapseStrandShapeTransitions,
   buildRunGraphData: rendererBuildRunGraphData,
   buildMachineGraphData: rendererBuildMachineGraphData,
   classifyStrandCapSteps: rendererClassifyStrandCapSteps,
@@ -4204,6 +4205,269 @@ function testRenderer_buildStrandGraphData_nestedForEachThrows() {
   assert(threw, 'nested ForEach without outer body cap must throw');
 }
 
+function testRenderer_collapseStrand_singleCapBodyShowsCapTitleWithIterCollectMarker() {
+  // User spec: ForEach/Collect are NOT rendered as nodes. The
+  // transition is labeled with the enclosed cap's title + a
+  // cardinality marker. For a single-cap body the marker is n→n
+  // (iterate + collect combined) because the same cap is both
+  // the body entry and the body exit.
+  //
+  // Strand [ForEach, Cap(extract), Collect], source=pdf;list,
+  // target=txt;list — target is NOT equivalent to cap's to_spec
+  // media:txt so the output node is retained.
+  //
+  // Expected render shape: 3 nodes (input_slot, step_1, output),
+  // with the entry edge labeled "extract (n→n)" and a plain
+  // unlabeled connector to the output.
+  const payload = {
+    source_spec: 'media:pdf;list',
+    target_spec: 'media:txt;list',
+    steps: [
+      makeForEachStep('media:pdf;list'),
+      makeCapStep('cap:in="media:pdf";op=extract;out="media:txt"', 'extract', 'media:pdf', 'media:txt', false, false),
+      makeCollectStep('media:txt'),
+    ],
+  };
+  const built = rendererBuildStrandGraphData(payload);
+  const collapsed = rendererCollapseStrandShapeTransitions(built);
+
+  const nodeIds = collapsed.nodes.map(n => n.id).sort();
+  assertEqual(JSON.stringify(nodeIds),
+    JSON.stringify(['input_slot', 'output', 'step_1']),
+    'collapse removes the ForEach and Collect nodes; the remaining nodes are source + cap + target');
+
+  // Exactly one edge from input_slot → step_1, carrying the cap
+  // title + iterate+collect cardinality marker.
+  const entryEdges = collapsed.edges.filter(e => e.source === 'input_slot' && e.target === 'step_1');
+  assertEqual(entryEdges.length, 1,
+    'phantom duplicate cap edge must be gone — exactly one edge from source to cap');
+  assertEqual(entryEdges[0].label, 'extract (n\u2192n)',
+    'single-cap-body edge is labeled "<cap_title> (n→n)"');
+
+  // The exit side is a plain unlabeled connector — the cap title
+  // is already shown on the entry edge.
+  const exitEdges = collapsed.edges.filter(e => e.source === 'step_1' && e.target === 'output');
+  assertEqual(exitEdges.length, 1,
+    'there is exactly one exit edge step_1 → output');
+  assertEqual(exitEdges[0].label, '',
+    'exit connector for a single-cap body is unlabeled (cap title already shown on entry edge)');
+}
+
+function testRenderer_collapseStrand_unclosedForEachBodyCollapses() {
+  // [Cap_a, ForEach, Cap_b] with no Collect, source=media:a,
+  // target=media:c. Cap_b's to_spec is media:c which is
+  // equivalent to target_spec, so the output node is merged
+  // into step_2.
+  //
+  // Raw topology:
+  //   input_slot → step_0 (cap_a) — normal, not in any body
+  //   step_0 → step_2 (cap_b, foreachEntry=true — phantom under
+  //                   plan builder, but the foreach body entry
+  //                   under the render model)
+  //   step_0 → step_1 (foreach direct)
+  //   step_1 → step_2 (iteration)
+  //   step_2 → output (trailing connector, empty label)
+  //
+  // Collapse:
+  //   - step_1 (foreach) removed with its iteration edges.
+  //   - step_0 → step_2 relabeled "b (1→n)" via foreachEntry.
+  //   - step_2 → output merged because upstream.fullUrn equivalent
+  //     to target_spec (both media:c); step_2 takes the target
+  //     display label.
+  //
+  // Final: 3 nodes (input_slot, step_0, step_2), 2 edges.
+  const payload = {
+    source_spec: 'media:a',
+    target_spec: 'media:c',
+    steps: [
+      makeCapStep('cap:in="media:a";op=a;out="media:b"', 'a', 'media:a', 'media:b', false, false),
+      makeForEachStep('media:b'),
+      makeCapStep('cap:in="media:b";op=b;out="media:c"', 'b', 'media:b', 'media:c', false, false),
+    ],
+  };
+  const built = rendererBuildStrandGraphData(payload);
+  const collapsed = rendererCollapseStrandShapeTransitions(built);
+
+  const nodeIds = collapsed.nodes.map(n => n.id).sort();
+  assertEqual(JSON.stringify(nodeIds),
+    JSON.stringify(['input_slot', 'step_0', 'step_2']),
+    'foreach node removed and output merged into step_2 (same URN as target)');
+
+  // Exactly one edge from step_0 to step_2, labeled with cap_b's
+  // title + (1→n) marker.
+  const step0ToStep2 = collapsed.edges.filter(e => e.source === 'step_0' && e.target === 'step_2');
+  assertEqual(step0ToStep2.length, 1,
+    'exactly one step_0 → step_2 edge after dropping the foreach iteration');
+  assertEqual(step0ToStep2[0].label, 'b (1\u2192n)',
+    'the foreach-entry edge is labeled "<cap_b_title> (1→n)"');
+
+  // Cap_a's edge is unchanged (not inside a foreach body).
+  const capA = collapsed.edges.find(e => e.source === 'input_slot' && e.target === 'step_0');
+  assert(capA !== undefined, 'cap_a edge input_slot → step_0 exists');
+  assertEqual(capA.label, 'a', 'cap_a edge carries just its title (no cardinality marker since 1→1)');
+
+  // After merging, step_2 becomes the render target — no separate
+  // output node exists.
+  const outputNode = collapsed.nodes.find(n => n.id === 'output');
+  assertEqual(outputNode, undefined,
+    'output node was merged into step_2 because their URNs are semantically equivalent');
+  const mergedTarget = collapsed.nodes.find(n => n.id === 'step_2');
+  assertEqual(mergedTarget.nodeClass, 'strand-target',
+    'merged step_2 takes on the strand-target role');
+}
+
+function testRenderer_collapseStrand_standaloneCollectCollapses() {
+  // [Cap, Collect] with no enclosing ForEach, source=media:a,
+  // target=media:b;list (NOT equivalent to cap's to_spec media:b,
+  // so the output node is retained after collapse).
+  //
+  // Collapse:
+  //   - step_1 (standalone Collect) removed.
+  //   - Synthesized bridging edge step_0 → output labeled "collect".
+  //   - The cap edge input_slot → step_0 is unchanged because the
+  //     cap is not inside any foreach body.
+  //
+  // Final: 3 nodes (input_slot, step_0, output), 2 edges.
+  const payload = {
+    source_spec: 'media:a',
+    target_spec: 'media:b;list',
+    steps: [
+      makeCapStep('cap:in="media:a";op=x;out="media:b"', 'x', 'media:a', 'media:b', false, false),
+      makeCollectStep('media:b'),
+    ],
+  };
+  const built = rendererBuildStrandGraphData(payload);
+  const collapsed = rendererCollapseStrandShapeTransitions(built);
+
+  const nodeIds = collapsed.nodes.map(n => n.id).sort();
+  assertEqual(JSON.stringify(nodeIds),
+    JSON.stringify(['input_slot', 'output', 'step_0']),
+    'collect node removed; only cap + source + target remain');
+
+  const capEdge = collapsed.edges.find(e => e.source === 'input_slot' && e.target === 'step_0');
+  assert(capEdge !== undefined, 'cap edge survives');
+  assertEqual(capEdge.label, 'x',
+    'cap edge carries just its title — no foreach cardinality markers because the cap is not inside a foreach body');
+
+  const collectEdge = collapsed.edges.find(e => e.source === 'step_0' && e.target === 'output');
+  assert(collectEdge !== undefined, 'step_0 → output edge synthesized by collect collapse');
+  assertEqual(collectEdge.label, 'collect',
+    'the synthesized bridging edge for a standalone Collect is labeled "collect"');
+}
+
+function testRenderer_collapseStrand_sequenceProducingCapBeforeForeach() {
+  // Regression test mirroring the user's real strand:
+  // [Cap_disbind (output_is_sequence=true), ForEach, Cap_make_decision],
+  // source = media:pdf, target = media:decision (equivalent to
+  // the last cap's to_spec).
+  //
+  // Expected render shape after collapse:
+  //   input_slot → step_0 labeled "Disbind (1→n)" — from Disbind's
+  //       own output_is_sequence flag, computed at build time.
+  //   step_0 → step_2 labeled "Make a Decision (1→n)" — because
+  //       make_decision is the first cap inside an unclosed
+  //       ForEach body (foreachEntry=true).
+  //   No separate output node because step_2's to_spec equals the
+  //       strand target.
+  //
+  // If this test fails, the runtime bug would manifest as either
+  // (a) a duplicate target node, (b) a "for each" labeled edge
+  // where the cap title should be, or (c) the phantom direct cap
+  // edge not being relabeled.
+  const payload = {
+    source_spec: 'media:pdf',
+    target_spec: 'media:decision',
+    steps: [
+      makeCapStep('cap:in="media:pdf";op=disbind;out="media:page"', 'Disbind', 'media:pdf', 'media:page', false, true),
+      makeForEachStep('media:page'),
+      makeCapStep('cap:in="media:page";op=decide;out="media:decision"', 'Make a Decision', 'media:page', 'media:decision', false, false),
+    ],
+  };
+  const built = rendererBuildStrandGraphData(payload);
+  const collapsed = rendererCollapseStrandShapeTransitions(built);
+
+  const nodeIds = collapsed.nodes.map(n => n.id).sort();
+  assertEqual(JSON.stringify(nodeIds),
+    JSON.stringify(['input_slot', 'step_0', 'step_2']),
+    'foreach node and duplicate output node both removed');
+
+  // Disbind cap edge carries its own (1→n) marker from
+  // output_is_sequence=true, NOT from the foreach flag.
+  const disbind = collapsed.edges.find(e => e.source === 'input_slot' && e.target === 'step_0');
+  assert(disbind !== undefined, 'Disbind edge input_slot → step_0 exists');
+  assertEqual(disbind.label, 'Disbind (1\u2192n)',
+    'Disbind edge reflects its own output_is_sequence=true cardinality');
+
+  // make_decision cap edge is the foreach entry — the plan-builder
+  // phantom direct edge becomes the render-visible cap edge with
+  // (1→n) appended to the cap title.
+  const makeDecision = collapsed.edges.filter(e => e.source === 'step_0' && e.target === 'step_2');
+  assertEqual(makeDecision.length, 1,
+    'exactly one edge from Text Page to Decision (phantom not duplicated)');
+  assertEqual(makeDecision[0].label, 'Make a Decision (1\u2192n)',
+    'the foreach entry edge is labeled "<cap_title> (1→n)", not "for each"');
+
+  // Duplicate target must be gone.
+  const outputNode = collapsed.nodes.find(n => n.id === 'output');
+  assertEqual(outputNode, undefined,
+    'output node merged into step_2 because they represent the same URN');
+}
+
+function testRenderer_collapseStrand_plainCapMergesTrailingOutput() {
+  // A strand with a single plain 1→1 cap whose to_spec equals
+  // target_spec. The plan-builder topology produces:
+  //   input_slot → step_0 (cap) → output
+  // The collapse pass merges the trailing output edge because
+  // step_0 and output represent the same URN (media:b).
+  //
+  // Final: 2 nodes (input_slot, step_0), 1 edge.
+  const payload = {
+    source_spec: 'media:a',
+    target_spec: 'media:b',
+    steps: [
+      makeCapStep('cap:in="media:a";op=x;out="media:b"', 'x', 'media:a', 'media:b', false, false),
+    ],
+  };
+  const built = rendererBuildStrandGraphData(payload);
+  const collapsed = rendererCollapseStrandShapeTransitions(built);
+
+  assertEqual(collapsed.nodes.length, 2,
+    'duplicate output node merged into step_0 — 2 nodes remain');
+  const outputNode = collapsed.nodes.find(n => n.id === 'output');
+  assertEqual(outputNode, undefined,
+    'output node dropped by merge');
+  const mergedTarget = collapsed.nodes.find(n => n.id === 'step_0');
+  assertEqual(mergedTarget.nodeClass, 'strand-target',
+    'step_0 takes on the strand-target role after the merge');
+
+  assertEqual(collapsed.edges.length, 1, 'single cap edge remains');
+  assertEqual(collapsed.edges[0].source, 'input_slot');
+  assertEqual(collapsed.edges[0].target, 'step_0');
+  assertEqual(collapsed.edges[0].label, 'x', 'cap title preserved as edge label');
+}
+
+function testRenderer_collapseStrand_plainCapDistinctTargetNoMerge() {
+  // A strand with a single plain cap whose to_spec is NOT
+  // equivalent to target_spec. The output node must be retained
+  // and the trailing connector edge preserved.
+  const payload = {
+    source_spec: 'media:a',
+    target_spec: 'media:b;list',
+    steps: [
+      makeCapStep('cap:in="media:a";op=x;out="media:b"', 'x', 'media:a', 'media:b', false, false),
+    ],
+  };
+  const built = rendererBuildStrandGraphData(payload);
+  const collapsed = rendererCollapseStrandShapeTransitions(built);
+
+  assertEqual(collapsed.nodes.length, 3,
+    'no merge because cap to_spec (media:b) and target (media:b;list) are semantically distinct');
+  assert(collapsed.nodes.find(n => n.id === 'output') !== undefined,
+    'output node retained');
+  assert(collapsed.nodes.find(n => n.id === 'step_0') !== undefined,
+    'step_0 retained');
+}
+
 function testRenderer_validateStrandPayload_missingSourceSpec() {
   let threw = false;
   try {
@@ -4372,6 +4636,156 @@ function testRenderer_buildRunGraphData_usesCapUrnIsEquivalentForFailedCap() {
   assertEqual(failureNodes, 2, 'trace truncates at cap y via isEquivalent, yielding 2 failure nodes');
 }
 
+function testRenderer_buildRunGraphData_backboneHasNoForeachNode() {
+  // Regression test for the run-mode rendering fix: the backbone
+  // delivered to cytoscape must NOT contain any strand-foreach or
+  // strand-collect nodes. Run mode inherits the same cosmetic
+  // collapse as strand mode so the foreach/collect execution-layer
+  // concepts don't leak into the view as boxed nodes.
+  //
+  // User scenario: [Disbind (1→n), ForEach, make_decision] where
+  // target_spec equals the last cap's to_spec, so the backbone
+  // collapses to 3 nodes: input_slot, step_0 (Text Page),
+  // step_2 (Decision, merged target). No separate `for each` or
+  // `collect` boxes.
+  const strand = {
+    source_spec: 'media:pdf',
+    target_spec: 'media:decision',
+    steps: [
+      makeCapStep('cap:in="media:pdf";op=disbind;out="media:page"', 'Disbind', 'media:pdf', 'media:page', false, true),
+      makeForEachStep('media:page'),
+      makeCapStep('cap:in="media:page";op=decide;out="media:decision"', 'Make a Decision', 'media:page', 'media:decision', false, false),
+    ],
+  };
+  const payload = {
+    resolved_strand: strand,
+    body_outcomes: [],
+    visible_success_count: 0,
+    visible_failure_count: 0,
+    total_body_count: 0,
+  };
+  const built = rendererBuildRunGraphData(payload);
+
+  // Backbone must contain NO foreach/collect nodes.
+  const foreachNodes = built.strandBuilt.nodes.filter(n => n.nodeClass === 'strand-foreach');
+  const collectNodes = built.strandBuilt.nodes.filter(n => n.nodeClass === 'strand-collect');
+  assertEqual(foreachNodes.length, 0, 'run backbone must not contain strand-foreach nodes');
+  assertEqual(collectNodes.length, 0, 'run backbone must not contain strand-collect nodes');
+
+  // The backbone fallback connector is the foreach-entry cap edge
+  // that runs from the pre-foreach node to the body cap. It must
+  // survive collapse so the target stays reachable even with zero
+  // successful bodies.
+  const backboneCapEdges = built.strandBuilt.edges.filter(e => e.edgeClass === 'strand-cap-edge');
+  assert(backboneCapEdges.some(e => e.source === 'step_0' && e.target === 'step_2'),
+    'foreach-entry backbone edge step_0 → step_2 must be present for fallback connectivity');
+
+  // With zero outcomes, no replicas and no show-more nodes.
+  assertEqual(built.replicaNodes.length, 0, 'no replica nodes when body_outcomes is empty');
+  assertEqual(built.showMoreNodes.length, 0, 'no show-more nodes when no hidden outcomes');
+}
+
+function testRenderer_buildRunGraphData_allFailedDropsTargetPlaceholder() {
+  // When every body fails, the strand target node was never
+  // reached by any execution. The render drops BOTH the backbone
+  // foreach-entry edge AND the orphaned target node so the user
+  // doesn't see a stale "Decision" placeholder alongside their
+  // failed replicas.
+  const strand = {
+    source_spec: 'media:pdf',
+    target_spec: 'media:decision',
+    steps: [
+      makeCapStep('cap:in="media:pdf";op=disbind;out="media:page"', 'Disbind', 'media:pdf', 'media:page', false, true),
+      makeForEachStep('media:page'),
+      makeCapStep('cap:in="media:page";op=decide;out="media:decision"', 'Make a Decision', 'media:page', 'media:decision', false, false),
+    ],
+  };
+  const failedCapUrn = 'cap:in="media:page";op=decide;out="media:decision"';
+  const payload = {
+    resolved_strand: strand,
+    body_outcomes: [
+      { body_index: 0, success: false, cap_urns: [], saved_paths: [], total_bytes: 0, duration_ms: 0, failed_cap: failedCapUrn, error: 'boom' },
+      { body_index: 1, success: false, cap_urns: [], saved_paths: [], total_bytes: 0, duration_ms: 0, failed_cap: failedCapUrn, error: 'boom' },
+    ],
+    visible_success_count: 3,
+    visible_failure_count: 3,
+    total_body_count: 2,
+  };
+  const built = rendererBuildRunGraphData(payload);
+
+  // The dropped placeholder: step_2 (the merged strand target
+  // "Decision") is absent from the backbone because all bodies
+  // failed and the replicas didn't reach it.
+  const hasStep2 = built.strandBuilt.nodes.some(n => n.id === 'step_2');
+  assertEqual(hasStep2, false,
+    'strand target placeholder must be dropped when zero successful replicas reach it');
+
+  // The backbone foreach-entry edge is also gone — replicas
+  // replaced it and there's no orphan target to connect.
+  const foreachEntry = built.strandBuilt.edges.find(e =>
+    e.edgeClass === 'strand-cap-edge' && e.foreachEntry === true);
+  assertEqual(foreachEntry, undefined,
+    'backbone foreach-entry edge must be dropped when replicas exist');
+
+  // Failures are rendered as red replica trails that don't merge.
+  const failureNodes = built.replicaNodes.filter(n => n.classes === 'body-failure');
+  assertEqual(failureNodes.length, 2,
+    'two failed bodies render two replica nodes (truncated at failed_cap)');
+
+  // The pre-foreach cap node (step_0, "Disbind") is still present
+  // along with its incoming edge — only the post-body parts were
+  // dropped.
+  const hasStep0 = built.strandBuilt.nodes.some(n => n.id === 'step_0');
+  assertEqual(hasStep0, true, 'pre-foreach cap node survives');
+  const disbindEdge = built.strandBuilt.edges.find(e =>
+    e.source === 'input_slot' && e.target === 'step_0');
+  assert(disbindEdge !== undefined, 'pre-foreach cap edge (Disbind) survives');
+}
+
+function testRenderer_buildRunGraphData_backboneDroppedWhenSuccessful() {
+  // When at least one successful replica merges into the target,
+  // the backbone foreach-entry edge is dropped — the replica's
+  // own chain represents the execution and the backbone would
+  // otherwise duplicate the path.
+  const strand = {
+    source_spec: 'media:pdf',
+    target_spec: 'media:decision',
+    steps: [
+      makeCapStep('cap:in="media:pdf";op=disbind;out="media:page"', 'Disbind', 'media:pdf', 'media:page', false, true),
+      makeForEachStep('media:page'),
+      makeCapStep('cap:in="media:page";op=decide;out="media:decision"', 'Make a Decision', 'media:page', 'media:decision', false, false),
+    ],
+  };
+  const payload = {
+    resolved_strand: strand,
+    body_outcomes: [
+      { body_index: 0, success: true, cap_urns: [], saved_paths: [], total_bytes: 0, duration_ms: 0 },
+    ],
+    visible_success_count: 3,
+    visible_failure_count: 3,
+    total_body_count: 1,
+  };
+  const built = rendererBuildRunGraphData(payload);
+
+  // The backbone foreach-entry edge is gone.
+  const foreachEntry = built.strandBuilt.edges.find(e =>
+    e.edgeClass === 'strand-cap-edge' && e.foreachEntry === true);
+  assertEqual(foreachEntry, undefined,
+    'foreach-entry backbone edge dropped when at least one success exists');
+
+  // step_2 (target) stays because the replica merge edge lands on it.
+  const hasStep2 = built.strandBuilt.nodes.some(n => n.id === 'step_2');
+  assertEqual(hasStep2, true,
+    'strand target node survives when successful replicas merge into it');
+
+  // Exactly one successful replica node and one merge edge.
+  const successNodes = built.replicaNodes.filter(n => n.classes === 'body-success');
+  assertEqual(successNodes.length, 1, 'one replica node for one successful body');
+  const mergeEdges = built.replicaEdges.filter(e =>
+    e.data && e.data.target === 'step_2' && e.classes === 'body-success');
+  assertEqual(mergeEdges.length, 1, 'one merge edge from replica to target');
+}
+
 // ---------------- machine builder ----------------
 
 function testRenderer_validateMachinePayload_rejectsUnknownKind() {
@@ -4800,6 +5214,12 @@ async function runTests() {
   runTest('RENDERER: buildStrand_standaloneCollect',          testRenderer_buildStrandGraphData_standaloneCollect);
   runTest('RENDERER: buildStrand_unclosedForEachBody',        testRenderer_buildStrandGraphData_unclosedForEachBody);
   runTest('RENDERER: buildStrand_nestedForEachThrows',        testRenderer_buildStrandGraphData_nestedForEachThrows);
+  runTest('RENDERER: collapseStrand_singleCapBody',           testRenderer_collapseStrand_singleCapBodyShowsCapTitleWithIterCollectMarker);
+  runTest('RENDERER: collapseStrand_unclosedForEachBody',     testRenderer_collapseStrand_unclosedForEachBodyCollapses);
+  runTest('RENDERER: collapseStrand_standaloneCollect',       testRenderer_collapseStrand_standaloneCollectCollapses);
+  runTest('RENDERER: collapseStrand_seqCapBeforeForeach',     testRenderer_collapseStrand_sequenceProducingCapBeforeForeach);
+  runTest('RENDERER: collapseStrand_plainCapMergesOutput',    testRenderer_collapseStrand_plainCapMergesTrailingOutput);
+  runTest('RENDERER: collapseStrand_plainCapDistinctTarget',  testRenderer_collapseStrand_plainCapDistinctTargetNoMerge);
   runTest('RENDERER: validateStrand_missingSourceSpec',       testRenderer_validateStrandPayload_missingSourceSpec);
 
   console.log('\n--- cap-graph-renderer run builder ---');
@@ -4807,6 +5227,9 @@ async function runTests() {
   runTest('RENDERER: buildRun_pagesSuccessesAndFailures',     testRenderer_buildRunGraphData_pagesSuccessesAndFailures);
   runTest('RENDERER: buildRun_failureWithoutFailedCap',       testRenderer_buildRunGraphData_failureWithoutFailedCapRendersFullTrace);
   runTest('RENDERER: buildRun_usesIsEquivalentForFailedCap',  testRenderer_buildRunGraphData_usesCapUrnIsEquivalentForFailedCap);
+  runTest('RENDERER: buildRun_backboneHasNoForeachNode',      testRenderer_buildRunGraphData_backboneHasNoForeachNode);
+  runTest('RENDERER: buildRun_allFailedDropsPlaceholder',     testRenderer_buildRunGraphData_allFailedDropsTargetPlaceholder);
+  runTest('RENDERER: buildRun_backboneDroppedWhenSuccessful', testRenderer_buildRunGraphData_backboneDroppedWhenSuccessful);
 
   console.log('\n--- cap-graph-renderer machine builder ---');
   runTest('RENDERER: validateMachine_unknownKind',            testRenderer_validateMachinePayload_rejectsUnknownKind);

package/package.json

@@ -40,5 +40,5 @@
     "pretest": "npm run build:parser",
     "test": "node capdag.test.js"
   },
-  "version": "0.109.248"
+  "version": "0.119.263"
 }