mixdog 1.2.5 → 1.2.6

package/src/runtime/agent/orchestrator/session/store-record-strict-scan.mjs

@@ -0,0 +1,306 @@
+/**
+ * Strict session-record read that decodes only what its caller needs.
+ *
+ * `readTopLevelLifecycleRecord` (lifecycle-scan.mjs) is the authority: a full
+ * `JSON.parse`, then a top-level duplicate-key walk. On a transcript that
+ * materializes every message object — about 2.5 ms per MB, most of it for
+ * tool output nobody reads. This reader reaches the SAME verdict and the same
+ * values while decoding only:
+ *   - top-level values whose key is not in `skip`;
+ *   - of `messages` (when it is an array): each element whose `role` is in
+ *     `fullMessageRoles` in full; every other object element as `{ role }`
+ *     (or `{}` without one); non-object elements in full.
+ * Everything else is validated, never decoded.
+ *
+ * The fast path accepts a document only when it has PROVEN it valid:
+ *   - no raw byte below 0x20 anywhere (one native regex test; JSON forbids
+ *     them inside strings, so a document with whitespace other than spaces,
+ *     i.e. a pretty-printed one, simply takes the authoritative path);
+ *   - no invalid escape anywhere (one native regex test; a backslash outside
+ *     a string fails the grammar walk below);
+ *   - the complete grammar, walked over every byte outside strings: values,
+ *     separators, exact number and literal spellings, nesting, and nothing
+ *     but whitespace after the root object;
+ *   - a root object without any repeated top-level key.
+ * Anything it cannot prove — malformed, ambiguous, or merely unusual — is
+ * handed to `readTopLevelLifecycleRecord` itself, so every rejection is the
+ * authority's own. Decoded values are `JSON.parse` of their exact UTF-8
+ * slices, which equal the full parse's sub-values (slices start and end at
+ * ASCII delimiters, so UTF-8 decoding agrees too).
+ */
+import { lifecycleRecordOf, readTopLevelLifecycleRecord } from './lifecycle-scan.mjs';
+
+const QUOTE = 0x22;
+const BACKSLASH = 0x5c;
+const SPACE = 0x20;
+const COMMA = 0x2c;
+const COLON = 0x3a;
+const OPEN_OBJECT = 0x7b;
+const CLOSE_OBJECT = 0x7d;
+const OPEN_ARRAY = 0x5b;
+const CLOSE_ARRAY = 0x5d;
+const MINUS = 0x2d;
+const PLUS = 0x2b;
+const DOT = 0x2e;
+const ZERO = 0x30;
+const NINE = 0x39;
+const EMPTY = new Set();
+
+// String-content faults, one native pass each (an alternation of the two is
+// slower than both). Any raw control byte: inside a string JSON.parse rejects
+// it; outside one only \t \n \r are whitespace, and those documents take the
+// full path.
+// biome-ignore lint/suspicious/noControlCharactersInRegex: control bytes are exactly what this detects.
+const CONTROL_BYTE = /[\x00-\x1f]/;
+// An escape that is not one of \" \\ \/ \b \f \n \r \t \uXXXX. The run before
+// it starts after a non-backslash, so escapes pair from the run's start.
+const INVALID_ESCAPE = /(?<!\\)(?:\\\\)*\\(?:[^"\\/bfnrtu]|u(?![0-9a-fA-F]{4}))/;
+
+const isDigit = (code) => code >= ZERO && code <= NINE;
+
+// Only spaces can remain: CONTROL_BYTE already sent every \t \n \r away.
+function skipSpaces(text, at) {
+  let i = at;
+  while (text.charCodeAt(i) === SPACE) i++;
+  return i;
+}
+
+/** Index after the string opening at `at`, or -1. */
+function stringEnd(text, at) {
+  let quote = at;
+  for (;;) {
+    quote = text.indexOf('"', quote + 1);
+    if (quote === -1) return -1;
+    let run = 0;
+    for (let k = quote - 1; text.charCodeAt(k) === BACKSLASH; k--) run++;
+    if ((run & 1) === 0) return quote + 1;
+  }
+}
+
+/** Index after the JSON number at `at`, or -1. */
+function numberEnd(text, at) {
+  let i = at;
+  if (text.charCodeAt(i) === MINUS) i++;
+  if (text.charCodeAt(i) === ZERO) i++;
+  else if (isDigit(text.charCodeAt(i))) {
+    while (isDigit(text.charCodeAt(i))) i++;
+  } else return -1;
+  if (text.charCodeAt(i) === DOT) {
+    i++;
+    if (!isDigit(text.charCodeAt(i))) return -1;
+    while (isDigit(text.charCodeAt(i))) i++;
+  }
+  const exponent = text.charCodeAt(i);
+  if (exponent === 0x65 || exponent === 0x45) {
+    i++;
+    if (text.charCodeAt(i) === PLUS || text.charCodeAt(i) === MINUS) i++;
+    if (!isDigit(text.charCodeAt(i))) return -1;
+    while (isDigit(text.charCodeAt(i))) i++;
+  }
+  return i;
+}
+
+/** Index after `"key" :` starting at `at`, or -1. */
+function memberValueStart(text, at) {
+  if (text.charCodeAt(at) !== QUOTE) return -1;
+  const end = stringEnd(text, at);
+  if (end === -1) return -1;
+  const colon = skipSpaces(text, end);
+  return text.charCodeAt(colon) === COLON ? colon + 1 : -1;
+}
+
+/** Index after one valid JSON value starting at or after `at`, or -1.
+ *  Iterative, so nesting depth costs no stack. */
+function valueEnd(text, at) {
+  const closers = [];
+  let i = at;
+  for (;;) {
+    i = skipSpaces(text, i);
+    const code = text.charCodeAt(i);
+    if (code === QUOTE) i = stringEnd(text, i);
+    else if (code === OPEN_OBJECT || code === OPEN_ARRAY) {
+      const closer = code === OPEN_OBJECT ? CLOSE_OBJECT : CLOSE_ARRAY;
+      i = skipSpaces(text, i + 1);
+      if (text.charCodeAt(i) === closer) i++;
+      else {
+        closers.push(closer);
+        if (closer === CLOSE_OBJECT) {
+          i = memberValueStart(text, i);
+          if (i === -1) return -1;
+        }
+        continue;
+      }
+    } else if (code === 0x74) i = text.startsWith('true', i) ? i + 4 : -1;
+    else if (code === 0x66) i = text.startsWith('false', i) ? i + 5 : -1;
+    else if (code === 0x6e) i = text.startsWith('null', i) ? i + 4 : -1;
+    else i = numberEnd(text, i);
+    if (i === -1) return -1;
+    // After a value: close containers or move to the next member/element.
+    for (;;) {
+      if (closers.length === 0) return i;
+      i = skipSpaces(text, i);
+      const next = text.charCodeAt(i);
+      const closer = closers[closers.length - 1];
+      if (next === closer) {
+        closers.pop();
+        i++;
+        continue;
+      }
+      if (next !== COMMA) return -1;
+      i = skipSpaces(text, i + 1);
+      if (closer === CLOSE_OBJECT) {
+        i = memberValueStart(text, i);
+        if (i === -1) return -1;
+      }
+      break;
+    }
+  }
+}
+
+const decodeSlice = (bytes, start, end) => JSON.parse(bytes.toString('utf8', start, end));
+
+/** The key of the string token [start, end): its own bytes unless escaped. */
+function decodeKey(bytes, text, start, end) {
+  for (let k = start + 1; k < end - 1; k++) {
+    if (text.charCodeAt(k) === BACKSLASH) return decodeSlice(bytes, start, end);
+  }
+  return bytes.toString('utf8', start + 1, end - 1);
+}
+
+function defineMember(target, key, value) {
+  // JSON.parse creates own data properties, `__proto__` included.
+  Object.defineProperty(target, key, { value, writable: true, enumerable: true, configurable: true });
+}
+
+// "role" spelled with escapes is at most 6 escapes of 6 chars plus quotes.
+const MAX_ESCAPED_ROLE_KEY = 26;
+
+/** One `messages` element [start, ...): `{ end, item }`, or null. */
+function messageElement(bytes, text, start, fullRoles) {
+  if (text.charCodeAt(start) !== OPEN_OBJECT) {
+    const end = valueEnd(text, start);
+    return end === -1 ? null : { end, item: decodeSlice(bytes, start, end) };
+  }
+  let i = skipSpaces(text, start + 1);
+  let role;
+  let hasRole = false;
+  if (text.charCodeAt(i) === CLOSE_OBJECT) return { end: i + 1, item: {} };
+  for (;;) {
+    if (text.charCodeAt(i) !== QUOTE) return null;
+    const keyEnd = stringEnd(text, i);
+    if (keyEnd === -1) return null;
+    const isRole =
+      (keyEnd - i === 6 && text.startsWith('"role"', i)) ||
+      (keyEnd - i <= MAX_ESCAPED_ROLE_KEY && keyEnd - i > 6 && decodeKey(bytes, text, i, keyEnd) === 'role');
+    const colon = skipSpaces(text, keyEnd);
+    if (text.charCodeAt(colon) !== COLON) return null;
+    const valueStart = skipSpaces(text, colon + 1);
+    const end = valueEnd(text, valueStart);
+    if (end === -1) return null;
+    if (isRole) {
+      // Duplicate members resolve last-wins, as in the full parse.
+      role = decodeSlice(bytes, valueStart, end);
+      hasRole = true;
+    }
+    i = skipSpaces(text, end);
+    if (text.charCodeAt(i) === COMMA) {
+      i = skipSpaces(text, i + 1);
+      continue;
+    }
+    if (text.charCodeAt(i) !== CLOSE_OBJECT) return null;
+    const elementEnd = i + 1;
+    let item = {};
+    if (hasRole && fullRoles.has(role)) item = decodeSlice(bytes, start, elementEnd);
+    else if (hasRole) defineMember(item, 'role', role);
+    return { end: elementEnd, item };
+  }
+}
+
+/** The `messages` array [start, ...): `{ end, messages }`, or null. */
+function messagesValue(bytes, text, start, fullRoles) {
+  const messages = [];
+  let i = skipSpaces(text, start + 1);
+  if (text.charCodeAt(i) === CLOSE_ARRAY) return { end: i + 1, messages };
+  for (;;) {
+    const element = messageElement(bytes, text, i, fullRoles);
+    if (!element) return null;
+    messages.push(element.item);
+    i = skipSpaces(text, element.end);
+    if (text.charCodeAt(i) === COMMA) {
+      i = skipSpaces(text, i + 1);
+      continue;
+    }
+    return text.charCodeAt(i) === CLOSE_ARRAY ? { end: i + 1, messages } : null;
+  }
+}
+
+/**
+ * The proven-valid, duplicate-free root object of `bytes`, or null when
+ * validity could not be proven (or the document is not such an object). Of
+ * it only the members `decode(key)` accepts are decoded — `messages`, when an
+ * array, as described in the module comment with `fullMessageRoles`; every
+ * other member is validated and left out.
+ */
+export function provenTopLevelObject(bytes, decode, fullMessageRoles = EMPTY) {
+  try {
+    return provenDocument(bytes, decode, fullMessageRoles);
+  } catch {
+    return null;
+  }
+}
+
+function provenDocument(bytes, decode, fullRoles) {
+  const text = bytes.toString('latin1');
+  if (CONTROL_BYTE.test(text) || INVALID_ESCAPE.test(text)) return null;
+  let i = skipSpaces(text, 0);
+  if (text.charCodeAt(i) !== OPEN_OBJECT) return null;
+  const doc = {};
+  const seen = new Set();
+  i = skipSpaces(text, i + 1);
+  if (text.charCodeAt(i) === CLOSE_OBJECT) i++;
+  else {
+    for (;;) {
+      if (text.charCodeAt(i) !== QUOTE) return null;
+      const keyEnd = stringEnd(text, i);
+      if (keyEnd === -1) return null;
+      const key = decodeKey(bytes, text, i, keyEnd);
+      if (seen.has(key)) return null;
+      seen.add(key);
+      const colon = skipSpaces(text, keyEnd);
+      if (text.charCodeAt(colon) !== COLON) return null;
+      const start = skipSpaces(text, colon + 1);
+      const wanted = decode(key);
+      let end;
+      if (wanted && key === 'messages' && text.charCodeAt(start) === OPEN_ARRAY) {
+        const value = messagesValue(bytes, text, start, fullRoles);
+        if (!value) return null;
+        end = value.end;
+        defineMember(doc, key, value.messages);
+      } else {
+        end = valueEnd(text, start);
+        if (end === -1) return null;
+        if (wanted) defineMember(doc, key, decodeSlice(bytes, start, end));
+      }
+      i = skipSpaces(text, end);
+      if (text.charCodeAt(i) === COMMA) {
+        i = skipSpaces(text, i + 1);
+        continue;
+      }
+      if (text.charCodeAt(i) !== CLOSE_OBJECT) return null;
+      i++;
+      break;
+    }
+  }
+  return skipSpaces(text, i) === text.length ? doc : null;
+}
+
+/**
+ * `readTopLevelLifecycleRecord` of the UTF-8 document in `bytes`, with `doc`
+ * decoded as described above — only for a proven document; a record from the
+ * authoritative fallback carries the complete document. Consumers must read
+ * nothing but non-skipped fields and, of non-full messages, `role`.
+ */
+export function readStrictRecordFields(bytes, { skip = EMPTY, fullMessageRoles = EMPTY } = {}) {
+  const doc = provenTopLevelObject(bytes, (key) => !skip.has(key), fullMessageRoles);
+  return doc ? lifecycleRecordOf(doc) : readTopLevelLifecycleRecord(bytes.toString('utf8'));
+}

package/src/runtime/agent/orchestrator/session/store-summary-catalog.mjs

@@ -15,8 +15,9 @@ import { join } from 'node:path';
 // Leaf helpers only: the three-way present/absent/unreadable classification
 // and the strict record parser the authoritative store uses, so the catalog
 // cannot disagree with it.
-import { probePath, readTextFile, PROBE_PRESENT, PROBE_ABSENT } from './store/fs-probe.mjs';
-import { readTopLevelLifecycleRecord, isLifecycleUnreadable } from './lifecycle-scan.mjs';
+import { probePath, readBytesFile, readTextFile, PROBE_PRESENT, PROBE_ABSENT } from './store/fs-probe.mjs';
+import { isLifecycleUnreadable } from './lifecycle-scan.mjs';
+import { readStrictRecordFields } from './store-record-strict-scan.mjs';
 import { isAgentOnlySession, isRootLeadSession, sessionVisibility } from './store-summary-visibility.mjs';
 import { applySummaryLogText, summaryLogPath } from './store-summary-log.mjs';
 import { dataDir } from './store-summary-locations.mjs';
@@ -43,7 +44,7 @@ export const STAMP_ABSENT_CODES = new Set(['ENOENT', 'ENOTDIR']);
 /** The one catalog order of every listing path (JSON and DB): newest
  *  conversation activity first (see normalizedRow's lastUsedAt note), ties by
  *  id, so a fallback and the DB never disagree on equal activity times. */
-export const byCatalogOrder = byActivityThenId;
+const byCatalogOrder = byActivityThenId;
 
 // ── Stamp-keyed strict derivations ──────────────────────────────────────────
 // Session metadata and catalog rows are small values derived from a strict
@@ -52,8 +53,20 @@ export const byCatalogOrder = byActivityThenId;
 // proven to come from (stat → read → stat) and that stamp is past the racy
 // window. Any other file — changed, replaced by another writer, unreadable —
 // is read and strictly parsed again.
+// Bounded by count and by serialized size: nothing tells this map a session
+// file went away, so a churning host fills it with dead paths until LRU
+// eviction (`delete` + `set` on a hit keeps Map order least recent first).
 const STAMPED_DERIVATION_LIMIT = 2048;
-const stampedDerivations = new Map(); // `${kind}|${path}` → { stamp, value }
+const STAMPED_DERIVATION_MAX_BYTES = 8 * 1024 * 1024;
+const stampedDerivations = new Map(); // `${kind}|${path}` → { stamp, value, bytes }
+let stampedDerivationBytes = 0;
+
+function dropStampedDerivation(key) {
+  const entry = stampedDerivations.get(key);
+  if (!entry) return;
+  stampedDerivations.delete(key);
+  stampedDerivationBytes -= entry.bytes;
+}
 
 export function observeStamp(path) {
   try {
@@ -64,24 +77,35 @@ export function observeStamp(path) {
 }
 
 /** `{ state, value }`: `derive(text)` for the record at `path`, or its cached
- *  result while the file is provably unchanged. */
-export function stampedDerivation(kind, path, derive) {
+ *  result while the file is provably unchanged. `bytes`: `derive` gets the
+ *  raw Buffer instead of text. `stamp`: the caller's own stat of `path`,
+ *  taken just before, stands for the pre-read stat (one stat fewer). */
+export function stampedDerivation(kind, path, derive, { bytes = false, stamp } = {}) {
   const key = `${kind}|${path}`;
-  const before = observeStamp(path);
+  const before = stamp === undefined ? observeStamp(path) : stamp;
   const cached = stampedDerivations.get(key);
   if (before && cached && sameSessionStamp(cached.stamp, before)) {
     stampedDerivations.delete(key);
     stampedDerivations.set(key, cached);
     return { state: PROBE_PRESENT, value: cached.value };
   }
-  stampedDerivations.delete(key);
-  const read = readTextFile(path);
+  dropStampedDerivation(key);
+  const read = bytes ? readBytesFile(path) : readTextFile(path);
   if (read.state !== PROBE_PRESENT) return { state: read.state, value: null };
-  const value = derive(read.text);
+  const value = derive(bytes ? read.bytes : read.text);
   if (isSettledSessionStamp(before) && sameSessionStamp(before, observeStamp(path))) {
-    stampedDerivations.set(key, { stamp: before, value });
-    if (stampedDerivations.size > STAMPED_DERIVATION_LIMIT) {
-      stampedDerivations.delete(stampedDerivations.keys().next().value);
+    // UTF-16 code units of the key and the serialized value approximate the
+    // retained bytes; the strict parse just above dwarfs this stringify.
+    const size = 2 * (key.length + (JSON.stringify(value)?.length ?? 0));
+    if (size <= STAMPED_DERIVATION_MAX_BYTES) {
+      stampedDerivations.set(key, { stamp: before, value, bytes: size });
+      stampedDerivationBytes += size;
+      while (
+        stampedDerivations.size > STAMPED_DERIVATION_LIMIT ||
+        stampedDerivationBytes > STAMPED_DERIVATION_MAX_BYTES
+      ) {
+        dropStampedDerivation(stampedDerivations.keys().next().value);
+      }
     }
   }
   return { state: PROBE_PRESENT, value };
@@ -199,6 +223,24 @@ function leadRows(rows) {
   return rows.filter((row) => row && isLeadVisibleRow(row));
 }
 
+// What a row derivation decodes of a record (store-record-strict-scan.mjs):
+// rowFromSession reads its user messages whole and only the role of the rest,
+// and never these top-level fields — together ~10% of a record, mostly tool
+// catalogs. Every other top-level field is decoded, so a field a row starts
+// to read is there without touching this list.
+const CATALOG_RECORD_READ = {
+  skip: new Set([
+    'tools',
+    'deferredToolCatalog',
+    'deferredLateToolCatalog',
+    'bp3CoreContext',
+    'bp3EnvironmentContext',
+    'compaction',
+    'pendingDeferredToolDelta',
+  ]),
+  fullMessageRoles: new Set(['user']),
+};
+
 function rowFromSession(session) {
   const messages = Array.isArray(session?.messages) ? session.messages : [];
   const preview =
@@ -259,14 +301,21 @@ function reconcileSessionFile(directory, storageId, retained, forceRead) {
     return { kind: 'indexed', ...fingerprint };
   }
   // A file the index does not describe (never saved by the store, or
-  // saved after the index was written) is parsed once per full stamp.
-  const read = stampedDerivation('row', path, (text) => {
-    // Same strict authority as the store: a duplicate/ambiguous top-level
-    // record or a foreign identity is not this file's session.
-    const record = readTopLevelLifecycleRecord(text);
-    if (isLifecycleUnreadable(record) || record.id !== storageId) return null;
-    return rowFromSession(record.doc);
-  });
+  // saved after the index was written) is read once per full stamp; the
+  // stat above is the read's pre-read stat.
+  const read = stampedDerivation(
+    'row',
+    path,
+    (bytes) => {
+      // Same strict authority as the store: a duplicate/ambiguous top-level
+      // record or a foreign identity is not this file's session. Only what a
+      // row is made of is decoded (see CATALOG_RECORD_READ).
+      const record = readStrictRecordFields(bytes, CATALOG_RECORD_READ);
+      if (isLifecycleUnreadable(record) || record.id !== storageId) return null;
+      return rowFromSession(record.doc);
+    },
+    { bytes: true, stamp }
+  );
   if (read.state === PROBE_ABSENT) return null;
   // Exists and could not be read (EACCES/EIO): retain the last known row
   // rather than let a transient IO error delete it from view.

package/src/runtime/agent/orchestrator/session/store-summary-reader.mjs

@@ -24,6 +24,7 @@ import {
 } from './store-summary-catalog.mjs';
 import { createStoredTranscriptCache, nextProjectionStamp } from './store-transcript-cache.mjs';
 import {
+  forgetStoredTranscriptOffThread,
   OFFLOAD_MIN_CHARS,
   projectStoredTranscriptOffThread,
   storedTranscriptWorkerRunning,
@@ -35,6 +36,7 @@ import { readArchivedAgentResult } from './store-summary-archived-agent.mjs';
 import { compactionArchivePath, readCompactionArchivePage } from './compaction-archive.mjs';
 import { currentSessionCatalogDb, onSessionCatalogDbChange, sessionCatalogDb } from './catalog-db/index.mjs';
 import { decodeCatalogCursor, encodeCatalogCursor, isAfterCursor } from './catalog-db/schema.mjs';
+import { onSessionActivityChange } from '../../../shared/session-activity-signal.mjs';
 import {
   readCanonicalSessionRecord as readCanonicalLifecycle,
   offerStrictSessionRecord,
@@ -45,7 +47,11 @@ import {
 // Worker-pool row projection (child + Lead indexes, live-work evidence) lives
 // in store-agent-worker-rows.mjs; re-exported so prior importers of this
 // module stay unchanged.
-export { listStoredAgentWorkerLinks, listStoredAgentWorkers } from './store-agent-worker-rows.mjs';
+export {
+  listStoredAgentWorkerLinks,
+  listStoredAgentWorkers,
+  listStoredAgentWorkersAsync,
+} from './store-agent-worker-rows.mjs';
 export { storedAgentWorkerIndexPath } from './store-summary-locations.mjs';
 
 // One cache per process: the daemon serves every cold pane read from it, and
@@ -59,7 +65,9 @@ export function clearStoredTranscriptCache() {
 
 /** Drop one session's cold projections: it went live, or its last view left. */
 export function forgetStoredSessionTranscript(sessionId) {
-  storedTranscriptCache.forget(`${String(sessionId || '').trim()}|`);
+  const id = String(sessionId || '').trim();
+  storedTranscriptCache.forget(`${id}|`);
+  if (id) forgetStoredTranscriptOffThread(id);
 }
 
 /** Its last view left: keep the cold projections for a revisit, within the
@@ -82,18 +90,22 @@ export function storedTranscriptCacheStats() {
 const ordinaryCatalog = createOrdinaryCatalog();
 const catalogListeners = new Set();
 
-function notifyCatalogListeners() {
+function notifyCatalogListeners(kind = 'catalog') {
   for (const listener of catalogListeners) {
     try {
-      listener();
+      listener(kind);
     } catch {
       /* a listener's failure is its own */
     }
   }
 }
 
-ordinaryCatalog.subscribe(notifyCatalogListeners);
-onSessionCatalogDbChange(notifyCatalogListeners);
+ordinaryCatalog.subscribe(() => notifyCatalogListeners());
+onSessionCatalogDbChange(() => notifyCatalogListeners());
+// Runtime activity transitions (turn start/settle, task wait, background
+// hand-off/finish) change only the Agents pool projection: `agent-activity`
+// lets the reader refresh just that, at once.
+onSessionActivityChange(() => notifyCatalogListeners('agent-activity'));
 
 /** `listener()` runs when a background pass finds a session file that changed
  *  without a directory or index change, i.e. when an ordinary listing would
@@ -292,29 +304,32 @@ export function storedSessionTranscriptStamp(id) {
   return archive ? `${record}|${checkpoint}|${archive}` : null;
 }
 
+/** A large record with no checkpoint sidecar is read, digested, parsed and
+ *  projected on a worker thread: the same pipeline, off the daemon event
+ *  loop. It hands no parse to the load cache (a later resume reads the file
+ *  itself). The answer is the cache's `project` contract; a worker failure
+ *  rejects and the cache runs the in-process pipeline instead. */
+async function projectStoredTranscriptElsewhere(known, context) {
+  const { sessionId, recordPath, itemLimit, timing } = context;
+  timing.worker = storedTranscriptWorkerRunning(sessionId) ? 'warm' : 'cold';
+  const workerStartedAt = performance.now();
+  const answer = await projectStoredTranscriptOffThread({ sessionId, recordPath, itemLimit, known });
+  timing.workerMs = performance.now() - workerStartedAt;
+  Object.assign(timing, answer.timing);
+  context.readState = answer.state;
+  if (answer.state !== PROBE_PRESENT) return null;
+  if (answer.same) return answer;
+  if (answer.unreadable) return { ...answer, value: null };
+  if (answer.stamp) readCanonicalLifecycle.rememberStrictVerdict(recordPath, answer.stamp, answer.lifecycle);
+  // Stamps are process-unique per module realm; re-issue in this one.
+  answer.value.projectionStamp = nextProjectionStamp();
+  return answer;
+}
+
 /** Projects the strictly parsed record `text` (read at full stamp `stamp`, or
  *  null when not provably stable) into the cached transcript value. */
 async function produceStoredTranscript(text, stamp, context) {
-  const { sessionId, recordPath, itemLimit, includeMessages, mode, offloadable, checkpointAbsent, timing } = context;
-  // A large record with no checkpoint sidecar parses and projects on a
-  // worker thread: the same pipeline, off the daemon event loop. It hands
-  // no parse to the load cache (a later resume reads the file itself).
-  if (offloadable && text.length >= OFFLOAD_MIN_CHARS) {
-    try {
-      timing.worker = storedTranscriptWorkerRunning() ? 'warm' : 'cold';
-      const workerStartedAt = performance.now();
-      const answer = await projectStoredTranscriptOffThread({ sessionId, text, itemLimit });
-      timing.workerMs = performance.now() - workerStartedAt;
-      Object.assign(timing, answer.timing);
-      if (answer.unreadable) return null;
-      if (stamp) readCanonicalLifecycle.rememberStrictVerdict(recordPath, stamp, answer.lifecycle);
-      // Stamps are process-unique per module realm; re-issue in this one.
-      answer.value.projectionStamp = nextProjectionStamp();
-      return answer.value;
-    } catch {
-      // Worker unavailable: fall through to the in-process pipeline.
-    }
-  }
+  const { sessionId, recordPath, itemLimit, includeMessages, mode, checkpointAbsent, timing } = context;
   const parseStartedAt = performance.now();
   const record = readTopLevelLifecycleRecord(text);
   timing.parseMs = performance.now() - parseStartedAt;
@@ -388,7 +403,6 @@ export async function readStoredSessionTranscript(id, options = {}) {
   const archive = probePath(archivePath);
   const requestedLimit = Number(options.transcriptItemLimit);
   const itemLimit = Number.isFinite(requestedLimit) && requestedLimit > 0 ? requestedLimit : Number.POSITIVE_INFINITY;
-  let readState = PROBE_PRESENT;
   // Full stamp the loaded text provably came from (unchanged around the
   // read), or null. Only such a parse may serve other readers.
   let readStamp = null;
@@ -405,9 +419,10 @@ export async function readStoredSessionTranscript(id, options = {}) {
     itemLimit,
     includeMessages,
     mode,
-    offloadable,
     checkpointAbsent,
     timing,
+    // How the record read went (the worker's read or loadText below).
+    readState: PROBE_PRESENT,
   };
   const { value, hit, read } = await storedTranscriptCache.read({
     key: `${sessionId}|${itemLimit}|${mode}`,
@@ -425,6 +440,7 @@ export async function readStoredSessionTranscript(id, options = {}) {
       archive.size,
     ].join(':'),
     fileStat: recordStat,
+    project: offloadable ? (known) => projectStoredTranscriptElsewhere(known, produceContext) : null,
     loadText: async () => {
       const readStartedAt = performance.now();
       const before = observeStamp(recordPath);
@@ -440,7 +456,7 @@ export async function readStoredSessionTranscript(id, options = {}) {
       }
       body ||= readTextFile(recordPath);
       timing.readMs = performance.now() - readStartedAt;
-      readState = body.state;
+      produceContext.readState = body.state;
       if (body.state !== PROBE_PRESENT) return null;
       readStamp = before && sameSessionStamp(before, observeStamp(recordPath)) ? before : null;
       return body.text;
@@ -448,7 +464,7 @@ export async function readStoredSessionTranscript(id, options = {}) {
     produce: (text) => produceStoredTranscript(text, readStamp, produceContext),
   });
   // The record vanished between stat and read: same answer as an absent probe.
-  if (readState === PROBE_ABSENT) return readVanishedSessionTranscript(sessionId);
+  if (produceContext.readState === PROBE_ABSENT) return readVanishedSessionTranscript(sessionId);
   if (typeof options.trace === 'function') {
     options.trace({
       sessionId,