mixdog 1.3.4 → 1.4.0

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

@@ -0,0 +1,85 @@
+/**
+ * Persisted copy of the agent pool's session-header cache. The in-memory
+ * cache of store-agent-worker-rows.mjs died with the daemon, so the first
+ * pool listing after every restart re-read every worker transcript (~1,700
+ * records, ~1 GB) just to rebuild headers that had not changed: seconds of
+ * I/O and CPU right when the restored conversation was loading.
+ *
+ * The file only seeds the in-memory cache. Every seeded entry is still served
+ * under that cache's full-stamp policy — the record must still have the exact
+ * { dev, ino, size, mtimeNs, ctimeNs } its header was read from, a stamp that
+ * was settled when cached — so a record changed while no daemon ran (or by
+ * another process) is read again. Being a cache, an absent, unreadable,
+ * damaged, other-version or other-field-set file seeds nothing (a bad entry
+ * alone is skipped) and is replaced by the next write; writes are atomic.
+ */
+import { randomBytes } from 'node:crypto';
+import { readFile, rename, unlink, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { sessionStampOf } from './store/canonical-reader.mjs';
+import { isStoredSessionId } from './store-summary-fields.mjs';
+import { dataDir } from './store-summary-locations.mjs';
+
+const VERSION = 1;
+const STAMP_KEYS = ['dev', 'ino', 'size', 'mtimeNs', 'ctimeNs'];
+const UNSIGNED = /^\d+$/;
+
+export function storedAgentWorkerHeaderCachePath(dir = dataDir()) {
+  return join(dir, 'agent-worker-header-cache.json');
+}
+
+function decodeStamp(value) {
+  if (!Array.isArray(value) || value.length !== STAMP_KEYS.length) return null;
+  if (!value.every((part) => typeof part === 'string' && UNSIGNED.test(part))) return null;
+  return sessionStampOf(Object.fromEntries(STAMP_KEYS.map((key, index) => [key, BigInt(value[index])])));
+}
+
+function decodeHeader(value, fields) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+  return Object.keys(value).every((key) => fields.has(key)) ? value : null;
+}
+
+/** sessionId -> { stamp, header } from the file at `path`; empty when the
+ *  file is absent, unreadable, damaged, or written for another version or
+ *  header field list. */
+export async function readPersistedWorkerHeaders(path, fields) {
+  const entries = new Map();
+  let doc;
+  try {
+    doc = JSON.parse(await readFile(path, 'utf8'));
+  } catch {
+    return entries;
+  }
+  if (doc?.version !== VERSION || doc.fields !== fields.join(',')) return entries;
+  if (!doc.sessions || typeof doc.sessions !== 'object' || Array.isArray(doc.sessions)) return entries;
+  const wanted = new Set(fields);
+  for (const [sessionId, entry] of Object.entries(doc.sessions)) {
+    if (!isStoredSessionId(sessionId) || !entry || typeof entry !== 'object') continue;
+    const stamp = decodeStamp(entry.stamp);
+    const header = decodeHeader(entry.header, wanted);
+    if (stamp && header) entries.set(sessionId, { stamp, header });
+  }
+  return entries;
+}
+
+/** Replaces the file at `path` with `entries` (sessionId -> { stamp, header })
+ *  by rename, so a reader sees the old file or the new one, never a torn one.
+ *  Resolves false instead of throwing: a lost write only costs the next
+ *  restart some re-reads. The data directory is never created: a store that
+ *  is gone gets no cache. */
+export async function writePersistedWorkerHeaders(path, fields, entries) {
+  const sessions = {};
+  for (const [sessionId, { stamp, header }] of entries) {
+    sessions[sessionId] = { stamp: STAMP_KEYS.map((key) => String(stamp[key])), header };
+  }
+  // The temp shape is atomic-file.mjs's `<name>.mixdog-tmp-<hex>`.
+  const tmp = `${path}.mixdog-tmp-${randomBytes(8).toString('hex')}`;
+  try {
+    await writeFile(tmp, JSON.stringify({ version: VERSION, fields: fields.join(','), sessions }), { flag: 'wx' });
+    await rename(tmp, path);
+    return true;
+  } catch {
+    await unlink(tmp).catch(() => {});
+    return false;
+  }
+}

package/src/runtime/agent/orchestrator/session/store-agent-worker-rows.mjs

@@ -17,7 +17,7 @@
  */
 import { readFileSync } from 'node:fs';
 import { readFile, stat } from 'node:fs/promises';
-import { join } from 'node:path';
+import { basename, join } from 'node:path';
 import {
   isSettledSessionStamp,
   sameSessionStamp,
@@ -27,6 +27,11 @@ import {
 import { readJsonProjection } from '../../../shared/pending-json-projection.mjs';
 import { listStoredAgentWorkers as assembleStoredAgentWorkers } from './store-agent-worker-pool.mjs';
 import { readTopLevelFields } from './store-agent-worker-header.mjs';
+import {
+  readPersistedWorkerHeaders,
+  storedAgentWorkerHeaderCachePath,
+  writePersistedWorkerHeaders,
+} from './store-agent-worker-header-cache.mjs';
 import {
   TAG_TOMBSTONE_TTL_MS,
   agentPaneVisible,
@@ -156,12 +161,12 @@ function cancelState(source) {
 function effectiveCancel(row, session) {
   const rowCancel = cancelState(row);
   const sessionCancel = cancelState(session);
-  const cancel =
-    rowCancel && sessionCancel && CANCEL_UNCONFIRMED_AGENT_STATUS.test(sessionCancel.status)
-      ? CANCEL_UNCONFIRMED_AGENT_STATUS.test(rowCancel.status)
-        ? rowCancel
-        : sessionCancel
-      : rowCancel || sessionCancel;
+  let cancel;
+  if (rowCancel && sessionCancel && CANCEL_UNCONFIRMED_AGENT_STATUS.test(sessionCancel.status)) {
+    cancel = CANCEL_UNCONFIRMED_AGENT_STATUS.test(rowCancel.status) ? rowCancel : sessionCancel;
+  } else {
+    cancel = rowCancel || sessionCancel;
+  }
   if (!cancel) return null;
   const newerWork = cancel.at > 0 && Math.max(workStampMs(row), workStampMs(session)) > cancel.at;
   return newerWork ? null : cancel;
@@ -330,8 +335,104 @@ const WORKER_HEADER_FIELDS = [
 // assembly the first answer stands, absent or unreadable included.
 let passHeaders = null; // path -> header | null, live only during an assembly
 
-function workerSessionHeaderPath(sessionId) {
-  return join(dataDir(), 'sessions', `${sessionId}.json`);
+function workerSessionHeaderPath(sessionId, dir = dataDir()) {
+  return join(dir, 'sessions', `${sessionId}.json`);
+}
+
+// Every change to the header cache is counted, so the persisted copy is
+// rewritten only when the cache it mirrors moved.
+let headerCacheEdits = 0;
+
+function cacheHeader(path, entry) {
+  workerSessionHeaderCache.set(path, entry);
+  headerCacheEdits += 1;
+}
+
+function dropHeader(path) {
+  if (workerSessionHeaderCache.delete(path)) headerCacheEdits += 1;
+}
+
+// The header cache outlives the daemon through store-agent-worker-header-
+// cache.mjs: the first awaited listing of a data directory seeds the cache
+// from its file (entries already in memory win), and an awaited listing that
+// changed the cache schedules a rewrite. The write waits out
+// HEADER_PERSIST_DELAY_MS — off the boot path, and at most one write per
+// window however often agents churn. Seeded entries pass the same full-stamp
+// check as any other, so a seed never serves a header its file no longer has.
+const HEADER_PERSIST_DELAY_MS = 10_000;
+let seededDir = null;
+let seeding = null;
+// The edit count the last write left on disk, and the directory it went to:
+// a count persisted for one data directory says nothing about another.
+let persistedEdits = 0;
+let persistedDir = null;
+let persistTimer = null;
+let persistTimerDir = null;
+let persistWrite = null;
+
+function seedPersistedHeaders() {
+  const dir = dataDir();
+  if (seededDir !== dir) {
+    seededDir = dir;
+    seeding = readPersistedWorkerHeaders(storedAgentWorkerHeaderCachePath(dir), WORKER_HEADER_FIELDS).then(
+      (entries) => {
+        for (const [sessionId, { stamp, header }] of entries) {
+          const path = workerSessionHeaderPath(sessionId, dir);
+          if (!workerSessionHeaderCache.has(path)) workerSessionHeaderCache.set(path, { stamp, header, pass: 0 });
+        }
+      }
+    );
+  }
+  return seeding;
+}
+
+function schedulePersistHeaders() {
+  const dir = dataDir();
+  // A write pending for the directory this listing left is dropped: the
+  // listing just forgot that directory's unread headers, so writing it now
+  // would shrink its file. Its last written cache still stands.
+  if (persistTimer && persistTimerDir !== dir) {
+    clearTimeout(persistTimer);
+    persistTimer = null;
+  }
+  if (persistTimer || (persistedDir === dir && headerCacheEdits === persistedEdits)) return;
+  persistTimerDir = dir;
+  persistTimer = setTimeout(() => {
+    persistTimer = null;
+    persistHeaders(persistTimerDir);
+  }, HEADER_PERSIST_DELAY_MS);
+  persistTimer.unref?.();
+}
+
+function persistHeaders(dir) {
+  if (persistWrite) return persistWrite;
+  const edits = headerCacheEdits;
+  const entries = [];
+  for (const [path, entry] of workerSessionHeaderCache) {
+    const sessionId = basename(path, '.json');
+    if (isStoredSessionId(sessionId) && workerSessionHeaderPath(sessionId, dir) === path) {
+      entries.push([sessionId, entry]);
+    }
+  }
+  persistWrite = writePersistedWorkerHeaders(storedAgentWorkerHeaderCachePath(dir), WORKER_HEADER_FIELDS, entries).then(
+    (written) => {
+      if (written) {
+        persistedEdits = edits;
+        persistedDir = dir;
+      }
+      persistWrite = null;
+    }
+  );
+  return persistWrite;
+}
+
+/** Test/diagnostic seam: writes a scheduled header-cache persist now and
+ *  resolves once no write is in flight. */
+export function flushStoredAgentWorkerHeaderCache() {
+  if (!persistTimer) return persistWrite || Promise.resolve();
+  clearTimeout(persistTimer);
+  persistTimer = null;
+  return persistHeaders(persistTimerDir);
 }
 
 function readWorkerSessionHeader(sessionId) {
@@ -358,15 +459,18 @@ function observeStamp(path) {
 // window when read. Size + mtime alone let an equal-length rewrite that kept
 // its mtime serve stale ownership, status and cancel fields.
 function probeWorkerSessionHeader(path) {
-  // Absent and unreadable alike: no header.
+  // Absent and unreadable alike: no header, and no cached one kept for it.
   const before = observeStamp(path);
-  if (!before) return null;
+  if (!before) {
+    dropHeader(path);
+    return null;
+  }
   const cached = workerSessionHeaderCache.get(path);
   if (cached && sameSessionStamp(cached.stamp, before)) {
     cached.pass = headerPass;
     return cached.header;
   }
-  workerSessionHeaderCache.delete(path);
+  dropHeader(path);
   // A rewrite re-reads only this record, and only its top-level fields are
   // decoded: the transcript bytes are validated, never materialized.
   let header = null;
@@ -378,7 +482,7 @@ function probeWorkerSessionHeader(path) {
   if (!header) return null;
   workerHeaderReads += 1;
   if (isSettledSessionStamp(before) && sameSessionStamp(before, observeStamp(path))) {
-    workerSessionHeaderCache.set(path, { stamp: before, header, pass: headerPass });
+    cacheHeader(path, { stamp: before, header, pass: headerPass });
   }
   return header;
 }
@@ -395,10 +499,13 @@ async function observeStampAsync(path) {
  *  same full-stamp cache policy. */
 async function probeWorkerSessionHeaderAsync(path) {
   const before = await observeStampAsync(path);
-  if (!before) return null;
+  if (!before) {
+    dropHeader(path);
+    return null;
+  }
   const cached = workerSessionHeaderCache.get(path);
   if (cached && sameSessionStamp(cached.stamp, before)) return cached.header;
-  workerSessionHeaderCache.delete(path);
+  dropHeader(path);
   let header = null;
   try {
     header = readTopLevelFields(await readFile(path), WORKER_HEADER_FIELDS);
@@ -408,7 +515,7 @@ async function probeWorkerSessionHeaderAsync(path) {
   if (!header) return null;
   workerHeaderReads += 1;
   if (isSettledSessionStamp(before) && sameSessionStamp(before, await observeStampAsync(path))) {
-    workerSessionHeaderCache.set(path, { stamp: before, header, pass: headerPass });
+    cacheHeader(path, { stamp: before, header, pass: headerPass });
   }
   return header;
 }
@@ -418,7 +525,9 @@ async function probeWorkerSessionHeaderAsync(path) {
 const HEADER_READ_CONCURRENCY = 4;
 
 async function prefetchWorkerHeaders(sessionIds, headers) {
-  const paths = [...new Set([...sessionIds].map(workerSessionHeaderPath))].filter((path) => !headers.has(path));
+  const paths = [...new Set([...sessionIds].map((sessionId) => workerSessionHeaderPath(sessionId)))].filter(
+    (path) => !headers.has(path)
+  );
   let next = 0;
   const drain = async () => {
     while (next < paths.length) {
@@ -524,6 +633,8 @@ function projectChildWorkerRow(row, context) {
     // A live turn blocked on the user's approval (persisted by the agent
     // tool's worker index); never carried by a row that is no longer working.
     ...(working && row.awaitingUser === 'approval' ? { awaitingUser: 'approval' } : {}),
+    // The owner closed this agent (status unchanged); reused work clears it.
+    ...(!working && row.released === true ? { released: true } : {}),
     // Why a settled failed row failed; a row working again has no failure.
     ...(!working && failedAgentWorker(row) && cleanValue(row.failureReason)
       ? { failureReason: cleanValue(row.failureReason) }
@@ -634,7 +745,7 @@ export function listStoredAgentWorkers({ runningSessionIds = null } = {}) {
 // Keep what the latest assembly read, whatever the index size; forget the rest.
 function forgetUnreadHeaders() {
   for (const [path, entry] of workerSessionHeaderCache) {
-    if (entry.pass !== headerPass) workerSessionHeaderCache.delete(path);
+    if (entry.pass !== headerPass) dropHeader(path);
   }
 }
 
@@ -643,6 +754,8 @@ function forgetUnreadHeaders() {
  *  each Lead row's, and each child's owner) are read first with awaited
  *  stats and reads; the assembly then runs over what was read, with no file
  *  access left in it (any header it still asks for falls back to a read).
+ *  The first listing after a restart seeds the header cache from its
+ *  persisted copy, so only records changed since are read again.
  *  `runningSessionIds` may be a function, asked once the reads are done. */
 export async function listStoredAgentWorkersAsync({ runningSessionIds = null } = {}) {
   const agentIndexPath = storedAgentWorkerIndexPath();
@@ -650,6 +763,7 @@ export async function listStoredAgentWorkersAsync({ runningSessionIds = null } =
   const [agentIndex, leadIndex] = await Promise.all([
     readWorkerIndexFileAsync(agentIndexPath),
     readWorkerIndexFileAsync(leadIndexPath),
+    seedPersistedHeaders(),
   ]);
   const headers = new Map();
   const childRows = workerRows(agentIndex);
@@ -683,6 +797,7 @@ export async function listStoredAgentWorkersAsync({ runningSessionIds = null } =
     passHeaders = null;
     passIndexes = null;
     forgetUnreadHeaders();
+    schedulePersistHeaders();
   }
 }
 

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

@@ -131,8 +131,9 @@ export function isLeadVisibleRow(row) {
   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.
-  if (!row.preview && row.messageCount === 0) return false;
+  // shows an empty conversation, so the catalog hides it. A titled one is a
+  // real conversation whose prompts were rewound away: it stays listed.
+  if (!row.preview && row.messageCount === 0 && !row.title) return false;
   const sourceType = String(row.sourceType || '')
     .trim()
     .toLowerCase();
@@ -282,6 +283,15 @@ function rowFromSession(session) {
   });
 }
 
+/** The catalog row of one session read off `<directory>/<sessionId>.json` by
+ *  id — the same strict, stamp-cached derivation a listing uses — or null
+ *  when it is absent, unreadable, foreign or not one the catalog lists. */
+export function storedSessionCatalogRow(directory, sessionId) {
+  if (!isStoredSessionId(sessionId)) return null;
+  const entry = reconcileSessionFile(directory, sessionId, null, false);
+  return entry?.kind === 'row' && isLeadVisibleRow(entry.row) ? entry.row : null;
+}
+
 // ── Session file reconcile ──────────────────────────────────────────────────
 // What one `sessions/<id>.json` name contributes to the catalog, with the full
 // stamp { dev, ino, size, mtimeNs, ctimeNs } it was judged at (and the

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

@@ -391,31 +391,58 @@ const _pendingRemovals = new Set(); // ids to drop (upsert/removal are mutually
 let _summaryRetryTimer = null;
 let _summaryFlushScheduled = false;
 let _summaryFlushInflight = 0;
-const _summarySettleWaiters = new Set();
+// Ids whose ops the async flush in flight took (they are requeued if it fails).
+const _inflightSummaryIds = new Set();
+const _summarySettleWaiters = new Set(); // { ids: string[]|null, resolve }
 
 export function _hasUnsettledSummaryOps() {
   return _pendingUpserts.size > 0 || _pendingRemovals.size > 0 || _summaryFlushScheduled || _summaryFlushInflight > 0;
 }
 
+/** The ids among `ids` whose summary ops are queued or being written. */
+export function pendingSummaryIndexIds(ids) {
+  return ids.filter((id) => _pendingUpserts.has(id) || _pendingRemovals.has(id) || _inflightSummaryIds.has(id));
+}
+
+function _waiterSettled({ ids }) {
+  return ids ? pendingSummaryIndexIds(ids).length === 0 : !_hasUnsettledSummaryOps();
+}
+
 function _notifySummarySettled() {
-  if (_hasUnsettledSummaryOps()) return;
-  for (const resolve of _summarySettleWaiters) resolve();
-  _summarySettleWaiters.clear();
+  for (const waiter of _summarySettleWaiters) {
+    if (_waiterSettled(waiter)) waiter.settle(true);
+  }
 }
 
 /**
- * Resolves once every queued summary-index mutation has landed and no flush
- * is scheduled or in flight — from then on this process no longer touches
- * the index, its lock or its temp files. Callers are told a save/sweep is
- * done before its deferred index flush runs, so an owner that removes or
- * switches the data dir awaits this first. A flush refused by a held lock
- * (an overlapping flush of this process, or another process) stays queued
- * and settles when its retry lands.
+ * Resolves true once the queued summary-index mutations have landed — of
+ * `ids` only when given, else every one with no flush scheduled or in flight;
+ * from then on this process no longer touches the index for them. Callers
+ * are told a save/sweep is done before its deferred index flush runs, so an
+ * owner that removes or switches the data dir awaits this first. A flush
+ * refused by a held lock (an overlapping flush of this process, or another
+ * process) stays queued and settles when its retry lands. When `signal`
+ * aborts first it resolves false and stops waiting; the ops stay queued.
  */
-export function settleSummaryIndexWrites() {
-  if (!_hasUnsettledSummaryOps()) return Promise.resolve();
+export function settleSummaryIndexWrites({ ids = null, signal = null } = {}) {
+  const waiter = { ids, settle: null };
+  if (_waiterSettled(waiter)) return Promise.resolve(true);
+  if (signal?.aborted) return Promise.resolve(false);
   _summaryRetryTimer?.ref?.();
-  return new Promise((resolve) => _summarySettleWaiters.add(resolve));
+  return new Promise((resolve) => {
+    const onAbort = () => waiter.settle(false);
+    // The one exit, landed or abandoned: the waiter and its abort listener
+    // both go, so a long-lived signal collects nothing per settle.
+    waiter.settle = (landed) => {
+      if (!_summarySettleWaiters.delete(waiter)) return;
+      signal?.removeEventListener('abort', onAbort);
+      // Only an awaited settlement keeps the process alive for the retry.
+      if (_summarySettleWaiters.size === 0) _summaryRetryTimer?.unref?.();
+      resolve(landed);
+    };
+    _summarySettleWaiters.add(waiter);
+    signal?.addEventListener('abort', onAbort, { once: true });
+  });
 }
 
 function _scheduleSummaryRetry() {
@@ -498,11 +525,14 @@ export function _flushPendingSummaryOps({ sync = false } = {}) {
     return;
   }
   _summaryFlushInflight++;
+  const taken = [...upserts.keys(), ...removals];
+  for (const id of taken) _inflightSummaryIds.add(id);
   withFileLock(`${path}.lock`, () => _appendSummaryOpsLocked(path, text), { timeoutMs: SUMMARY_LOCK_TIMEOUT_MS })
     .then(() => _sweepStaleSummaryTempOnce(path))
     .catch(requeue)
     .finally(() => {
       _summaryFlushInflight--;
+      for (const id of taken) _inflightSummaryIds.delete(id);
       if (_pendingUpserts.size > 0 || _pendingRemovals.size > 0) _scheduleSummaryFlush();
       _notifySummarySettled();
     });

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

@@ -22,6 +22,7 @@ import {
   scanSessionFiles,
   scanSessionFilesAsync,
   stampedDerivation,
+  storedSessionCatalogRow,
 } from './store-summary-catalog.mjs';
 import { createStoredTranscriptCache, nextProjectionStamp } from './store-transcript-cache.mjs';
 import {
@@ -34,10 +35,17 @@ import { projectStoredTranscript } from './store-transcript-projection.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';
+import {
+  compactionArchivePath,
+  compactionArchiveRange,
+  readCompactionArchivePage,
+  visitCompactionArchive,
+} from './compaction-archive.mjs';
+import { attachmentHistoryRows } from './stored-attachment-history.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 { onSessionActivityChange, onSessionApprovalCardChange } from '../../../shared/session-activity-signal.mjs';
+import { inFlightSessionActivity } from './manager/runtime-state.mjs';
 import {
   readCanonicalSessionRecord as readCanonicalLifecycle,
   offerStrictSessionRecord,
@@ -59,6 +67,11 @@ export { storedAgentWorkerIndexPath } from './store-summary-locations.mjs';
 // the desktop service worker keeps its own for the deep-history prefetch.
 const storedTranscriptCache = createStoredTranscriptCache();
 
+// The attachment rows of whole stored conversations: the same cache mechanism
+// and byte budget as the windows above, as an instance of its own, which a
+// lookup can neither fill nor evict.
+const attachmentHistoryCache = createStoredTranscriptCache();
+
 /** Test seam: forget every cached projection. */
 export function clearStoredTranscriptCache() {
   storedTranscriptCache.clear();
@@ -106,7 +119,23 @@ 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'));
+// A transition that starts or settles a turn also changes the catalog rows'
+// `working` / `agentWorking` overlay. The listing that a turn's final save
+// triggers can run before the turn leaves the runtime map, and nothing else
+// re-lists: a bot home (no title write after its turn) kept `working` — a
+// spinner and no completion dot — until its next file change.
+let catalogActivity = '';
+onSessionActivityChange(() => {
+  notifyCatalogListeners('agent-activity');
+  const { working, agentWorking } = inFlightSessionActivity();
+  const next = `${[...working].sort().join(',')}|${[...agentWorking].sort().join(',')}`;
+  if (next === catalogActivity) return;
+  catalogActivity = next;
+  notifyCatalogListeners('turn-activity');
+});
+// A session started or stopped waiting on the user's approval: its catalog row
+// (`awaitingApproval`) changed, though no store file did.
+onSessionApprovalCardChange(() => notifyCatalogListeners('approval'));
 
 /** `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
@@ -232,6 +261,12 @@ export async function listStoredSessionSummaryPage(options = {}) {
   };
 }
 
+/** One session's catalog row by id, read off its record (not the paged
+ *  listing): null when the catalog would not list it. */
+export function readStoredSessionCatalogRow(id) {
+  return storedSessionCatalogRow(join(dataDir(), 'sessions'), String(id || '').trim());
+}
+
 /** Exact, fail-closed existence check for a durable session address.
  * Summary indexes and desktop metadata are presentation caches; neither may
  * make a missing sessions/<id>.json record addressable again. */
@@ -269,6 +304,7 @@ function storedSessionMetadata(sessionId, session) {
     ownerSessionId: session.ownerSessionId || session.parentSessionId || null,
     visibility: sessionVisibility(session),
     agentTag: session.agentTag || null,
+    title: session.title || null,
     cwd: session.cwd || '',
     ...(workspaceSummary(session.workspace) ? { workspace: workspaceSummary(session.workspace) } : {}),
     provider: session.provider || null,
@@ -405,6 +441,49 @@ async function produceStoredTranscript(text, stamp, context) {
   }
 }
 
+/** The rows of one session's whole stored conversation that name attachments
+ *  (see attachmentHistoryRows): its record's messages and every visible
+ *  segment of its compaction archive (a cleared or capped archive stays
+ *  excluded, as for a window). Read from the files alone, under the same
+ *  strict record authority as a transcript read, and cached by content
+ *  identity in a cache of its own: the transcript windows are untouched.
+ *  Null when the record is absent, unreadable or not this session's. */
+async function readStoredAttachmentHistory(sessionId, recordPath, archivePath) {
+  const recordStat = probePath(recordPath);
+  if (recordStat.state !== PROBE_PRESENT) return null;
+  const archive = probePath(archivePath);
+  const key = `${sessionId}|attachments`;
+  let complete = true;
+  const { value } = await attachmentHistoryCache.read({
+    key,
+    fingerprint: [archive.state, archive.mtimeMs, archive.ctimeMs, archive.size, archive.ino, archive.dev].join(':'),
+    fileStat: recordStat,
+    loadText: () => {
+      const body = readTextFile(recordPath);
+      return body.state === PROBE_PRESENT ? body.text : null;
+    },
+    produce: async (text) => {
+      const record = readTopLevelLifecycleRecord(text);
+      if (isLifecycleUnreadable(record) || record.id !== sessionId) return null;
+      const { restoreTranscriptItems } = await import('./transcript-restore/restore.mjs');
+      const items = [];
+      const range = compactionArchiveRange(record.doc);
+      // An archive that exists but could not be walked is a transient miss,
+      // not a state worth keeping.
+      const walked = range
+        ? await visitCompactionArchive(join(dataDir(), 'sessions'), sessionId, range, (segment) =>
+            items.push(...attachmentHistoryRows(segment))
+          )
+        : true;
+      complete = walked || archive.state !== PROBE_PRESENT;
+      items.push(...attachmentHistoryRows(restoreTranscriptItems(record.doc.messages, { sessionId })));
+      return { sessionId, items };
+    },
+  });
+  if (!complete) attachmentHistoryCache.forget(key);
+  return value ?? null;
+}
+
 /** Read exactly one persisted session for a visible desktop pane. This never
  * enumerates siblings. Normal reads stay independent of runtime ownership;
  * interrupted turns conditionally use the same durable reconnect recovery as
@@ -416,6 +495,8 @@ export async function readStoredSessionTranscript(id, options = {}) {
   // absent, unreadable, ambiguous or foreign record yields no transcript.
   const { recordPath, checkpointPath, archivePath } = storedTranscriptInputPaths(sessionId);
   if (options.metadataOnly === true) return readStoredSessionMetadata(recordPath, sessionId);
+  // The attachments the whole conversation names, apart from any window.
+  if (options.attachmentHistory === true) return readStoredAttachmentHistory(sessionId, recordPath, archivePath);
   // One page of the display-only compaction archive (the live head loader
   // pages it once a runtime's in-memory rows are exhausted).
   if (options.compactionArchive && typeof options.compactionArchive === 'object') {

package/src/runtime/agent/orchestrator/session/stored-attachment-history.mjs

@@ -0,0 +1,32 @@
+// The attachments a session's whole stored conversation names (its record and
+// its compaction archive), reduced to the metadata that says which rows name
+// which attachment. Whether an attachment id belongs to a session is decided
+// against this, not against a transcript window (a tail plus the pages paged
+// in), which no longer holds rows a compaction moved into the archive.
+
+const pick = (entry, keys) =>
+  Object.fromEntries(keys.filter((key) => entry?.[key] != null).map((key) => [key, entry[key]]));
+const picked = (list, keys) => (Array.isArray(list) ? list.map((entry) => pick(entry, keys)) : []);
+
+/** The rows of `items` that name attachments, reduced to the fields the
+ *  desktop reads to attribute an id to its row: the row kind (and a notice's
+ *  routine / room kind) and each attachment's id, name, type and size. No
+ *  text, tool output or other row content is kept. */
+export function attachmentHistoryRows(items) {
+  const rows = [];
+  for (const item of Array.isArray(items) ? items : []) {
+    const attachments = picked(item?.attachments, ['id', 'name', 'mimeType', 'kind', 'size']);
+    const images = picked(item?.images, ['attachmentRef', 'name', 'mimeType', 'bytes']);
+    const imageRefs = picked(item?.imageRefs, ['ref']);
+    if (!attachments.length && !images.length && !imageRefs.length) continue;
+    rows.push({
+      kind: item.kind,
+      ...(item.routine?.kind ? { routine: { kind: item.routine.kind } } : {}),
+      ...(item.room?.kind ? { room: { kind: item.room.kind } } : {}),
+      ...(attachments.length ? { attachments } : {}),
+      ...(images.length ? { images } : {}),
+      ...(imageRefs.length ? { imageRefs } : {}),
+    });
+  }
+  return rows;
+}