mixdog 1.2.5 → 1.3.0

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

@@ -15,11 +15,14 @@ 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';
+import { normalizeRoutineProvenance } from './routine-result.mjs';
+import { lastMessageLine, lastMessageSummary } from './store-summary-last-message.mjs';
 import {
   desktopSession,
   importKey,
@@ -30,6 +33,7 @@ import {
   workspaceSummary,
 } from './store-summary-fields.mjs';
 import { isRealTurnMessage } from './compact/user-message-kind.mjs';
+import { sessionModeOf } from './agent-mode.mjs';
 import { byActivityThenId } from './catalog-db/schema.mjs';
 import {
   sessionStampOf,
@@ -43,7 +47,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 +56,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 +80,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 };
@@ -167,6 +194,7 @@ export function normalizedRow(row) {
     status: String(row.status || (row.closed === true ? 'closed' : 'idle')),
     owner: row.owner || 'user',
     agent: row.agent || null,
+    sessionMode: sessionModeOf(row),
     sourceType: row.sourceType || null,
     sourceName: row.sourceName || null,
     scopeKey: row.scopeKey || null,
@@ -186,6 +214,10 @@ export function normalizedRow(row) {
     realTurnCount: realTurnCount(row),
     title: cleanText(row.title, 100),
     preview: cleanText(row.preview),
+    lastMessagePreview: cleanText(row.lastMessagePreview),
+    // Null for any line that is not a routine result, and on rows written
+    // before the marker existed (they show their plain text).
+    lastMessageRoutine: normalizeRoutineProvenance(row.lastMessageRoutine),
     generation: typeof row.generation === 'number' ? row.generation : 0,
     storageMtimeMs: positiveNumber(row.storageMtimeMs, 0),
     storageSize: positiveNumber(row.storageSize, 0),
@@ -199,6 +231,26 @@ 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, the newest messages back to
+// the one with a last-message line whole too, 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']),
+  fullTailUntil: (message) => Boolean(lastMessageLine(message)),
+};
+
 function rowFromSession(session) {
   const messages = Array.isArray(session?.messages) ? session.messages : [];
   const preview =
@@ -214,11 +266,15 @@ function rowFromSession(session) {
       )
       .map((message) => cleanText(messageText(message.content)))
       .find(Boolean) || '';
+  // The last-message line comes from the transcript like the summary index
+  // derives it; without it a session saved after the index was written lost
+  // its contact-row preview whenever its row came from this file read.
   return normalizedRow({
     ...session,
     messageCount: messages.filter((message) => message?.role === 'user' || message?.role === 'assistant').length,
     realTurnCount: messages.filter(isRealTurnMessage).length,
     preview,
+    ...lastMessageSummary(messages),
   });
 }
 
@@ -259,14 +315,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-index.mjs

@@ -16,8 +16,9 @@ import {
   writeJsonAtomicSync,
 } from '../../../shared/atomic-file.mjs';
 import { applySummaryLogText, encodeSummaryOps, summaryLogPath } from './store-summary-log.mjs';
-import { cleanSessionPreview, isSessionPreviewNoise, sessionMessageText } from '../runtime-core/session-text.mjs';
+import { isSessionPreviewNoise, sessionMessageText } from '../runtime-core/session-text.mjs';
 import { sessionVisibility } from './store-summary-visibility.mjs';
+import { sessionModeOf } from './agent-mode.mjs';
 import {
   importKey,
   inheritedFromSessionId,
@@ -27,6 +28,8 @@ import {
   workspaceSummary,
 } from './store-summary-fields.mjs';
 import { isRealTurnMessage } from './compact/user-message-kind.mjs';
+import { isRoutineResultMessage, normalizeRoutineProvenance, routineProvenance } from './routine-result.mjs';
+import { LAST_MESSAGE_PREVIEW_MAX, cleanSummaryPreview, lastMessageRawText } from './store-summary-last-message.mjs';
 
 export const SESSION_SUMMARY_INDEX_VERSION = 2;
 
@@ -37,15 +40,7 @@ export function summaryIndexPath() {
   return join(getPluginData(), 'session-summaries.json');
 }
 
-function _computeCleanPreview(text, max) {
-  const value = cleanSessionPreview(text, max);
-  return value.length > max
-    ? value
-        .slice(0, max)
-        .replace(/\s+\S*$/, '')
-        .trim()
-    : value;
-}
+const _computeCleanPreview = cleanSummaryPreview;
 
 // Every index flush re-normalizes EVERY row's stored title and preview, and
 // cleaning runs a chain of regex replaces that each allocate a copy. Those
@@ -79,8 +74,13 @@ const sessionMessageProjectionMemo = new WeakMap();
 // re-cleaned.
 const messagePreviewMemo = new WeakMap();
 
+// Routine results (a schedule's output in its owner's home thread) follow ONE
+// rule here: each is exactly one message of `messageCount` (so a thread's
+// unread count, messageCount minus the read cursor, rises by one per result),
+// never a real turn (`realTurnCount`), never the first-prompt `preview` the
+// title falls back to, and shown as its notice line in `lastMessagePreview`.
 function _previewFromMessage(message) {
-  if (message?.role !== 'user') return '';
+  if (message?.role !== 'user' || isRoutineResultMessage(message)) return '';
   const raw = sessionMessageText(message.content);
   const memo = messagePreviewMemo.get(message);
   if (memo && memo.raw === raw) return memo.preview;
@@ -89,6 +89,20 @@ function _previewFromMessage(message) {
   return preview;
 }
 
+// message → { raw, preview } for the LAST conversational message, user or
+// assistant alike (a messenger row's last-message line).
+const lastMessagePreviewMemo = new WeakMap();
+
+function _lastPreviewFromMessage(message) {
+  const raw = lastMessageRawText(message);
+  if (raw === null) return '';
+  const memo = lastMessagePreviewMemo.get(message);
+  if (memo && memo.raw === raw) return memo.preview;
+  const preview = isSessionPreviewNoise(raw) ? '' : _cleanPreview(raw, LAST_MESSAGE_PREVIEW_MAX);
+  lastMessagePreviewMemo.set(message, { raw, preview });
+  return preview;
+}
+
 function _sessionMessageProjection(session) {
   const messages = Array.isArray(session?.messages) ? session.messages : [];
   const cached = session && typeof session === 'object' ? sessionMessageProjectionMemo.get(session) : null;
@@ -134,6 +148,17 @@ function _sessionMessageProjection(session) {
       }
     }
   }
+  // The newest line, read back from the tail every time: a streamed reply
+  // fills its message in place. Tool-only and synthetic rows are skipped, and
+  // each message's text is memoized, so this stays a few lookups per save.
+  // The line's routine provenance rides along, so a client labels a routine
+  // result by this marker and never by the line's wording.
+  let last = '';
+  let lastRoutine = null;
+  for (let index = messages.length - 1; index >= 0 && !last; index -= 1) {
+    last = _lastPreviewFromMessage(messages[index]);
+    if (last) lastRoutine = routineProvenance(messages[index]);
+  }
   if (session && typeof session === 'object') {
     sessionMessageProjectionMemo.set(session, {
       length: messages.length,
@@ -144,7 +169,7 @@ function _sessionMessageProjection(session) {
       previewMessage,
     });
   }
-  return { count, real, preview };
+  return { count, real, preview, last, lastRoutine };
 }
 
 function _desktopSessionSummary(value, cwd = null) {
@@ -178,6 +203,8 @@ export function _sessionSummary(session) {
     status: String(session.status || (session.closed === true ? 'closed' : 'idle')),
     owner: session.owner || 'user',
     agent: session.agent || null,
+    // 'agent' | 'coding' (agent-mode.mjs); older records resolve it.
+    sessionMode: sessionModeOf(session),
     sourceType: session.sourceType || null,
     sourceName: session.sourceName || null,
     scopeKey: session.scopeKey || null,
@@ -209,6 +236,8 @@ export function _sessionSummary(session) {
     realTurnCount: messageProjection.real,
     title: _cleanPreview(session.title || '', 100),
     preview: messageProjection.preview,
+    lastMessagePreview: messageProjection.last,
+    lastMessageRoutine: messageProjection.lastRoutine,
     generation: typeof session.generation === 'number' ? session.generation : 0,
     storageMtimeMs: _positiveNumber(session.storageMtimeMs, 0),
     storageSize: _positiveNumber(session.storageSize, 0),
@@ -234,6 +263,7 @@ function _normalizeSummaryRow(row) {
     status: String(row.status || (row.closed === true ? 'closed' : 'idle')),
     owner: row.owner || 'user',
     agent: row.agent || null,
+    sessionMode: sessionModeOf(row),
     sourceType: row.sourceType || null,
     sourceName: row.sourceName || null,
     scopeKey: row.scopeKey || null,
@@ -264,6 +294,8 @@ function _normalizeSummaryRow(row) {
     realTurnCount: realTurnCount(row),
     title: _cleanPreview(row.title || '', 100),
     preview: _cleanPreview(row.preview || ''),
+    lastMessagePreview: _cleanPreview(row.lastMessagePreview || '', 160),
+    lastMessageRoutine: normalizeRoutineProvenance(row.lastMessageRoutine),
     generation: typeof row.generation === 'number' ? row.generation : 0,
     storageMtimeMs: _positiveNumber(row.storageMtimeMs, 0),
     storageSize: _positiveNumber(row.storageSize, 0),

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

@@ -0,0 +1,46 @@
+/**
+ * The summary's last-message line (a messenger row's preview): the newest
+ * user or assistant message with displayable text, and that line's routine
+ * provenance. Leaf module, shared by the summary index (store saves) and the
+ * catalog's strict file scan so both derive the same line.
+ */
+import { cleanSessionPreview, isSessionPreviewNoise, sessionMessageText } from '../runtime-core/session-text.mjs';
+import { plainPreviewText } from '../../../shared/plain-preview.mjs';
+import { isRoutineResultMessage, routineProvenance, routineResultNotice } from './routine-result.mjs';
+
+export const LAST_MESSAGE_PREVIEW_MAX = 160;
+
+/** cleanSessionPreview cut back to a word boundary within `max`. */
+export function cleanSummaryPreview(text, max) {
+  const value = cleanSessionPreview(text, max);
+  return value.length > max
+    ? value
+        .slice(0, max)
+        .replace(/\s+\S*$/, '')
+        .trim()
+    : value;
+}
+
+/** The raw text a conversational message contributes as the last line (a
+ *  routine result: its notice line); null for any other message. */
+export function lastMessageRawText(message) {
+  if (message?.role !== 'user' && message?.role !== 'assistant') return null;
+  return isRoutineResultMessage(message) ? routineResultNotice(message).text : sessionMessageText(message.content);
+}
+
+/** The message's last-message line, '' when it has none (tool-only, synthetic). */
+export function lastMessageLine(message) {
+  const raw = lastMessageRawText(message);
+  if (raw === null || isSessionPreviewNoise(raw)) return '';
+  return cleanSummaryPreview(plainPreviewText(raw), LAST_MESSAGE_PREVIEW_MAX);
+}
+
+/** `{ lastMessagePreview, lastMessageRoutine }` of a transcript. */
+export function lastMessageSummary(messages) {
+  const list = Array.isArray(messages) ? messages : [];
+  for (let index = list.length - 1; index >= 0; index -= 1) {
+    const line = lastMessageLine(list[index]);
+    if (line) return { lastMessagePreview: line, lastMessageRoutine: routineProvenance(list[index]) };
+  }
+  return { lastMessagePreview: '', lastMessageRoutine: null };
+}

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,

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

@@ -49,7 +49,3 @@ export function sessionVisibility(value) {
 export function isAgentOnlySession(value) {
   return sessionVisibility(value) === SESSION_VISIBILITY_AGENT_ONLY;
 }
-
-export function isOrdinarySession(value) {
-  return !isAgentOnlySession(value);
-}