@volter/supercode-interchange 0.1.20 → 0.1.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-interchange",
-  "version": "0.1.20",
+  "version": "0.1.21",
   "type": "module",
   "description": "Read-only harness metadata, transcript codecs and session projections for Supercode",
   "license": "MIT OR Apache-2.0",

package/session-claude-index.mjs

@@ -220,6 +220,16 @@ class ClaudeRecordScan extends AppendScan {
   graph = new ClaudeReplayIndex(); meta = createSession('claude_code').meta; profile = recordedProfileFold('claude_code');
   skeletons = new Map(); view = null;
 
+  /** Charge retained replay records and derived entries, including one entry for the scan itself. Progress and other discarded lines
+   * only advance `lines`: charging them as retained records made two long, mostly-progress transcripts evict one
+   * another on every alternating read, though their replay state together was far below the bound. */
+  get retainedRecords() {
+    // The record's graph node and linear-line index are views of that same retained record, not two more records.
+    // They are bounded by `records.size`; fork anchors and derived profile/message entries are charged separately.
+    return 1 + this.records.size + this.graph.segmentAnchors.size + this.profile.history.length + this.skeletons.size
+      + (this.view?.skeleton.length ?? 0) + (this.view?.groups.length ?? 0);
+  }
+
   /** The lines completed since the last pass. A last line with no LF yet stays outside the scan: `view` reads it. */
   async extend(reader) {
     const from = this.bytes;
@@ -267,7 +277,7 @@ class ClaudeRecordScan extends AppendScan {
   }
 }
 
-// The scans of the files read most recently, at most this many records between them: a transcript read again is
+// The scans of the files read most recently, at most this many retained replay entries between them: a transcript read again is
 // read from where its scan stopped, and one read long ago is scanned again. Of the files shorter than
 // SCAN_KEPT_BYTES only the one read last is kept (a pass reads its file more than once): scanning a short file again
 // costs less than keeping the scan of every one read.
@@ -278,11 +288,27 @@ async function scanOf(path, reader) {
   let scan = scans.get(path); scans.delete(path);
   if (!scan || !await scan.holds(reader)) scan = new ClaudeRecordScan(reader);
   await scan.extend(reader);
+  return scan;
+}
+
+// Project before admitting the scan: the projection adds skeletons and groups that the same finite bound charges.
+// As before, the current scan is kept even when it alone exceeds the bound; every older scan then goes.
+function retainScan(path, scan, metrics = {}) {
+  metrics.claude_scan_physical_lines = scan.lines;
+  metrics.claude_scan_record_positions = scan.records.size;
+  metrics.claude_scan_graph_nodes = scan.graph.nodes.length;
+  metrics.claude_scan_graph_lines = scan.graph.linearLines.length;
+  metrics.claude_scan_profile_changes = scan.profile.history.length;
+  metrics.claude_scan_skeletons = scan.skeletons.size;
   if (scan.bytes < SCAN_KEPT_BYTES) for (const [other, item] of scans) if (item.bytes < SCAN_KEPT_BYTES) scans.delete(other);
   scans.set(path, scan);
-  let held = 0; for (const item of scans.values()) held += item.lines;
-  for (const [other, item] of scans) { if (held <= SCANNED_RECORDS || item === scan) break; scans.delete(other); held -= item.lines; }
-  return scan;
+  let held = 0; for (const item of scans.values()) held += item.retainedRecords;
+  for (const [other, item] of scans) {
+    if (held <= SCANNED_RECORDS || item === scan) break;
+    scans.delete(other); held -= item.retainedRecords;
+    metrics.claude_scan_evictions = (metrics.claude_scan_evictions ?? 0) + 1;
+  }
+  metrics.claude_scan_retained_entries = held;
 }
 
 /**
@@ -299,7 +325,11 @@ export async function loadClaudeRecordWindow(locator, { from, bytes = null, mess
   if (!await supportsClaudeReadIndex(path, { metrics })) return null;
   return (await withSessionFile(path, async (reader) => {
     let view;
-    try { view = await (await scanOf(path, reader)).project(reader, fidelity); }
+    try {
+      const scan = await scanOf(path, reader);
+      view = await scan.project(reader, fidelity);
+      retainScan(path, scan, metrics);
+    }
     catch (error) {
       scans.delete(path);
       throw ['ERR_ENCODING_INVALID_ENCODED_DATA', 'ERR_STRING_TOO_LONG'].includes(error?.code) ? sessionTextError(path, error) : error;