mixdog 1.4.1 → 1.4.2

package/src/runtime/agent/orchestrator/session/store-transcript-cache.mjs

@@ -17,9 +17,9 @@
 
 import { createHash } from 'node:crypto';
 
-// Serialized (UTF-8 JSON) bytes of the retained PROJECTIONS. A tail-window
-// projection is ~0.1-1 MB; a legacy 512-item page of a worker transcript can
-// reach ~16 MB, so this keeps a couple of those or dozens of tail windows.
+// Serialized (UTF-8 JSON) bytes of the retained PROJECTIONS: windows and pages
+// sliced from a session's display history (which itself stays with the thread
+// that built it); one larger than the whole budget is not retained.
 const STORED_TRANSCRIPT_CACHE_MAX_BYTES = 32 * 1024 * 1024;
 // Coarse filesystems stamp mtime at whole seconds (FAT: two). A write landing
 // inside that window after our read could keep the same stat, so only a file
@@ -70,22 +70,42 @@ export function nextProjectionStamp() {
   return `${stampEpoch}:${stampSequence}`;
 }
 
-export function createStoredTranscriptCache({
-  // Bound retained content, not the number of small sessions. An eight-entry
-  // LRU reparsed every unchanged record when nine visible sessions refreshed.
-  maxEntries = Number.POSITIVE_INFINITY,
-  maxBytes = STORED_TRANSCRIPT_CACHE_MAX_BYTES,
-  maxIdleBytes = STORED_TRANSCRIPT_IDLE_MAX_BYTES,
-} = {}) {
+const producedSlices = new WeakSet();
+/** What a `produce` returns for a slice of a display history it may already
+ *  hold: the value, its serialized `bytes` (measured by the producer) and
+ *  whether a history was built for it (`historyBuilt`). */
+export function producedSlice(value, { bytes = null, historyBuilt = true } = {}) {
+  const slice = { value, bytes, historyBuilt };
+  producedSlices.add(slice);
+  return slice;
+}
+
+/** This realm's stamp epoch (a worker composes history stamps with its
+ *  caller's). */
+export function projectionStampEpoch() {
+  return stampEpoch;
+}
+
+/** The identity of one display history: its session, record content and
+ *  sidecar fingerprint, within one process epoch (a restart re-proves held
+ *  rows by digest). Every slice of the history shares it, whichever thread
+ *  built it and however often, so held rows stay proven across pages,
+ *  evictions and worker restarts. */
+export function historyStampOf(sessionId, textHash, textChars, fingerprint, epoch = stampEpoch) {
+  const id = createHash('sha256')
+    .update(`${sessionId}|${textHash}|${textChars}|${fingerprint}`)
+    .digest('base64url')
+    .slice(0, 22);
+  return `${epoch}:h${id}`;
+}
+
+/** The retained entries and their eviction policy: byte/entry budget, paging
+ *  pins, ghost admission and idle trimming. */
+function createEntryStore({ maxEntries, maxBytes, maxIdleBytes }) {
   // Retain a content digest, not a second full transcript beside its projection.
   // The bound is the size of what is actually retained: the projection.
   /** key -> { textHash, textChars, bytes, group, fingerprint, value, usedAt } (Map order is LRU order). */
   const entries = new Map();
-  /** key -> { text, fingerprint, promise } for reads still parsing. */
-  const inFlight = new Map();
-  /** key -> { fingerprint, fileStat, promise } for reads not yet answered,
-   *  from before their body is loaded. */
-  const reading = new Map();
   /** Keys evicted for space (insertion order = age), bounded. */
   const ghosts = new Set();
   let retainedBytes = 0;
@@ -104,8 +124,21 @@ export function createStoredTranscriptCache({
   };
   const overBudget = (extraEntries = 0, extraBytes = 0) =>
     entries.size + extraEntries > maxEntries || retainedBytes + extraBytes > maxBytes;
-  const prune = () => {
-    while (entries.size > 0 && overBudget()) evict(entries.keys().next().value);
+  // A history a reader is paging through (read with `pin` within
+  // ACTIVE_ENTRY_MS) stays cached under pressure: every page would otherwise
+  // build it again.
+  const paging = (entry, now) => now - entry.pinnedAt <= ACTIVE_ENTRY_MS;
+  // The newest entry stays (never larger than the budget: remember refuses
+  // those). For an unpinned newcomer, entries being paged are not evicted; a
+  // pinned one evicts whatever exceeds the budget, pinned or not.
+  const prune = (now, keepPaging) => {
+    const listed = [...entries];
+    const newest = listed.at(-1)?.[0];
+    for (const [key, entry] of listed) {
+      if (!overBudget()) return;
+      if (key === newest || (keepPaging && paging(entry, now))) continue;
+      evict(key);
+    }
   };
   // A returning ghost may displace only idle entries (oldest first).
   const makeRoomForGhost = (bytes, now) => {
@@ -123,25 +156,37 @@ export function createStoredTranscriptCache({
     for (const other of idle) evict(other);
     return true;
   };
-  const remember = (key, group, textChars, textHash, fingerprint, fileStat, value, now) => {
+  const remember = (key, group, textChars, textHash, fingerprint, fileStat, value, now, pin, measured) => {
     drop(key);
     // One entry per group: a growing history window replaces its smaller
     // predecessor instead of accumulating beside it.
     if (group !== null) {
       for (const [other, entry] of [...entries]) if (entry.group === group) drop(other);
     }
-    const bytes = Buffer.byteLength(JSON.stringify(value));
+    // Values are slices (a window or page), never a whole history; the
+    // producer's own measure is used when it has one.
+    const bytes = Number.isSafeInteger(measured) && measured >= 0 ? measured : Buffer.byteLength(JSON.stringify(value));
+    // Larger than the whole budget: served uncached, pinned or not.
     if (bytes > maxBytes) return;
-    if (ghosts.has(key)) {
-      if (!makeRoomForGhost(bytes, now)) return;
-      ghosts.delete(key);
+    if (pin) ghosts.delete(key);
+    else {
+      if (ghosts.has(key)) {
+        if (!makeRoomForGhost(bytes, now)) return;
+        ghosts.delete(key);
+      }
+      // Never in place of a history being paged: served uncached instead.
+      let pagedBytes = 0;
+      for (const entry of entries.values()) if (paging(entry, now)) pagedBytes += entry.bytes;
+      if (pagedBytes > 0 && pagedBytes + bytes > maxBytes) return;
     }
-    entries.set(key, { textChars, textHash, bytes, group, fingerprint, fileStat, value, usedAt: now });
+    const pinnedAt = pin ? now : Number.NEGATIVE_INFINITY;
+    entries.set(key, { textChars, textHash, bytes, group, fingerprint, fileStat, value, usedAt: now, pinnedAt });
     retainedBytes += bytes;
-    prune();
+    prune(now, !pin);
   };
-  const touch = (key, entry, now) => {
+  const touch = (key, entry, now, pin = false) => {
     entry.usedAt = now;
+    if (pin) entry.pinnedAt = now;
     entries.delete(key);
     entries.set(key, entry);
   };
@@ -168,14 +213,59 @@ export function createStoredTranscriptCache({
       : null;
   };
 
+  return {
+    get: (key) => entries.get(key),
+    remember,
+    touch,
+    trimIdle,
+    entryWithContent,
+    release(keyPrefix, now) {
+      for (const [key, entry] of entries) {
+        if (key.startsWith(keyPrefix)) entry.usedAt = Math.min(entry.usedAt, now - ACTIVE_ENTRY_MS - 1);
+      }
+      trimIdle(now);
+    },
+    forget(keyPrefix) {
+      for (const key of [...entries.keys()]) {
+        if (key.startsWith(keyPrefix)) drop(key);
+      }
+      for (const key of [...ghosts]) {
+        if (key.startsWith(keyPrefix)) ghosts.delete(key);
+      }
+    },
+    clear() {
+      entries.clear();
+      ghosts.clear();
+      retainedBytes = 0;
+    },
+    stats: () => ({ entries: entries.size, retainedBytes, ghosts: ghosts.size }),
+  };
+}
+
+export function createStoredTranscriptCache({
+  // Bound retained content, not the number of small sessions. An eight-entry
+  // LRU reparsed every unchanged record when nine visible sessions refreshed.
+  maxEntries = Number.POSITIVE_INFINITY,
+  maxBytes = STORED_TRANSCRIPT_CACHE_MAX_BYTES,
+  maxIdleBytes = STORED_TRANSCRIPT_IDLE_MAX_BYTES,
+} = {}) {
+  const store = createEntryStore({ maxEntries, maxBytes, maxIdleBytes });
+  /** key -> { text, fingerprint, promise } for reads still parsing. */
+  const inFlight = new Map();
+  /** key -> { fingerprint, fileStat, promise } for reads not yet answered,
+   *  from before their body is loaded. */
+  const reading = new Map();
+  // Projections produced (here or by `project`), cached or not.
+  let builds = 0;
+
   // `project(known)` reads, digests and projects the record elsewhere (a
   // worker thread) in one step: `{ textChars, textHash, value }`, or
   // `{ textChars, textHash, same: true }` without a projection when the
   // content is the `known` digest of the cached entry; null when the record
   // cannot be read. Undefined when it could not answer at all.
-  async function readProjected({ key, group, fingerprint, fileStat, project, now }) {
+  async function readProjected({ key, group, fingerprint, fileStat, project, now, pin }) {
     for (let attempt = 0; attempt < 2; attempt += 1) {
-      const cached = entries.get(key);
+      const cached = store.get(key);
       const known =
         attempt === 0 && cached?.fingerprint === fingerprint
           ? { textChars: cached.textChars, textHash: cached.textHash }
@@ -195,38 +285,52 @@ export function createStoredTranscriptCache({
       if (answer === undefined) return undefined;
       if (answer === null || typeof answer !== 'object') return { value: null, hit: false, read: true };
       if (answer.same === true) {
-        const entry = entryWithContent(key, fingerprint, answer);
+        const entry = store.entryWithContent(key, fingerprint, answer);
         // Evicted meanwhile: project it after all.
         if (!entry) continue;
         entry.fileStat = fileStat;
-        touch(key, entry, now);
+        store.touch(key, entry, now, pin);
         return { value: entry.value, hit: true, read: true };
       }
       const value = answer.value ?? null;
+      // A worker that served the slice from a history it already held built nothing.
+      const built = Boolean(value && typeof value === 'object' && answer.historyBuilt !== false);
+      if (built) builds += 1;
       if (current && value && typeof value === 'object') {
-        remember(key, group, answer.textChars, answer.textHash, fingerprint, fileStat, value, now);
+        store.remember(
+          key,
+          group,
+          answer.textChars,
+          answer.textHash,
+          fingerprint,
+          fileStat,
+          value,
+          now,
+          pin,
+          answer.bytes
+        );
       }
-      return { value, hit: false, read: true };
+      return { value, hit: false, read: true, built };
     }
     return undefined;
   }
 
-  async function readFresh({ key, group, fingerprint, fileStat, loadText, produce, project, now }) {
+  async function readFresh({ key, group, fingerprint, fileStat, loadText, produce, project, now, pin }) {
     if (typeof project === 'function') {
-      const answered = await readProjected({ key, group, fingerprint, fileStat, project, now });
+      const answered = await readProjected({ key, group, fingerprint, fileStat, project, now, pin });
       if (answered !== undefined) return answered;
       // It could not answer (worker unavailable): load and produce here.
     }
-    const cached = entries.get(key);
+    const cached = store.get(key);
     // `loadText` may answer asynchronously (a large record is read without
     // blocking the loop); a plain string is unchanged.
     let text = loadText();
     if (typeof text?.then === 'function') text = await text;
     if (typeof text !== 'string') return { value: null, hit: false, read: true };
     const textHash = transcriptTextHash(text);
-    if (cached && entryWithContent(key, fingerprint, { textChars: text.length, textHash }) === cached) {
+    if (cached && store.entryWithContent(key, fingerprint, { textChars: text.length, textHash }) === cached) {
       cached.fileStat = fileStat;
-      touch(key, cached, now);
+      store.touch(key, cached, now, pin);
       return { value: cached.value, hit: true, read: true };
     }
     const pending = inFlight.get(key);
@@ -234,17 +338,23 @@ export function createStoredTranscriptCache({
       return { value: await pending.promise, hit: true, read: true };
     }
     const record = { text, fingerprint, promise: null };
+    let built = false;
     const promise = (async () => {
-      const value = await produce(text);
+      const produced = await produce(text);
+      const slice = producedSlices.has(produced) ? produced : null;
+      const value = slice ? slice.value : produced;
+      built = Boolean(value && typeof value === 'object' && slice?.historyBuilt !== false);
+      if (built) builds += 1;
       if (inFlight.get(key) === record && value && typeof value === 'object') {
-        remember(key, group, text.length, textHash, fingerprint, fileStat, value, now);
+        store.remember(key, group, text.length, textHash, fingerprint, fileStat, value, now, pin, slice?.bytes);
       }
       return value;
     })();
     record.promise = promise;
     inFlight.set(key, record);
     try {
-      return { value: await promise, hit: false, read: true };
+      const value = await promise;
+      return { value, hit: false, read: true, built };
     } finally {
       if (inFlight.get(key) === record) inFlight.delete(key);
     }
@@ -256,7 +366,9 @@ export function createStoredTranscriptCache({
      *  `project` run only when stat alone cannot vouch for the entry.
      *  Concurrent callers with the same content share one parse; callers of
      *  one unchanged, settled file share one read before it is even loaded.
-     *  Entries naming the same `group` replace each other. */
+     *  Entries naming the same `group` replace each other. `pin`: a reader is
+     *  paging through this entry — it is cached however full the cache is,
+     *  and for ACTIVE_ENTRY_MS no unpinned newcomer evicts it. */
     async read({
       key,
       group = null,
@@ -266,11 +378,12 @@ export function createStoredTranscriptCache({
       produce,
       project = null,
       now = Date.now(),
+      pin = false,
     }) {
-      trimIdle(now);
-      const cached = entries.get(key);
+      store.trimIdle(now);
+      const cached = store.get(key);
       if (cached && cached.fingerprint === fingerprint && settledSameFile(cached.fileStat, fileStat, now)) {
-        touch(key, cached, now);
+        store.touch(key, cached, now, pin);
         return { value: cached.value, hit: true, read: false };
       }
       const joined = reading.get(key);
@@ -280,7 +393,7 @@ export function createStoredTranscriptCache({
         if (value) return { value, hit: true, read: false };
       }
       const record = { fingerprint, fileStat, promise: null };
-      record.promise = readFresh({ key, group, fingerprint, fileStat, loadText, produce, project, now });
+      record.promise = readFresh({ key, group, fingerprint, fileStat, loadText, produce, project, now, pin });
       reading.set(key, record);
       try {
         return await record.promise;
@@ -291,10 +404,7 @@ export function createStoredTranscriptCache({
     /** The last view of these projections left: they turn idle now and stay
      *  only within the idle budget, ready for a revisit. */
     release(keyPrefix, now = Date.now()) {
-      for (const [key, entry] of entries) {
-        if (key.startsWith(keyPrefix)) entry.usedAt = Math.min(entry.usedAt, now - ACTIVE_ENTRY_MS - 1);
-      }
-      trimIdle(now);
+      store.release(keyPrefix, now);
     },
     forget(keyPrefix) {
       for (const pending of [inFlight, reading]) {
@@ -302,28 +412,17 @@ export function createStoredTranscriptCache({
           if (key.startsWith(keyPrefix)) pending.delete(key);
         }
       }
-      for (const key of [...entries.keys()]) {
-        if (key.startsWith(keyPrefix)) drop(key);
-      }
-      for (const key of [...ghosts]) {
-        if (key.startsWith(keyPrefix)) ghosts.delete(key);
-      }
+      store.forget(keyPrefix);
     },
     clear() {
-      entries.clear();
+      store.clear();
       inFlight.clear();
       reading.clear();
-      ghosts.clear();
-      retainedBytes = 0;
+      builds = 0;
     },
     stats() {
-      return {
-        entries: entries.size,
-        retainedBytes,
-        inFlight: inFlight.size,
-        reading: reading.size,
-        ghosts: ghosts.size,
-      };
+      const { entries, retainedBytes, ghosts } = store.stats();
+      return { entries, retainedBytes, inFlight: inFlight.size, reading: reading.size, ghosts, builds };
     },
   };
 }

package/src/runtime/agent/orchestrator/session/store-transcript-projection.mjs

@@ -107,27 +107,186 @@ export async function prepareStoredTranscriptBase(sessionId, doc, options) {
   };
 }
 
-/** One transcript window (`options.itemLimit`, default whole) of a base. */
+/** The digest a paged caller proves its held rows with: over their wire form,
+ *  as the caller serializes them. */
+export async function heldRowsDigester() {
+  const [{ sanitizeForWire }, { transcriptItemsDigest }] = await Promise.all([
+    import('../../../../standalone/session-wire-values.mjs'),
+    import('../../../../standalone/session-state-patch.mjs'),
+  ]);
+  return (rows) => transcriptItemsDigest(rows.map((row) => sanitizeForWire(row, 2) ?? null));
+}
+
+/** The rows a page reveals never go below this many whatever their size, so
+ *  paging always progresses (the caller's own floor). */
+const PAGE_MIN_ROWS = 8;
+
+/** The slice of a whole display history (windowStoredTranscript with
+ *  `history`) one read receives (`request`):
+ *  - `held` (`{ firstId, count, digest }`, the newest rows a paged caller
+ *    holds): when the history's newest `held.count` rows are those rows (same
+ *    first id and — unless `proven` — the same `digestOf` digest), only the
+ *    rows above them: at most `maxRows` (and `limit - held.count`) within
+ *    `byteBudget` (`rowBytes(index)`), never fewer than PAGE_MIN_ROWS, with
+ *    `heldProven`. Unproven: a tail of at most `maxRows` rows instead
+ *    (`heldProven: false`).
+ *  - otherwise its newest `limit` rows but the newest `skip` (with
+ *    `skippedFirstId`, the oldest skipped row) — or, without a finite limit
+ *    (the legacy whole read), every restored row and none of the compaction
+ *    archive.
+ *  `windowStamp` names the slice within the history (the caller composes the
+ *  projection stamp). Slicing only: whatever the depth, a slice carries only
+ *  its own rows, and the history never leaves the thread that built it. */
+export function storedHistorySlice(history, request = {}, { digestOf = null, rowBytes = null } = {}) {
+  if (!history || typeof history !== 'object' || !Array.isArray(history.items)) return history;
+  const { transcriptArchivedRows: archivedRows = 0, items, projectionStamp: _stamp, ...fields } = history;
+  const sizeOf =
+    typeof rowBytes === 'function' ? rowBytes : (index) => Buffer.byteLength(JSON.stringify(items[index] ?? null));
+  if (request.cursor) return historyCursorSlice(fields, items, request.cursor, history.transcriptHasOlder, sizeOf);
+  const itemLimit = Number(request.limit);
+  if (!Number.isFinite(itemLimit)) {
+    return {
+      ...fields,
+      windowStamp: 'whole',
+      items: archivedRows > 0 ? items.slice(archivedRows) : items.slice(),
+      transcriptHasOlder: false,
+    };
+  }
+  const limit = Math.max(0, Math.floor(itemLimit));
+  const held = request.held;
+  if (held) {
+    const maxRows = Math.max(1, Math.floor(Number(request.maxRows) || limit));
+    const end = items.length - held.count;
+    const holds =
+      end >= 0 &&
+      items[end]?.id === held.firstId &&
+      (request.proven === true || (typeof digestOf === 'function' && digestOf(items.slice(end)) === held.digest));
+    if (!holds) {
+      // A fresh tail of one answer, within the same byte budget (and floor).
+      const start = budgetedEdge(items.length, -1, items.length, Math.min(limit, maxRows), request.byteBudget, sizeOf);
+      return {
+        ...fields,
+        windowStamp: `${items.length - start}`,
+        items: items.slice(start),
+        transcriptHasOlder: start > 0 || history.transcriptHasOlder === true,
+        heldProven: false,
+      };
+    }
+    const rows = Math.max(0, Math.min(maxRows, limit - held.count));
+    const start = budgetedEdge(end, -1, items.length, rows, request.byteBudget, sizeOf);
+    return {
+      ...fields,
+      windowStamp: `${items.length - start}@${held.count}`,
+      items: items.slice(start, end),
+      transcriptHasOlder: start > 0 || history.transcriptHasOlder === true,
+      skippedFirstId: held.firstId,
+      heldProven: true,
+    };
+  }
+  const skipped = Math.max(0, Math.min(Math.floor(Number(request.skip) || 0), limit, items.length));
+  const end = items.length - skipped;
+  const start = Math.max(0, items.length - limit);
+  return {
+    ...fields,
+    windowStamp: skipped ? `${limit}@${skipped}` : `${limit}`,
+    items: items.slice(start, end),
+    transcriptHasOlder: start > 0 || history.transcriptHasOlder === true,
+    ...(skipped ? { skippedFirstId: items[end]?.id ?? null } : {}),
+  };
+}
+
+/** The far edge of a run of at most `rows` rows within `byteBudget`
+ *  (`sizeOf(index)`), never fewer than PAGE_MIN_ROWS whatever their size:
+ *  older (`step` -1) ending just before index `from`, or newer (`step` +1)
+ *  starting at it. */
+function budgetedEdge(from, step, length, rows, byteBudget, sizeOf) {
+  const budget = Number(byteBudget) > 0 ? Number(byteBudget) : null;
+  const floor = Math.min(rows, PAGE_MIN_ROWS);
+  let edge = from;
+  let taken = 0;
+  let bytes = 0;
+  while (taken < rows) {
+    const index = step < 0 ? edge - 1 : edge;
+    if (index < 0 || index >= length) break;
+    const next = budget ? sizeOf(index) : 0;
+    if (budget && taken >= floor && bytes + next > budget) break;
+    bytes += next;
+    taken += 1;
+    edge += step;
+  }
+  return edge;
+}
+
+/** The most rows one historical-position read carries, whatever it asks. */
+export const CURSOR_PAGE_MAX_ROWS = 512;
+
+/** A cursor's page size: 1 to CURSOR_PAGE_MAX_ROWS rows. */
+export function cursorPageRows(maxRows) {
+  return Math.min(CURSOR_PAGE_MAX_ROWS, Math.max(1, Math.floor(Number(maxRows) || 1)));
+}
+
+/** A historical-position read (`cursor`: `{ before | after, maxRows,
+ *  byteBudget }`): the rows directly older than row `before`, or newer than
+ *  row `after`, at most `maxRows` within `byteBudget` (PAGE_MIN_ROWS floor),
+ *  with whether rows remain past them each way. Rows are located by their
+ *  stable id, so a page stays valid while the history only grows; a row the
+ *  history no longer holds (compaction, rewind, clear) answers
+ *  `cursorMissing`. */
+function historyCursorSlice(fields, items, cursor, olderBeyond, sizeOf) {
+  const older = cursor.before != null;
+  const id = older ? cursor.before : cursor.after;
+  const at = items.findIndex((item) => item?.id === id);
+  if (at < 0) return { ...fields, windowStamp: 'cursor', items: [], cursorMissing: true };
+  const rows = cursorPageRows(cursor.maxRows);
+  if (older) {
+    const start = budgetedEdge(at, -1, items.length, rows, cursor.byteBudget, sizeOf);
+    return {
+      ...fields,
+      windowStamp: 'cursor',
+      items: items.slice(start, at),
+      transcriptHasOlder: start > 0 || olderBeyond === true,
+      transcriptHasNewer: true,
+    };
+  }
+  const end = budgetedEdge(at + 1, 1, items.length, rows, cursor.byteBudget, sizeOf);
+  return {
+    ...fields,
+    windowStamp: 'cursor',
+    items: items.slice(at + 1, end),
+    transcriptHasOlder: true,
+    transcriptHasNewer: end < items.length,
+  };
+}
+
+/** One transcript window (`options.itemLimit`, default whole) of a base.
+ *  `options.history`: the whole display history instead — every restored row
+ *  after every row of the visible compaction archive, with
+ *  `transcriptArchivedRows` naming how many lead it. Every window is a tail
+ *  of it (storedHistoryWindow). */
 export async function windowStoredTranscript(sessionId, base, options) {
   const { session, messages, contextFields } = base;
   const { restoreTranscriptItems } = await import('./transcript-restore/restore.mjs');
+  const history = options.history === true;
   // Restoring one item past a finite limit proves whether older history exists
   // without projecting it; restore ids are message-positional, so the kept
   // tail is identical either way.
-  const itemLimit = Number.isFinite(options.itemLimit) ? options.itemLimit : Number.POSITIVE_INFINITY;
+  const itemLimit = !history && Number.isFinite(options.itemLimit) ? options.itemLimit : Number.POSITIVE_INFINITY;
   const restored = restoreTranscriptItems(messages, { sessionId, itemLimit: itemLimit + 1 });
   let transcriptHasOlder = restored.length > itemLimit;
   let items = transcriptHasOlder ? restored.slice(-itemLimit) : restored;
+  let archivedRows = 0;
   // A paged window continues past the first stored message into the
   // display-only compaction archive (newest segment first). A legacy whole
   // read never receives it.
-  const archiveRange = Number.isFinite(itemLimit) && !transcriptHasOlder ? compactionArchiveRange(session) : null;
+  const archiveRange =
+    history || (Number.isFinite(itemLimit) && !transcriptHasOlder) ? compactionArchiveRange(session) : null;
   if (archiveRange) {
     const archived = await readCompactionArchivePage(join(dataDir(), 'sessions'), sessionId, {
       ...archiveRange,
-      limit: itemLimit - restored.length,
+      limit: history ? Number.POSITIVE_INFINITY : itemLimit - restored.length,
     });
     if (archived.items.length) items = [...archived.items, ...restored];
+    archivedRows = archived.items.length;
     transcriptHasOlder = archived.hasOlder;
   }
   return {
@@ -136,6 +295,7 @@ export async function windowStoredTranscript(sessionId, base, options) {
     ...(options.includeMessages ? { messages } : {}),
     items,
     transcriptHasOlder,
+    ...(history ? { transcriptArchivedRows: archivedRows } : {}),
     provider: session.provider || '',
     model: session.model || '',
     effort: session.effort || '',