mixdog 1.2.3 → 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
@@ -87,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.
@@ -115,6 +117,7 @@ export function isLeadVisibleRow(row) {
     .trim()
     .toLowerCase();
   return (
+    agentSession ||
     agent === 'lead' ||
     sourceType === 'lead' ||
     sourceType === 'cli' ||
@@ -149,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,
@@ -160,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',
@@ -196,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
@@ -239,15 +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,
-      realTurnCount: messages.filter(isRealTurnMessage).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 ──────────────────────────────────────────────────
@@ -293,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
@@ -321,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);
 }
 
 /**
@@ -379,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 ───────────────────────────────────────────────────────────
@@ -479,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);
@@ -513,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));
@@ -539,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
@@ -581,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(),
@@ -610,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);
   }
@@ -634,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. */
@@ -729,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);
@@ -739,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;
   }
 
@@ -795,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-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

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,
   };
 }

package/src/runtime/agent/orchestrator/session/store.mjs

@@ -6,7 +6,7 @@
 import { closeSync, fsyncSync, openSync, writeFileSync } from 'node:fs';
 import * as fsp from 'node:fs/promises';
 import { randomBytes } from 'node:crypto';
-import { sessionPath } from './store/paths-heartbeat.mjs';
+import { sessionPath } from './store/session-paths.mjs';
 import {
   guardedSaveOptions as _guardedSaveOptions,
   cancelSessionWrites as _cancelSessionWrites,
@@ -30,17 +30,6 @@ export {
   _upsertSessionSummary,
   _removeSessionSummary,
 } from './store-summary-index.mjs';
-export {
-  publishHeartbeat,
-  deleteHeartbeat,
-  publishSessionPresence,
-  deleteSessionPresence,
-  readSessionPresenceMtime,
-  isSessionPresenceOwnerDead,
-  readSessionHeartbeatOwnerPid,
-  isSessionHeartbeatOwnerDead,
-  isProcessAlive,
-} from './store/paths-heartbeat.mjs';
 import { _sessionForDisk, _ensureLifecycleFields } from './store/serialize.mjs';
 import {
   _cacheSessionSummary,
@@ -55,11 +44,9 @@ import {
   withdrawPendingOwnCommit as _withdrawPendingOwnCommit,
   recordOwnSessionCommit as _recordOwnSessionCommit,
 } from './store/canonical-reader.mjs';
-// Durable lifecycle reads, heartbeat freshness and live-cache reclamation are
-// owned by dedicated modules; re-exported so prior importers of store.mjs
-// stay unchanged.
+// Durable lifecycle reads and live-cache reclamation are owned by dedicated
+// modules; re-exported so prior importers of store.mjs stay unchanged.
 export { readSessionLifecycleFromDisk, readSessionLifecycleStateFromDisk } from './store/lifecycle-read.mjs';
-export { readSessionHeartbeatMtime } from './store/liveness-veto.mjs';
 export { evictLiveSession, evictIdleLiveSessions } from './store/live-cache-eviction.mjs';
 import {
   setLiveSession,

package/src/runtime/agent/orchestrator/session/tool-batch/execute-call.mjs

@@ -78,7 +78,12 @@ export async function executeBatchCall(batch, call, callIndex) {
 // Read entries are stat-validated; scoped entries retain dependency
 // invalidation and their bounded TTL. A miss proceeds to execution.
 function lookupCaches(batch, call, exec) {
-  const cached = lookupToolResultReuse({ sessionId: batch.sessionId, call, cwd: batch.cwd });
+  const cached = lookupToolResultReuse({
+    sessionId: batch.sessionId,
+    call,
+    cwd: batch.cwd,
+    sessionRef: batch.sessionRef,
+  });
   if (cached?.kind === 'read') exec.readCacheHit = cached.entry;
   else if (cached?.kind === 'scoped') exec.scopedCacheHit = cached.entry;
 }
@@ -115,9 +120,7 @@ async function executeLive(batch, call, callIndex, exec) {
   // this session never received the discarded body.
   let discardedRead = false;
   if (eager !== undefined && eager.mutationEpoch < epoch.mutation && isEagerDispatchable(call.name, tools)) {
-    const stale = _isReadTool(call.name)
-      ? mutationAffectsRead(epoch, eager.mutationEpoch, call, batch.cwd)
-      : true;
+    const stale = _isReadTool(call.name) ? mutationAffectsRead(epoch, eager.mutationEpoch, call, batch.cwd) : true;
     if (stale) {
       discardedRead = _isReadTool(call.name);
       pending.delete(call.id);
@@ -176,14 +179,10 @@ async function executeSerially(batch, call, exec, suppressReadUnchangedStub = fa
   exec.executionStartedAt = Date.now();
   exec.serialExecutionStartedAt = exec.executionStartedAt;
   exec.localSearchTelemetry = {};
-  exec.result = await executeToolFn(
-    call.name,
-    call.arguments,
-    cwd,
-    sessionId,
-    sessionRef,
-    { ...invocationOptions(batch, call, exec), ...(suppressReadUnchangedStub ? { suppressReadUnchangedStub: true } : {}) }
-  );
+  exec.result = await executeToolFn(call.name, call.arguments, cwd, sessionId, sessionRef, {
+    ...invocationOptions(batch, call, exec),
+    ...(suppressReadUnchangedStub ? { suppressReadUnchangedStub: true } : {}),
+  });
   exec.toolEndedAt = Date.now();
   classifyExecuted(call, exec);
 }