mixdog 1.2.2 → 1.2.4

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

@@ -1,6 +1,8 @@
 /**
  * The ordinary session catalog engine: summary index (base + delta log),
- * session-file reconcile, `.hb` liveness and the background verification.
+ * session-file reconcile and the background verification. Turn liveness is
+ * not part of it: the daemon overlays its in-memory runtime state on the rows
+ * it serves.
  *
  * Leaf by design (no store.mjs, no config, no workers): the cold reader
  * (store-summary-reader.mjs) runs one instance on its own thread for the JSON
@@ -24,8 +26,10 @@ import {
   inheritedFromSessionId,
   isStoredSessionId,
   positiveNumber,
+  realTurnCount,
   workspaceSummary,
 } from './store-summary-fields.mjs';
+import { isRealTurnMessage } from './compact/user-message-kind.mjs';
 import { byActivityThenId } from './catalog-db/schema.mjs';
 import {
   sessionStampOf,
@@ -85,18 +89,18 @@ export function stampedDerivation(kind, path, derive) {
 
 const SESSION_SUMMARY_INDEX_VERSION = 2;
 
-// Mirror of lifecycle-api.mjs listLeadSessions visibility: the cold catalog
-// must never surface worker/agent dispatches (memory ingest chunks, judges,
-// spawned agents) — the authoritative engine excludes them, so a click on
-// such a row dead-ends in "Session is not available." (user report).
+// Catalog visibility: Agent sessions are listed like any other session (the
+// desktop sidebar filters to Leads itself), while internal dispatches the
+// engine cannot open (memory ingest chunks, judges, exec runs) stay out — a
+// click on such a row dead-ends in "Session is not available." (user report).
 const LEAD_OWNERS = new Set(['cli', 'user', 'mixdog']);
 
 export function isLeadVisibleRow(row) {
   const owner = String(row.owner || 'user')
     .trim()
     .toLowerCase();
-  if (isAgentOnlySession(row)) return false;
-  if (!isRootLeadSession(row) && owner && !LEAD_OWNERS.has(owner)) return false;
+  const agentSession = isAgentOnlySession(row) || owner === 'agent';
+  if (!agentSession && !isRootLeadSession(row) && owner && !LEAD_OWNERS.has(owner)) return false;
   // Mirror listLeadSessions: a previewless zero-message row is an unusable
   // scratch (desktop boot leftovers, crashed first turns) — resuming it
   // shows an empty conversation, so the catalog hides it.
@@ -113,6 +117,7 @@ export function isLeadVisibleRow(row) {
     .trim()
     .toLowerCase();
   return (
+    agentSession ||
     agent === 'lead' ||
     sourceType === 'lead' ||
     sourceType === 'cli' ||
@@ -147,7 +152,7 @@ function messageText(content) {
     .join(' ');
 }
 
-export function normalizedRow(row, heartbeatAt = 0) {
+export function normalizedRow(row) {
   if (!row || typeof row.id !== 'string' || !isStoredSessionId(row.id)) return null;
   return {
     id: row.id,
@@ -158,10 +163,6 @@ export function normalizedRow(row, heartbeatAt = 0) {
     lastUsedAt: positiveNumber(row.lastUsedAt, 0),
     createdAt: positiveNumber(row.createdAt, 0),
     lastHeartbeatAt: positiveNumber(row.lastHeartbeatAt, 0),
-    // Liveness comes from the .hb sidecar mtime alone: stored row fields
-    // (summary index / final session save) survive completion and must not
-    // keep the desktop working indicator on after the sidecar is deleted.
-    heartbeatAt: positiveNumber(heartbeatAt, 0),
     closed: row.closed === true,
     status: String(row.status || (row.closed === true ? 'closed' : 'idle')),
     owner: row.owner || 'user',
@@ -182,6 +183,7 @@ export function normalizedRow(row, heartbeatAt = 0) {
     permission: row.permission || null,
     toolPermission: row.toolPermission || null,
     messageCount: Math.max(0, Math.floor(Number(row.messageCount) || 0)),
+    realTurnCount: realTurnCount(row),
     title: cleanText(row.title, 100),
     preview: cleanText(row.preview),
     generation: typeof row.generation === 'number' ? row.generation : 0,
@@ -193,35 +195,11 @@ export function normalizedRow(row, heartbeatAt = 0) {
   };
 }
 
-/** Newest heartbeat of each Lead's live agents, from rows carrying `heartbeatAt`. */
-export function agentHeartbeatsByOwner(rows) {
-  const agentHeartbeatByOwner = new Map();
-  for (const row of rows) {
-    const heartbeatAt = positiveNumber(row?.heartbeatAt, 0);
-    const ownerSessionId = String(row?.ownerSessionId || '').trim();
-    const owner = String(row?.owner || '')
-      .trim()
-      .toLowerCase();
-    const agent = String(row?.agent || '')
-      .trim()
-      .toLowerCase();
-    if (!heartbeatAt || !ownerSessionId || (owner !== 'agent' && (!agent || agent === 'lead'))) continue;
-    agentHeartbeatByOwner.set(ownerSessionId, Math.max(agentHeartbeatByOwner.get(ownerSessionId) || 0, heartbeatAt));
-  }
-  return agentHeartbeatByOwner;
-}
-
-function leadRowsWithAgentHeartbeat(rows) {
-  const agentHeartbeatByOwner = agentHeartbeatsByOwner(rows);
-  return rows
-    .filter((row) => row && isLeadVisibleRow(row))
-    .map((row) => {
-      const agentHeartbeatAt = agentHeartbeatByOwner.get(row.id) || 0;
-      return agentHeartbeatAt > 0 ? { ...row, agentHeartbeatAt } : row;
-    });
+function leadRows(rows) {
+  return rows.filter((row) => row && isLeadVisibleRow(row));
 }
 
-function rowFromSession(session, heartbeatAt = 0) {
+function rowFromSession(session) {
   const messages = Array.isArray(session?.messages) ? session.messages : [];
   const preview =
     messages
@@ -236,14 +214,12 @@ function rowFromSession(session, heartbeatAt = 0) {
       )
       .map((message) => cleanText(messageText(message.content)))
       .find(Boolean) || '';
-  return normalizedRow(
-    {
-      ...session,
-      messageCount: messages.filter((message) => message?.role === 'user' || message?.role === 'assistant').length,
-      preview,
-    },
-    heartbeatAt
-  );
+  return normalizedRow({
+    ...session,
+    messageCount: messages.filter((message) => message?.role === 'user' || message?.role === 'assistant').length,
+    realTurnCount: messages.filter(isRealTurnMessage).length,
+    preview,
+  });
 }
 
 // ── Session file reconcile ──────────────────────────────────────────────────
@@ -289,7 +265,7 @@ function reconcileSessionFile(directory, storageId, retained, forceRead) {
     // 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, 0);
+    return rowFromSession(record.doc);
   });
   if (read.state === PROBE_ABSENT) return null;
   // Exists and could not be read (EACCES/EIO): retain the last known row
@@ -317,53 +293,46 @@ function deepFreeze(value) {
   return value;
 }
 
-/** The session ids (`<id>.json`) and live sidecar ids (`<id>.hb`) of
- *  `directory`, or null when it cannot be enumerated. */
-function listSessionNames(directory) {
+/** The session ids (`<id>.json`) of `directory`, or null when it cannot be
+ *  enumerated. */
+function listSessionIds(directory) {
   let names;
   try {
     names = readdirSync(directory);
   } catch {
     return null;
   }
-  const sessionIds = [];
-  const heartbeatIds = [];
-  for (const filename of names) {
-    if (filename.endsWith('.json')) sessionIds.push(filename.slice(0, -5));
-    else if (filename.endsWith('.hb') && isStoredSessionId(filename.slice(0, -3))) {
-      heartbeatIds.push(filename.slice(0, -3));
-    }
-  }
-  return { sessionIds, heartbeatIds };
+  return names.filter((filename) => filename.endsWith('.json')).map((filename) => filename.slice(0, -5));
 }
 
-/** Every `.json` entry and `.hb` sidecar id of an enumerable `directory`, or
- *  null when it cannot be enumerated. */
+/** Every `.json` entry of an enumerable `directory`, or null when it cannot
+ *  be enumerated. */
 function scanSessionEntries(directory, indexRowsById, forceRead) {
-  const names = listSessionNames(directory);
-  if (!names) return null;
+  const sessionIds = listSessionIds(directory);
+  if (!sessionIds) return null;
   const entries = new Map();
-  for (const storageId of names.sessionIds) {
+  for (const storageId of sessionIds) {
     const entry = reconcileSessionFile(directory, storageId, indexRowsById.get(storageId), forceRead);
     if (entry) entries.set(storageId, entry);
   }
-  return { entries, heartbeatIds: names.heartbeatIds };
+  return { entries };
 }
 
-/** The row an entry contributes (before liveness overlays), or null. */
+/** The row an entry contributes, or null. */
 function entryRow(entry, id, indexRowsById) {
   if (!entry || entry.kind === 'none') return null;
   return (entry.kind === 'row' ? entry.row : indexRowsById.get(id)) || null;
 }
 
 /** Catalog rows of reconciled `entries`, in catalog order. */
-function assembleCatalog(entries, indexRowsById, heartbeatMtimes) {
+function assembleCatalog(entries, indexRowsById) {
   const rows = [];
   for (const [id, entry] of entries) {
     const row = entryRow(entry, id, indexRowsById);
-    if (row) rows.push({ ...row, heartbeatAt: positiveNumber(heartbeatMtimes.get(id), 0) });
+    // A copy: the cached entry rows are frozen and shared.
+    if (row) rows.push({ ...row });
   }
-  return leadRowsWithAgentHeartbeat(rows).sort(byCatalogOrder);
+  return leadRows(rows).sort(byCatalogOrder);
 }
 
 /**
@@ -375,23 +344,18 @@ function assembleCatalog(entries, indexRowsById, heartbeatMtimes) {
  * durable summary and a single UNREADABLE file retains its last known row
  * instead of vanishing.
  */
-export function scanSessionFiles(heartbeatMtimes, indexRowsById, forceRead) {
+export function scanSessionFiles(indexRowsById, forceRead) {
   const directory = join(dataDir(), 'sessions');
   const dirProbe = probePath(directory);
   if (dirProbe.state === PROBE_ABSENT) return [];
   if (dirProbe.state !== PROBE_PRESENT) return null;
   const scan = scanSessionEntries(directory, indexRowsById, forceRead);
-  return scan && assembleCatalog(scan.entries, indexRowsById, heartbeatMtimes);
+  return scan && assembleCatalog(scan.entries, indexRowsById);
 }
 
 /** Listing from the index rows alone, or null without a valid index. */
-export function indexListing(index, heartbeatMtimes) {
-  return (
-    index.rows &&
-    leadRowsWithAgentHeartbeat(
-      index.rows.map((row) => ({ ...row, heartbeatAt: positiveNumber(heartbeatMtimes.get(row.id), 0) }))
-    ).sort(byCatalogOrder)
-  );
+export function indexListing(index) {
+  return index.rows && leadRows(index.rows.map((row) => ({ ...row }))).sort(byCatalogOrder);
 }
 
 // ── Summary index ───────────────────────────────────────────────────────────
@@ -475,7 +439,7 @@ function readSummaryIndex(cached) {
       }
       // Same semantics as applySummaryLogText: last writer wins per id.
       if (op?.u && typeof op.u.id === 'string') {
-        const row = normalizedRow(op.u, 0);
+        const row = normalizedRow(op.u);
         if (row) rowsById.set(row.id, deepFreeze(row));
         else rowsById.delete(op.u.id);
         touched.add(op.u.id);
@@ -509,7 +473,7 @@ function readSummaryIndex(cached) {
     }
   }
   const rows = applySummaryLogText({ rows: baseRows ?? [] }, index.logBytes.toString('utf8'))
-    .rows.map((row) => normalizedRow(row, 0))
+    .rows.map((row) => normalizedRow(row))
     .filter(Boolean)
     .map(deepFreeze);
   for (const row of rows) index.signatures.set(row.id, JSON.stringify(row));
@@ -535,16 +499,10 @@ function changedIndexIds(previous, next) {
   return ids;
 }
 
-function sameMtimes(left, right) {
-  if (!right || left.size !== right.size) return false;
-  for (const [id, mtimeMs] of left) if (right.get(id) !== mtimeMs) return false;
-  return true;
-}
-
 // ── Ordinary catalog ────────────────────────────────────────────────────────
 // The ordinary listing keeps its last reconcile and answers an unchanged call
-// from cheap stamps alone: the index pair (above), the sessions DIRECTORY and
-// the handful of live `.hb` sidecars — no per-session-file filesystem work.
+// from cheap stamps alone: the index pair (above) and the sessions DIRECTORY —
+// no per-session-file filesystem work.
 //
 // The directory stamp changes on every create, delete and rename in it
 // (including a temp-file + rename replace), and NOT on an in-place write
@@ -577,8 +535,6 @@ function newSessionCatalog(directory, dirStamp, index, scan) {
     dirSettled: isSettledSessionStamp(dirStamp),
     index,
     entries: scan.entries,
-    heartbeatIds: scan.heartbeatIds,
-    heartbeatMtimes: null,
     rows: null,
     dirty: new Set(),
     verifiedAt: Date.now(),
@@ -606,17 +562,16 @@ function reconcileKnownCatalog(catalog, directory, dirStamp, index, hinted) {
     changed = true;
   }
   if (!catalog.dirSettled || !sameSessionStamp(catalog.dirStamp, dirStamp)) {
-    const names = listSessionNames(directory);
-    if (!names) return null;
-    const present = new Set(names.sessionIds);
+    const sessionIds = listSessionIds(directory);
+    if (!sessionIds) return null;
+    const present = new Set(sessionIds);
     for (const id of catalog.entries.keys()) {
       if (present.has(id)) continue;
       catalog.entries.delete(id);
       changedIds.add(id);
       changed = true;
     }
-    for (const id of names.sessionIds) if (!catalog.entries.has(id)) ids.add(id);
-    catalog.heartbeatIds = names.heartbeatIds;
+    for (const id of sessionIds) if (!catalog.entries.has(id)) ids.add(id);
     catalog.dirStamp = dirStamp;
     catalog.dirSettled = isSettledSessionStamp(dirStamp);
   }
@@ -630,20 +585,6 @@ function reconcileKnownCatalog(catalog, directory, dirStamp, index, hinted) {
   return { changed, changedIds };
 }
 
-/** Liveness: `.hb` sidecars are rewritten in place, so their mtimes are
- *  probed every call (absent or unreadable contributes nothing). True when
- *  they differ from the previous probe. */
-function refreshHeartbeatMtimes(catalog, directory) {
-  const heartbeatMtimes = new Map();
-  for (const id of catalog.heartbeatIds) {
-    const probe = probePath(join(directory, `${id}.hb`));
-    if (probe.state === PROBE_PRESENT && probe.mtimeMs > 0) heartbeatMtimes.set(id, probe.mtimeMs);
-  }
-  const differs = !sameMtimes(heartbeatMtimes, catalog.heartbeatMtimes);
-  catalog.heartbeatMtimes = heartbeatMtimes;
-  return differs;
-}
-
 /** Marks every entry of `snapshot` whose file no longer has the full stamp it
  *  was judged at dirty (a replacement brings a new inode and change time even
  *  when its size and mtime match). Stops early once `isCurrent()` is false. */
@@ -725,7 +666,6 @@ export function createOrdinaryCatalog() {
       }
       ({ changed, changedIds } = reconciled);
     }
-    if (refreshHeartbeatMtimes(catalog, directory)) changed = true;
     if (changed) catalog.rows = null;
     if (assemble) rowsOf(catalog);
     armCatalogVerify(catalog);
@@ -735,9 +675,7 @@ export function createOrdinaryCatalog() {
 
   /** The (frozen) listing of a reconciled catalog, assembled on demand. */
   function rowsOf(catalog) {
-    catalog.rows ||= assembleCatalog(catalog.entries, catalog.index.rowsById, catalog.heartbeatMtimes).map(
-      Object.freeze
-    );
+    catalog.rows ||= assembleCatalog(catalog.entries, catalog.index.rowsById).map(Object.freeze);
     return catalog.rows;
   }
 
@@ -791,7 +729,7 @@ export function createOrdinaryCatalog() {
     loadIndex,
     refresh,
     rowsOf,
-    /** The row `id` contributes to the current catalog (before overlays). */
+    /** The row `id` contributes to the current catalog. */
     entryRow: (catalog, id) => entryRow(catalog.entries.get(id), id, catalog.index.rowsById),
     current: () => sessionCatalog,
     /** `listener()` runs when a background pass finds a session file that

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

@@ -55,6 +55,14 @@ export function inheritedFromSessionId(value) {
   return id || null;
 }
 
+/** Count of real human turns a session persisted (actual user instructions
+ *  plus compact summaries, which stand for earlier human turns); null for a
+ *  row written before the field existed. */
+export function realTurnCount(value) {
+  const count = value?.realTurnCount;
+  return typeof count === 'number' && Number.isFinite(count) && count >= 0 ? Math.floor(count) : null;
+}
+
 export function importKey(value) {
   const key = typeof value?.importKey === 'string' ? value.importKey : value?.importOrigin?.key;
   return typeof key === 'string' && key.trim() ? key : null;

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

@@ -23,8 +23,10 @@ import {
   inheritedFromSessionId,
   isStoredSessionId,
   positiveNumber as _positiveNumber,
+  realTurnCount,
   workspaceSummary,
 } from './store-summary-fields.mjs';
+import { isRealTurnMessage } from './compact/user-message-kind.mjs';
 
 export const SESSION_SUMMARY_INDEX_VERSION = 2;
 
@@ -92,6 +94,7 @@ function _sessionMessageProjection(session) {
   const cached = session && typeof session === 'object' ? sessionMessageProjectionMemo.get(session) : null;
   let start = 0;
   let count = 0;
+  let real = 0;
   let preview = '';
   let previewMessage = null;
   const canAppend =
@@ -101,6 +104,7 @@ function _sessionMessageProjection(session) {
   if (canAppend) {
     start = cached.length;
     count = cached.count;
+    real = cached.real;
     preview = cached.preview;
     previewMessage = cached.previewMessage;
     // The first real user message is stable in normal append-only session
@@ -112,6 +116,7 @@ function _sessionMessageProjection(session) {
       else {
         start = 0;
         count = 0;
+        real = 0;
         preview = '';
         previewMessage = null;
       }
@@ -120,6 +125,7 @@ function _sessionMessageProjection(session) {
   for (let index = start; index < messages.length; index += 1) {
     const message = messages[index];
     if (message && (message.role === 'user' || message.role === 'assistant')) count += 1;
+    if (isRealTurnMessage(message)) real += 1;
     if (!preview) {
       const candidate = _previewFromMessage(message);
       if (candidate) {
@@ -133,11 +139,12 @@ function _sessionMessageProjection(session) {
       length: messages.length,
       lastMessage: messages[messages.length - 1] || null,
       count,
+      real,
       preview,
       previewMessage,
     });
   }
-  return { count, preview };
+  return { count, real, preview };
 }
 
 function _desktopSessionSummary(value, cwd = null) {
@@ -199,6 +206,7 @@ export function _sessionSummary(session) {
       : null,
     taskType: session.taskType || null,
     messageCount: messageProjection.count,
+    realTurnCount: messageProjection.real,
     title: _cleanPreview(session.title || '', 100),
     preview: messageProjection.preview,
     generation: typeof session.generation === 'number' ? session.generation : 0,
@@ -253,6 +261,7 @@ function _normalizeSummaryRow(row) {
       : null,
     taskType: row.taskType || null,
     messageCount: Math.max(0, Math.floor(Number(row.messageCount) || 0)),
+    realTurnCount: realTurnCount(row),
     title: _cleanPreview(row.title || '', 100),
     preview: _cleanPreview(row.preview || ''),
     generation: typeof row.generation === 'number' ? row.generation : 0,

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

@@ -1,14 +1,10 @@
 /**
- * Where the cold read-only catalog reads from, and the heartbeat-sidecar scan
- * that gives it liveness. Leaf module by design: no store.mjs, no config, no
- * workers — every consumer of the cold path resolves paths through here so
- * they cannot drift apart.
+ * Where the cold read-only catalog reads from. Leaf module by design: no
+ * store.mjs, no config, no workers — every consumer of the cold path resolves
+ * paths through here so they cannot drift apart.
  */
-import { readdirSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
-import { probePath, PROBE_PRESENT } from './store/fs-probe.mjs';
-import { isStoredSessionId } from './store-summary-fields.mjs';
 
 export function dataDir() {
   if (process.env.MIXDOG_DATA_DIR) return process.env.MIXDOG_DATA_DIR;
@@ -23,25 +19,3 @@ export function storedAgentWorkerIndexPath() {
 export function storedLeadWorkerIndexPath() {
   return join(dataDir(), 'lead-workers.json');
 }
-
-export function sessionHeartbeatMtimes() {
-  const directory = join(dataDir(), 'sessions');
-  const result = new Map();
-  if (probePath(directory).state !== PROBE_PRESENT) return result;
-  let entries = [];
-  try {
-    entries = readdirSync(directory);
-  } catch {
-    return result;
-  }
-  for (const filename of entries) {
-    if (!filename.endsWith('.hb')) continue;
-    const id = filename.slice(0, -3);
-    if (!isStoredSessionId(id)) continue;
-    // Liveness is additive: a sidecar that is absent OR unreadable simply
-    // contributes nothing, and can never remove a row.
-    const probe = probePath(join(directory, filename));
-    if (probe.state === PROBE_PRESENT && probe.mtimeMs > 0) result.set(id, probe.mtimeMs);
-  }
-  return result;
-}

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

@@ -28,7 +28,7 @@ test.after(() => {
 });
 
 /** Point the reader at a fresh data dir with an empty sessions directory. */
-export function useDataDir(prefix) {
+export function isolateDataDir(prefix) {
   root = mkdtempSync(join(tmpdir(), prefix));
   roots.push(root);
   mkdirSync(join(root, 'sessions'));

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

@@ -29,7 +29,7 @@ import {
   storedTranscriptWorkerRunning,
 } from './store-transcript-worker.mjs';
 import { projectStoredTranscript } from './store-transcript-projection.mjs';
-import { dataDir, sessionHeartbeatMtimes } from './store-summary-locations.mjs';
+import { dataDir } from './store-summary-locations.mjs';
 import { isStoredSessionId, workspaceSummary } from './store-summary-fields.mjs';
 import { readArchivedAgentResult } from './store-summary-archived-agent.mjs';
 import { compactionArchivePath, readCompactionArchivePage } from './compaction-archive.mjs';
@@ -42,9 +42,9 @@ import {
   sameSessionStamp,
   isSettledSessionStamp,
 } from './store/canonical-reader.mjs';
-// Worker-pool row projection (child + Lead indexes, heartbeat lease, cancel
-// ranking) lives in store-agent-worker-rows.mjs; re-exported so prior
-// importers of this module stay unchanged.
+// 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 { storedAgentWorkerIndexPath } from './store-summary-locations.mjs';
 
@@ -123,13 +123,12 @@ export function listStoredSessionSummaries(options = {}) {
   // nor empty: the scan still runs, and when IT cannot enumerate either, the
   // catalog reports nothing rather than inventing an empty truth.
   if (options.refreshFromStorage === true) {
-    const heartbeatMtimes = sessionHeartbeatMtimes();
-    return scanSessionFiles(heartbeatMtimes, index.rowsById, true) ?? indexListing(index, heartbeatMtimes) ?? [];
+    return scanSessionFiles(index.rowsById, true) ?? indexListing(index) ?? [];
   }
-  if (options.rebuildIfMissing === false) return indexListing(index, sessionHeartbeatMtimes()) ?? [];
+  if (options.rebuildIfMissing === false) return indexListing(index) ?? [];
   // A missing/malformed index leaves every file to be parsed (once per
   // stamp); a present one lets unchanged files reuse their durable summary.
-  return ordinaryCatalog.refresh(index).rows ?? indexListing(index, sessionHeartbeatMtimes()) ?? [];
+  return ordinaryCatalog.refresh(index).rows ?? indexListing(index) ?? [];
 }
 
 /** The catalog DB's answer to an ordinary listing (`{ rows, more }`), or
@@ -250,6 +249,14 @@ function storedSessionMetadata(sessionId, session) {
   };
 }
 
+/** A record that is gone may be a reaped agent child: its parent is resolved
+ *  from metadata only (worker link, summary-index row), never by a scan. */
+function readVanishedSessionTranscript(sessionId) {
+  return readArchivedAgentResult(sessionId, {
+    catalogRow: (id) => ordinaryCatalog.loadIndex().rowsById.get(id) || null,
+  });
+}
+
 /** The two files a stored transcript projection is built from. */
 function storedTranscriptInputPaths(sessionId) {
   return {
@@ -375,7 +382,7 @@ export async function readStoredSessionTranscript(id, options = {}) {
   // Phase durations of the parse this call ran (absent on a cache hit).
   const timing = {};
   const recordStat = probePath(recordPath);
-  if (recordStat.state === PROBE_ABSENT) return readArchivedAgentResult(sessionId);
+  if (recordStat.state === PROBE_ABSENT) return readVanishedSessionTranscript(sessionId);
   if (recordStat.state !== PROBE_PRESENT) return null;
   const checkpoint = probePath(checkpointPath);
   const archive = probePath(archivePath);
@@ -441,7 +448,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 readArchivedAgentResult(sessionId);
+  if (readState === PROBE_ABSENT) return readVanishedSessionTranscript(sessionId);
   if (typeof options.trace === 'function') {
     options.trace({
       sessionId,

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

@@ -1,7 +1,7 @@
 /**
  * The parse/recovery/projection body of one stored transcript read: durable
  * turn-checkpoint recovery for interrupted turns, the read-only checkpoint
- * projection for a live foreign owner, the cold context projection and the
+ * projection for a live turn, the cold context projection and the
  * pane-facing transcript shape.
  *
  * Kept apart from the cache/fingerprint policy in store-summary-reader.mjs
@@ -12,7 +12,7 @@
 import { sessionContextMeasurement, contextMeasurementStats } from '../../../shared/context-measurement.mjs';
 import { nextProjectionStamp } from './store-transcript-cache.mjs';
 import { join } from 'node:path';
-import { cleanValue, desktopSession, positiveNumber } from './store-summary-fields.mjs';
+import { desktopSession, positiveNumber } from './store-summary-fields.mjs';
 import { compactionArchiveRange, readCompactionArchivePage } from './compaction-archive.mjs';
 import { dataDir } from './store-summary-locations.mjs';
 
@@ -20,27 +20,20 @@ import { dataDir } from './store-summary-locations.mjs';
  *  per distinct content; its result is shared read-only through the cache. */
 export async function projectStoredTranscript(sessionId, doc, options) {
   let session = doc;
-  const owner = cleanValue(session.owner).toLowerCase();
-  const agent = cleanValue(session.agent).toLowerCase();
-  const liveDetachedAgent =
-    session.closed === true &&
-    (owner === 'agent' || (agent && agent !== 'lead')) &&
-    Boolean(cleanValue(session.ownerSessionId || session.parentSessionId));
   if (!options.checkpointAbsent) {
     const { projectTurnCheckpointMessages, readTurnCheckpoint } = await import('./manager/turn-checkpoint.mjs');
     const projectCheckpoint = () => {
       const checkpoint = readTurnCheckpoint(sessionId);
       if (checkpoint) session = { ...session, messages: projectTurnCheckpointMessages(session, checkpoint) };
     };
-    if (liveDetachedAgent) {
-      projectCheckpoint();
-    } else {
-      const { recoverSessionAfterProcessRestart } = await import('./manager.mjs');
+    const { isSessionTurnLive, recoverSessionAfterProcessRestart } = await import(
+      './manager/turn-checkpoint-recovery.mjs'
+    );
+    // A running turn is never recovered: project its checkpoint read-only.
+    if (isSessionTurnLive(sessionId)) projectCheckpoint();
+    else {
       session = recoverSessionAfterProcessRestart(sessionId) || session;
-      // A live foreign owner is intentionally not recovered/mutated.
-      // Project its durable working checkpoint read-only so the cold pane
-      // never repaints the stale pre-compaction session.messages while it
-      // waits for the owner's live-share frame.
+      // A closed session keeps its marker unrecovered.
       if (session?.activeTurnCheckpoint) projectCheckpoint();
     }
   }
@@ -134,9 +127,5 @@ export async function projectStoredTranscript(sessionId, doc, options) {
           displayContextWindow: displayContextWindow || null,
           autoCompactTokenLimit: autoCompactTokenLimit || null,
         }),
-    // Desktop must not ask its unrelated active engine to recover/peek an
-    // externally owned child: that runtime can only return the detached
-    // Task row and masks this checkpoint projection.
-    readOnlyDetachedAgent: liveDetachedAgent,
   };
 }