@volter/supercode-interchange 0.1.20 → 0.1.22

package/discovery.mjs

@@ -10,7 +10,7 @@ export async function enrichDescriptor(query, descriptor, { codexTopics, metrics
   const row = { ...descriptor };
   const take = async (read) => {
     try { return await read(); }
-    catch (error) { previewFailure?.(row.locator, error); return []; }
+    catch (error) { if (metrics) metrics.preview_failures = (metrics.preview_failures ?? 0) + 1; previewFailure?.(row.locator, error); return []; }
   };
   if (query.include_topic_candidates) {
     const history = row.locator.harness === 'codex' ? codexTopics?.get(row.locator.session_id) : null;
@@ -30,8 +30,19 @@ export async function enrichDescriptor(query, descriptor, { codexTopics, metrics
 export const readsPreviews = (query) => query.include_latest_candidates !== false || Boolean(query.include_topic_candidates);
 
 export async function enrichIndexPage(query, rows, options) {
-  const result = [];
-  for (const row of rows) result.push(await enrichDescriptor(query, row, options));
+  // A page used to await every open/read/stat/close before starting the next row. Keep a small number of
+  // independent reads in flight, preserve row order and retain every fingerprint/failure check. Never fan out
+  // with Promise.all(rows): a whole-index request can contain thousands of transcripts and expanded tails.
+  const result = new Array(rows.length);
+  let next = 0;
+  const read = async () => {
+    while (next < rows.length) {
+      const at = next++;
+      result[at] = await enrichDescriptor(query, rows[at], options);
+    }
+  };
+  const finished = await Promise.allSettled(Array.from({ length: Math.min(4, rows.length) }, read));
+  for (const worker of finished) if (worker.status === 'rejected') throw worker.reason;
   return result;
 }
 
@@ -46,9 +57,10 @@ export function namesWholeSessionId(query) {
  * title supplier chooses one id by source mtime, before applying the other
  * query filters, as native claude_session_named does. Neither is caller proof. */
 export async function discoverFromIndex(query, descriptors, options = {}) {
+  const step = options.step ?? ((_name, work) => work());
   const raw = [...descriptors];
-  if (query.search_previews) return previewPage(query, raw, options);
-  const page = projectMetadataPage(query, raw, options);
+  if (query.search_previews) return step('preview search', () => previewPage(query, raw, options));
+  const page = await step('metadata projection', () => projectMetadataPage(query, raw, options));
   const name = queryName(query);
   if (query.cursor == null && name) {
     const selected = query.harnesses;
@@ -78,7 +90,7 @@ export async function discoverFromIndex(query, descriptors, options = {}) {
   }
   // Keep the native receipt from projection: its counts precede the exact-name
   // post-filter and late-name fallback. Do not silently rewrite that contract.
-  page.sessions = await enrichIndexPage(query, page.sessions, options);
+  page.sessions = await step('preview reads', () => enrichIndexPage(query, page.sessions, options));
   return page;
 }
 

package/index.d.ts

@@ -108,6 +108,8 @@ export interface DiscoveryEnrichmentOptions extends MetadataProjectionOptions {
   previewFailure?: (locator: SessionLocator, error: Error) => void;
   liveClaudeName?: (name: string) => Promise<{ id: string; name: string } | null>;
   lateClaudeName?: (name: string) => Promise<string | null>;
+  /** Optional request-local stage timing; it must preserve the work's value and errors. */
+  step?: <T>(name: string, work: () => T | Promise<T>) => T | Promise<T>;
 }
 export function enrichDescriptor(query: DiscoveryQuery, descriptor: SessionDescriptor, options?: DiscoveryEnrichmentOptions): Promise<SessionDescriptor>;
 export function readsPreviews(query: DiscoveryQuery): boolean;

package/package.json

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

package/previews.mjs

@@ -66,6 +66,30 @@ function codexMessage(native) {
 
 function parseLine(text) { try { return parseNativeJson(text); } catch { return null; } }
 
+// Walk boundaries only as far as the eight candidates need. Splitting a validated 512 KiB/4 MiB window built
+// an array of every progress/tool line for each returned session, even when its newest eight messages came first.
+function* linesIn(text, latest) {
+  if (!text.length) return;
+  const limit = text.endsWith('\n') ? text.length - 1 : text.length;
+  if (latest) {
+    let end = limit;
+    for (;;) {
+      const newline = end === 0 ? -1 : text.lastIndexOf('\n', end - 1);
+      yield text.slice(newline + 1, end);
+      if (newline < 0) return;
+      end = newline;
+    }
+  } else {
+    let from = 0;
+    for (;;) {
+      const newline = text.indexOf('\n', from);
+      if (newline < 0 || newline >= limit) { yield text.slice(from, limit); return; }
+      yield text.slice(from, newline);
+      from = newline + 1;
+    }
+  }
+}
+
 function codexCandidates(lines, latest) {
   const candidates = [];
   let pending = null;
@@ -90,9 +114,7 @@ function candidatesIn(bytes, harness, latest) {
   // Validate the entire window before selecting eight records, matching the
   // native String::from_utf8 refusal even for unused later preview bytes.
   const text = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(bytes);
-  const lines = text.split('\n');
-  if (lines.at(-1) === '') lines.pop();
-  if (latest) lines.reverse();
+  const lines = linesIn(text, latest);
   if (harness === 'codex') return codexCandidates(lines, latest);
   const candidates = [];
   for (const line of lines) {

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;