@volter/supercode-interchange 0.1.22 → 0.1.24

package/session-claude-graph.mjs

@@ -18,8 +18,9 @@ function compactBoundary(value) {
   };
 }
 
-/** Claude's active branch and compaction projection. Semantic reads may name
- * degraded segments; stricter continuation/export reads never guess a graph. */
+/** Claude's active branch and compaction projection. Semantic reads may name degraded segments, and a history read
+ * (a semantic read with `history`) keeps every segment before the latest compaction; other reads cut at the latest
+ * boundary, and stricter continuation/export reads never guess a graph. */
 export class ClaudeReplayIndex {
   nodes = [];
   byUuid = new Map();
@@ -64,11 +65,11 @@ export class ClaudeReplayIndex {
     });
   }
 
-  selectLines(fidelity) {
+  selectLines(fidelity, { history = false } = {}) {
     const lenient = fidelity === 'semantic', residue = [];
     if (this.nodes.every((node) => !conversation(node))) return { lines: this.linearLines, residue };
     if (lenient) this.#anchorDanglingParents(residue);
-    try { return { lines: this.#project(lenient, residue), residue }; }
+    try { return { lines: this.#project(lenient, residue, lenient && history), residue }; }
     catch (error) {
       if (!lenient) throw error;
       residue.push(`the Claude record graph could not be projected (${error.message}); every record was stitched in transcript order instead`);
@@ -88,10 +89,13 @@ export class ClaudeReplayIndex {
     residue.push(`${dangling.length} Claude record(s) reference a parentUuid absent from the transcript and were anchored as segment roots: ${listed}`);
   }
 
-  #project(lenient, residue) {
+  #project(lenient, residue, history) {
     const retained = this.nodes.map(() => true);
+    // Compaction cuts what the model is given, not the conversation: a history read is a view, and keeps every segment
+    // before the latest boundary in transcript order, as Claude Code's own transcript view (ctrl+o) does. Every other
+    // read starts at the latest boundary.
     const boundary = this.nodes.findLastIndex((node) => node.compact != null);
-    if (boundary !== -1) {
+    if (boundary !== -1 && !history) {
       const parents = lenient ? this.nodes.map((node) => node.parent) : null;
       try { this.#applyCompaction(boundary, retained); }
       catch (error) {
@@ -111,6 +115,12 @@ export class ClaudeReplayIndex {
     while (!conversation(this.nodes[active])) {
       if (seeking.has(active)) throw claudeReplayError('cycle while resolving active Claude leaf');
       seeking.add(active);
+      // A history read whose newest records open a segment with no conversation yet (a compaction's boundary and its
+      // attachments, written before the summary that opens it) is read from the newest conversation record before them.
+      if (history && this.nodes[active].parent == null) {
+        const newest = this.nodes.findLastIndex((node, index) => retained[index] && !node.sidechain && conversation(node));
+        if (newest !== -1) { active = newest; break; }
+      }
       active = this.#parentIndex(active, retained);
     }
     const children = new Map();
@@ -120,9 +130,20 @@ export class ClaudeReplayIndex {
       children.get(node.parent).push(index);
     });
     const segments = [this.#projectSegment(active, retained, sidechainOnly, lenient, children)];
-    if (lenient) {
+    if (lenient && !history) {
       for (const leaf of this.#severedLeaves(active, retained)) segments.push(this.#projectSegment(leaf, retained, sidechainOnly, lenient, children));
       if (segments.length > 1) residue.push(`${segments.length} conversation segments were stitched in transcript order because the Claude record graph is severed`);
+    } else if (history) {
+      // The transcript's opening and each compaction start a segment of their own; any other root is a severed graph.
+      const roots = new Map(), opening = this.nodes.findIndex(conversation);
+      const openingRoot = opening === -1 ? null : this.#componentRoot(opening, retained, roots);
+      let severed = 0;
+      for (const leaf of this.#severedLeaves(active, retained)) {
+        segments.push(this.#projectSegment(leaf, retained, sidechainOnly, lenient, children));
+        const root = this.#componentRoot(leaf, retained, roots);
+        if (root !== openingRoot && this.nodes[root]?.compact == null) severed++;
+      }
+      if (severed > 0) residue.push(`${severed + 1} conversation segments were stitched in transcript order because the Claude record graph is severed`);
     }
     const firstLine = (segment) => segment.reduce((first, index) => Math.min(first, this.nodes[index].lineIndex), Infinity);
     const ordered = [], placed = new Set();
@@ -149,6 +170,7 @@ export class ClaudeReplayIndex {
       else if (this.segmentAnchors.has(node.parent) || sidechainOnly) cursor = null;
       else throw claudeReplayError(`active Claude record \`${node.uuid}\` has missing parentUuid \`${node.parent}\``);
       if (cursor != null && !retained[cursor]) {
+        // A compaction boundary is where this segment ends; the records it pruned stay pruned.
         if (lenient) break;
         throw claudeReplayError(`active Claude chain crosses an excluded compaction record from \`${node.uuid}\``);
       }