@awak-app/simy-cli 0.7.33 → 0.7.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awak-app/simy-cli",
-  "version": "0.7.33",
+  "version": "0.7.35",
   "description": "Local SIMY executor for non-coding Local Tasks and Agentic Loop runs.",
   "type": "module",
   "bin": {

package/src/cli-contract.js

@@ -14,7 +14,7 @@ import {
 } from "./durable-local-task-steps-contract.js";
 import { buildExecutionCapabilityContract } from "./execution-capability-contract.js";
 
-export const CLI_VERSION = "0.7.33";
+export const CLI_VERSION = "0.7.35";
 export const CLI_API_CONTRACT_VERSION = 10;
 
 export function narrativeImageCapabilityMetadata() {

package/src/cli-observability.js

@@ -7,7 +7,7 @@ import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { webApiHeaders, webApiUrl } from './web-api.js';
 // Keep this leaf module package-safe: hooks load it before the full CLI contract.
-const CLI_VERSION = '0.7.33';
+const CLI_VERSION = '0.7.35';
 
 const STORE = 'cli-observability-state.json';
 const LEGACY_CONFIG = 'cli-observability.json';

package/src/codex-plugins/simy/hooks/delivery-loop.mjs

@@ -340,7 +340,8 @@ export async function readRecord(root = rootDirectory(), provider, session) {
   } catch { return null; } // Match listRecords' treatment of unreadable records.
 }
 const RECORD_NAME = /^[a-f0-9]{64}\.json$/;
-const RECORD_CACHE_LIMIT = 500;
+const RECORD_CACHE_LIMIT = 10_000;
+const RECORD_CACHE_BYTES = 32 * 1024 * 1024;
 const READ_CONCURRENCY = 8;
 async function recordNames(root) {
   try { return (await readdir(root)).filter(name => RECORD_NAME.test(name)).sort(); }
@@ -367,13 +368,16 @@ export async function listRecords(root = rootDirectory()) {
 // A shared candidate/display index, never mutation authority. Every list checks
 // metadata so external hooks, removals and direct writes invalidate cached JSON.
 // Fresh execution reads and updateRecord locks remain independent of this index.
-export function createRecordReader(root = rootDirectory()) {
+export function createRecordReader(root = rootDirectory(), { cacheEntries = RECORD_CACHE_LIMIT, cacheBytes = RECORD_CACHE_BYTES } = {}) {
+  if (!Number.isSafeInteger(cacheEntries) || cacheEntries < 1 || cacheEntries > RECORD_CACHE_LIMIT ||
+      !Number.isSafeInteger(cacheBytes) || cacheBytes < 1 || cacheBytes > RECORD_CACHE_BYTES) throw new Error('Invalid record cache limits.');
   const cache = new Map();
-  let inFlight = null, closed = false;
+  let inFlight = null, closed = false, retainedBytes = 0;
+  const discard = name => { retainedBytes -= cache.get(name)?.bytes || 0; cache.delete(name); };
   const fingerprint = info => [info.dev, info.ino, info.size, info.mtimeNs, info.ctimeNs].join(':');
   const scan = async () => {
-    const names = await recordNames(root), live = new Set(names.slice(0, RECORD_CACHE_LIMIT));
-    for (const name of cache.keys()) if (!live.has(name)) cache.delete(name);
+    const names = await recordNames(root), live = new Set(names.slice(0, cacheEntries));
+    for (const name of cache.keys()) if (!live.has(name)) discard(name);
     return mapRecordNames(names, async name => {
       const path = join(root, name);
       try {
@@ -384,10 +388,14 @@ export function createRecordReader(root = rootDirectory()) {
         // Do not retain a value when a write races the read; the next list must
         // inspect it again. This also prevents malformed transient JSON sticking.
         const after = await stat(path, { bigint: true });
-        if (live.has(name) && fingerprint(after) === key) cache.set(name, { key, record });
-        else cache.delete(name);
+        discard(name);
+        const bytes = Number(after.size);
+        if (live.has(name) && bytes <= cacheBytes && fingerprint(after) === key) {
+          while (retainedBytes + bytes > cacheBytes && cache.size) discard(cache.keys().next().value);
+          cache.set(name, { key, record, bytes }); retainedBytes += bytes;
+        }
         return record;
-      } catch { cache.delete(name); return null; }
+      } catch { discard(name); return null; }
     });
   };
   return {
@@ -398,7 +406,7 @@ export function createRecordReader(root = rootDirectory()) {
       // cached records or a simultaneous caller's view.
       return currentProviderConsent(root, structuredClone(await inFlight));
     },
-    async close() { closed = true; await inFlight?.catch(() => {}); cache.clear(); },
+    async close() { closed = true; await inFlight?.catch(() => {}); cache.clear(); retainedBytes = 0; },
   };
 }
 function positive(value, fallback, max) {

package/src/desktop-host.js

@@ -82,9 +82,9 @@ import {
 } from "./desktop-process-lock.js";
 
 const silentLogger = { log() {}, error() {} };
-// Match the native DesktopStatusFrames limit: 200 conversation summaries can
-// exceed 128 KiB, including after a signed runtime handoff.
-const MAX_DESKTOP_FRAME_BYTES = 8 * 1024 * 1024;
+// Match the native DesktopStatusFrames limit for full retained histories,
+// including after a signed runtime handoff. Native delivery remains bounded.
+const MAX_DESKTOP_FRAME_BYTES = 64 * 1024 * 1024;
 
 async function withReadCancellation(signal, work) {
   signal.throwIfAborted();
@@ -171,11 +171,16 @@ export async function startDesktopHost({ input = process.stdin, output = process
   // volatile; reuse the encoded body after comparing freshly authorized data.
   // Detach the comparison value because registries may mutate nested objects.
   let encodedStatus = null, lastStatus = null, updateProgress = null;
+  let projectCatalogFrame = status => status;
+  let resolveFirstStatus;
+  const firstStatus = new Promise(resolve => { resolveFirstStatus = resolve; });
+  let startupPublication;
   // Per verified source reader, never accepted from a projection or command.
   const acceptanceReaderId = randomUUID();
   let acceptanceReadbackSequence = 0;
   let remoteHosts;
   const emitStatus = status => {
+    status = projectCatalogFrame(status);
     const updateSettings = updater?.snapshot?.() || {};
     status = { ...status, update: { ...status.update,
       auto_update_supported: updateSettings.auto_update_supported === true,
@@ -207,6 +212,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
     }
     const observation = sampledAt === undefined ? '' : `"sampledAt":${JSON.stringify(sampledAt)}${encodedStatus ? ',' : ''}`;
     frames.write(`{"type":"status","status":{${observation}${encodedStatus}}}\n`, true);
+    resolveFirstStatus?.(); resolveFirstStatus = null;
   };
   const root = env.SIMY_HOME?.trim() || join(homedir(), ".simy");
   const controllerPreferences = createControllerStore(root);
@@ -224,6 +230,8 @@ export async function startDesktopHost({ input = process.stdin, output = process
   const supervisorToken = lock?.nonce || env.SIMY_DESKTOP_SUPERVISOR_TOKEN;
   const deliveryRoot = join(root, "delivery-hooks");
   const recordReader = createRecordReader(deliveryRoot);
+  let frameRecordScope = null, frameRecords = new Map();
+  const pendingCatalogPreferences = new Map();
   let providerLinks = await readProviderLinks(root);
   const providerLinkBusy = new Set(), providerLinkFeedback = {}, explicitAnalyses = new Set();
   const linkedSessions = sessions => sessions.filter(item => providerLinks[item.provider]?.connected === true);
@@ -291,6 +299,8 @@ export async function startDesktopHost({ input = process.stdin, output = process
       nativeCompletionInFlight.clear();
     }
     if (previousScope !== accessScope(currentAccess)) {
+      frameRecordScope = null; frameRecords.clear();
+      pendingCatalogPreferences.clear();
       statisticsCache.clear();
       activeStatisticsRead?.controller.abort();
       explicitAnalyses.clear();
@@ -539,6 +549,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
   let commands;
   let sessionStatus = { sessions: [], providers: { codex: { discovery: "loading", reason: null }, claude: { discovery: "loading", reason: null } }, refreshedAt: null, initialLoading: true };
   let sessionRefresh = null, sessionRefreshedAt = 0, sessionRefreshAgain = false, discoveryController = null, discoveryStopped = false;
+  let catalogRevision = 0;
   let enrichmentController = null, sessionEnrichment = null;
   let catalogAnalysisJob = null, catalogAnalysisAgain = false;
   const withCurrentSettings = (sessions, records) => {
@@ -636,17 +647,21 @@ export async function startDesktopHost({ input = process.stdin, output = process
         sessionStatus = { ...sessionStatus, ...value,
           sessions: linkedSessions(merge(sessionStatus.sessions, value.sessions)).sort(compareSessionWork),
           selectionCandidates: merge(sessionStatus.selectionCandidates || [], value.selectionCandidates),
-          initialLoading: false, completeProviders: [...complete], discoveryAttempt: attempt };
+          initialLoading: false, completeProviders: [...complete], discoveryAttempt: attempt, catalogRevision: ++catalogRevision };
         sessionRefreshedAt = Date.now();
         void publish().catch(() => {});
         void refreshCatalogAnalysis();
       };
-      sessionRefresh = boundedDiscovery(signal => (dependencies.discoverSessions || discoverSessions)({
+      const firstPageTimeoutMs = dependencies.discoveryTimeoutMs ?? 30_000;
+      const historyTimeoutMs = dependencies.historyDiscoveryTimeoutMs ?? dependencies.discoveryTimeoutMs ?? 300_000;
+      sessionRefresh = boundedDiscovery((signal, startHistory) => (dependencies.discoverSessions || discoverSessions)({
         root: deliveryRoot, signal, onDrain: trackDiscoveryDrain, includeArchived: true, includeSelectionCandidates: true,
+        readRecords: () => recordReader.list(),
         connectedProviders: PROVIDER_LINKS.filter(provider => providerLinks[provider].connected),
-        timeoutMs: dependencies.discoveryTimeoutMs ?? 30_000,
-        onProgress: value => applyCatalog(value, signal),
-      }), { signal: controller.signal, timeoutMs: (dependencies.discoveryTimeoutMs ?? 30_000) + 1000, onDrain: dependencies.discoverSessions ? undefined : trackDiscoveryDrain })
+        timeoutMs: firstPageTimeoutMs, historyTimeoutMs,
+        onProgress: value => { if (value.sessions?.length) startHistory(); return applyCatalog(value, signal); },
+      }), { signal: controller.signal, timeoutMs: firstPageTimeoutMs + 1000, historyTimeoutMs: historyTimeoutMs + 1000,
+        onDrain: dependencies.discoverSessions ? undefined : trackDiscoveryDrain })
         .then(async value => {
           await applyCatalog(value);
           if (closed || relay || controller.signal.aborted) return;
@@ -678,6 +693,33 @@ export async function startDesktopHost({ input = process.stdin, output = process
     }
     return sessionStatus;
   };
+  // Provider metadata is already scoped and cancelable. A connection heartbeat
+  // can publish it while optional Action/deadline enrichment owns a slow full
+  // projection. These rows do not authorize execution or mint record readbacks.
+  projectCatalogFrame = status => {
+    if (!desktopAccessReady(status.access) || accessScope(status.access) !== accessScope(currentAccess) ||
+        sessionStatus.initialLoading !== false || !sessionStatus.discoveryAttempt) return status;
+    const previous = status.sessionSupervision;
+    if (!pendingCatalogPreferences.size && previous?.discoveryAttempt?.id === sessionStatus.discoveryAttempt.id &&
+        previous.catalogRevision === sessionStatus.catalogRevision && previous.initialLoading === false &&
+        previous.historyLoading === sessionStatus.historyLoading) return status;
+    const prior = new Map((previous?.sessions || []).map(row => [`${row.provider}:${row.session}`, row]));
+    const records = frameRecordScope === accessScope(currentAccess) ? frameRecords : new Map();
+    const sessions = linkedSessions(sessionStatus.sessions).map(candidate => {
+      const key = `${candidate.provider}:${candidate.session}`, record = pendingCatalogPreferences.get(key) || records.get(key);
+      const observed = projectSessionAutoContinue({ ...prior.get(key), ...candidate }, record);
+      const analyzed = analysisManager?.project(observed) || observed;
+      const row = automaticContinuation?.project(analyzed) || analyzed;
+      const projected = { ...row, actionDeadline: row.actionDeadline || { status: 'unavailable', online: false, reminder: null },
+        workState: sessionWorkState(row, record?.run, { provider: sessionStatus.providers?.[candidate.provider] }) };
+      return { ...projected, conversationPresentation: conversationPresentation(projected, record?.run) };
+    }).sort(compareSessionWork);
+    const providers = { ...sessionStatus.providers };
+    for (const provider of PROVIDER_LINKS) {
+      if (!providerLinks[provider].connected) providers[provider] = { discovery: 'disconnected', reason: null };
+    }
+    return { ...status, sessionSupervision: { ...sessionStatus, sessions, providers } };
+  };
   const claudeDesktopNative = dependencies.claudeDesktopNative || createClaudeDesktopNativeAdapter();
   const archiveClaudeDesktop = createClaudeDesktopArchiveController({ native: claudeDesktopNative, ...(dependencies.readClaudeDesktopTarget ? { readTarget: dependencies.readClaudeDesktopTarget } : {}) });
   const selectedSession = async (command, { reuseDiscovery = false, preferObserved = false } = {}) => {
@@ -883,10 +925,24 @@ export async function startDesktopHost({ input = process.stdin, output = process
         publishAgain = true;
         return;
       }
+      for (const [key, saved] of pendingCatalogPreferences) {
+        const current = await readRecord(deliveryRoot, saved.provider, saved.session);
+        if (pendingCatalogPreferences.get(key) === saved) pendingCatalogPreferences.set(key, current || {
+          provider: saved.provider, session: saved.session, cwd: saved.cwd,
+          autoContinue: false, autoContinueEpoch: null, tracked: false, monitor: false });
+      }
+      if (!await acceptStatusAccess(sampledAccess)) { publishAgain = true; return; }
+      if (JSON.stringify(await readProviderLinks(root)) !== requestedLinks) { publishAgain = true; return; }
+      const preferenceAccess = agent.getDesktopAccess ? agent.getDesktopAccess() : await accessSnapshot();
+      if (!sameAccess(preferenceAccess, status.access)) { publishAgain = true; return; }
       // Select cached record evidence after all asynchronous authorization:
       // a full projection may have advanced it while those reads were waiting.
       const sameScope = desktopAccessReady(currentAccess) &&
         accessScope(lastStatus?.access) === accessScope(currentAccess);
+      const cached = sameScope && lastStatus && controllerScope(lastStatus) === controllerScope(status) ? structuredClone(lastStatus) : null;
+      // A heartbeat is a complete frame: retain optional scoped fields until
+      // their replacement is ready, while fresh access/provider data wins.
+      if (cached) status = { ...cached, ...status };
       status.deliveryHooks = sameScope && lastStatus?.deliveryHooks
         ? structuredClone(lastStatus.deliveryHooks) : { runs: [], providers: {} };
       status.sessionSupervision = sameScope && lastStatus?.sessionSupervision
@@ -896,7 +952,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
       status.nativeDevelopmentReports = sameScope && sameReportController(nativeDevelopmentReportsController, {
         scope: accessScope(status.access), controllerScope: controllerScope(status), deviceSession: reportDeviceSession(),
       }) && nativeDevelopmentReportsScope === accessScope(currentAccess)
-        ? structuredClone(nativeDevelopmentReports) : { state: 'loading', enrollments: [] };
+        ? { ...structuredClone(cached?.nativeDevelopmentReports || {}), ...structuredClone(nativeDevelopmentReports) } : { state: 'loading', enrollments: [] };
       // Cached enrichment must follow the current connection preference even
       // while a full projection is waiting on records or remote metadata.
       status.deliveryHooks.runs = linkedSessions(status.deliveryHooks.runs || []);
@@ -936,6 +992,15 @@ export async function startDesktopHost({ input = process.stdin, output = process
       if (preferenceScope) await controllerPreferences.load(preferenceScope);
       const requestedLinks = await decorateProviderSettings(status);
       const allRecords = await recordReader.list();
+      if (accessScope(currentAccess) === requestedScope) {
+        // Keep explicit preference overrides until the scope changes. A full
+        // projection that started before the save can finish after this read.
+        // Heartbeats refresh these identities from disk, including external OFF.
+        frameRecordScope = requestedScope;
+        frameRecords = new Map(allRecords.map(record => [`${record.provider}:${record.session}`, record]));
+      }
+      // Begin the usable catalog before optional record/Action enrichment.
+      refreshSessions();
       const records = linkedSessions(allRecords);
       const update = status.update || updater.snapshot?.() || {};
       if (!stoppingForUpdate) unfinishedDesktopWork = hasUnfinishedSessions(allRecords);
@@ -966,7 +1031,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
       if (reportController.controllerScope) void syncEmailPreferences(reportController);
       const preferenceState = reportController.controllerScope ? await controllerPreferences.load(reportController.controllerScope) : null;
       status.notificationPreferences = preferenceState?.notificationPreferences || {};
-      status.nativeDevelopmentReports = { ...structuredClone(sameReportController(reportController, nativeDevelopmentReportsController) ? nativeDevelopmentReports : { state: 'loading', enrollments: [] }), deliveries: Object.values(preferenceState?.conversations || {}).flatMap(row => Object.values(row.emailDeliveries || {})), preferences: Object.values(preferenceState?.conversations || {}).flatMap(row => row.emailPreference ? [{ ...row.emailPreference.request, sync: row.emailPreference.state }] : []) };
+      status.nativeDevelopmentReports = { ...structuredClone(sameReportController(reportController, nativeDevelopmentReportsController) ? nativeDevelopmentReports : { state: 'loading', enrollments: [] }), deliveries: Object.values(preferenceState?.conversations || {}).flatMap(row => Object.values(row.emailDeliveries || {})).map(({ receipt_id, ...delivery }) => delivery), preferences: Object.values(preferenceState?.conversations || {}).flatMap(row => row.emailPreference ? [{ ...row.emailPreference.request, sync: row.emailPreference.state }] : []) };
       // This is an asynchronous local attestation. It neither changes a
       // Delivery Loop nor places receipt or device data in status frames.
       let reportCompletions = [];
@@ -1266,7 +1331,8 @@ export async function startDesktopHost({ input = process.stdin, output = process
       }
     } });
     await refreshPlugins();
-    await publish();
+    startupPublication = publish();
+    void startupPublication.catch(() => {});
     const maintenance = new Map();
     const tick = worker => {
       if (closed || relay || !coordinator.acceptsNewWork() || maintenance.has(worker)) return;
@@ -1920,8 +1986,11 @@ export async function startDesktopHost({ input = process.stdin, output = process
           if (command.enabled) await authorizeWork(commandScope);
           const saved = await (dependencies.setSessionAutoContinue || saveSessionAutoContinuePreference)({ root: join(root, 'delivery-hooks'),
             provider: command.provider, session: command.session, enabled: command.enabled, initialContinuationPolicy: command.continuationPolicy, admission, target, expectedProviderEpoch: providerEpoch });
-          if (saved) sessionStatus = { ...sessionStatus,
-            sessions: sessionStatus.sessions.map(candidate => projectSessionAutoContinue(candidate, saved)) };
+          if (saved) {
+            pendingCatalogPreferences.set(`${saved.provider}:${saved.session}`, saved);
+            sessionStatus = { ...sessionStatus, catalogRevision: ++catalogRevision,
+              sessions: sessionStatus.sessions.map(candidate => projectSessionAutoContinue(candidate, saved)) };
+          }
           if (!command.enabled) automaticContinuation.revoke(command.provider, command.session);
           // Acknowledge the durable preference before discovery or analysis.
           emit({ type: "result", id: command.id, ok: true });
@@ -2252,6 +2321,10 @@ export async function startDesktopHost({ input = process.stdin, output = process
     ownerTransport = await createOwnerTransport({ root, nonce: lock.nonce, allowedActions, allowControllerArchive: env.SIMY_REMOTE_CHILD !== '1', dispatch: command => commands.emit('line', JSON.stringify(command)) });
     await publish();
   }
+  // Register controls before awaiting initial presentation. A fast, authorized
+  // catalog frame is sufficient; unrelated optional enrichment may still wait.
+  try { await Promise.race([startupPublication, firstStatus]); }
+  catch (error) { await close(); throw error; }
   return { close, publish, agent };
 }
 

package/src/session-supervision/codex-app-server.js

@@ -235,11 +235,12 @@ export function codexThreadMetadata(thread) {
   };
 }
 
-export async function listCodexSessions({ client, all = false, signal, onPage, maxPages = 40, pageSize = 25, maxSessions = RECENT_SESSION_LIMIT, archived = false, inspectState = false, prioritySessions = [], observationBudgetMs = 3000, codexHome } = {}) {
+export async function listCodexSessions({ client, all = false, signal, onPage, maxPages = 40, pageSize = 25, historyPageSize = 200, maxSessions = RECENT_SESSION_LIMIT, archived = false, inspectState = false, prioritySessions = [], observationBudgetMs = 3000, codexHome } = {}) {
   const sessions = [];
   const windowSize = all ? Infinity : Math.min(maxSessions, maxPages * pageSize);
   const cursors = new Set(), ids = new Set();
   let cursor = null, listed = 0, pages = 0, batchSize = pageSize, nextProgress = 0;
+  let reducedBatch = false;
   try {
     while (pages < Math.max(maxPages, Math.ceil(windowSize / batchSize)) && listed < windowSize) {
       signal?.throwIfAborted();
@@ -251,6 +252,7 @@ export async function listCodexSessions({ client, all = false, signal, onPage, m
         // Keep the transport's byte limit. Retry the same cursor in smaller
         // batches rather than dropping discovery for large metadata envelopes.
         if (error?.code !== 'response_too_large' || limit <= 1) throw error;
+        reducedBatch = true;
         batchSize = Math.max(1, Math.floor(limit / 2));
         continue;
       }
@@ -267,6 +269,10 @@ export async function listCodexSessions({ client, all = false, signal, onPage, m
       if (onPage && (pages === 1 || sessions.length >= nextProgress)) {
         await onPage(sessions); nextProgress = Math.max(100, sessions.length * 2);
       }
+      // Keep the first frame small, then amortize expensive metadata RPCs over
+      // bounded history pages. The transport byte ceiling still wins: once a
+      // response is oversized, retain its reduced batch for the rest of the scan.
+      if (all && pages === 1 && !reducedBatch) batchSize = Math.max(pageSize, Math.min(200, historyPageSize));
       cursor = response?.nextCursor || null;
       if (!cursor) break;
       if (typeof cursor !== 'string' || cursors.has(cursor))

package/src/session-supervision/index.js

@@ -165,20 +165,25 @@ export async function discoverSessions(options = {}) {
 }
 
 async function discoverSessionCatalog({ root, openClient = openCodexAppServer, listClaude = listClaudeSessions,
-  inspectProcess = processIdentity, now: requestedNow, signal, listCodexTitles = readCodexTitles, listCodexChildren = readCodexChildSessions, codexHome, connectedProviders = ['codex', 'claude'], includeArchived = false, includeSelectionCandidates = false, catalogSnapshot, onProgress } = {}) {
+  inspectProcess = processIdentity, now: requestedNow, signal, listCodexTitles = readCodexTitles, listCodexChildren = readCodexChildSessions, codexHome, connectedProviders = ['codex', 'claude'], includeArchived = false, includeSelectionCandidates = false, catalogSnapshot, recordSnapshot, archiveReconciliations = new Map(), readRecords = listRecords, onProgress } = {}) {
   const now = requestedNow ?? Date.now();
   const assertActive = () => { if (signal?.aborted) throw new CodexAppServerError('cancelled', 'Conversation discovery was cancelled.'); };
   assertActive();
   const connected = new Set(connectedProviders);
-  const records = (await listRecords(root)).filter(record => connected.has(record.provider));
+  const records = (recordSnapshot || await readRecords(root)).filter(record => connected.has(record.provider));
   const priorities = records.filter(retainedSession);
   let archivedCodex = [];
   let discovered = [], codexError = null, codexReasonCode = null, claude = [], claudeError = null;
   let archiveStates = new Map();
   const progress = async snapshot => {
     if (!onProgress || signal?.aborted) return;
+    const observed = new Set([...(snapshot.discovered || []), ...(snapshot.claude || []), ...(snapshot.archivedCodex || [])]
+      .map(item => `${item.provider}:${item.session}`));
     const value = await discoverSessionCatalog({ root, inspectProcess, now: requestedNow, signal, connectedProviders, includeArchived, codexHome,
-      catalogSnapshot: snapshot, listCodexChildren: async () => [], listCodexTitles: async () => new Map() });
+      // Pages reuse this attempt's records. Do not rescan or project the entire
+      // retained corpus for every page; the complete catalog still includes it.
+      catalogSnapshot: snapshot, recordSnapshot: records.filter(record => observed.has(`${record.provider}:${record.session}`)), archiveReconciliations,
+      listCodexChildren: async () => [], listCodexTitles: async () => new Map() });
     if (!signal?.aborted) await onProgress(value);
   };
   if (catalogSnapshot) {
@@ -234,11 +239,22 @@ async function discoverSessionCatalog({ root, openClient = openCodexAppServer, l
     const claudeItem = record.provider === 'claude' ? claude.find(item => item.session === record.session && item.cwd === record.cwd) : null;
     const archiveState = record.provider === 'codex' ? archiveStates.get(record.session) ?? (activeCodex.has(record.session) ? false : undefined) : claudeItem?.archived;
     if (typeof archiveState !== 'boolean') continue;
+    const key = `${record.provider}:${record.session}`;
+    const reconciled = archiveReconciliations.get(key);
+    if (reconciled?.archived === archiveState) {
+      records[index] = reconciled.record;
+      continue;
+    }
+    // Pages repeat an ever-growing prefix. Persist positive archive fencing
+    // before exposing it once, rather than repeatedly refreshing the same old
+    // observation and contending with hook writers on every page. This map is
+    // private to one scoped attempt; execution still reads fresh durable state.
+    const remember = () => archiveReconciliations.set(key, { archived: archiveState, record: records[index] });
     const isArchived = archiveState;
     if (isArchived) await recordProviderArchive(root, record.provider, record.session, true, now);
-    if (isArchived && record.providerArchived === true) continue;
-    if (!isArchived && !(record.providerArchived === true && archiveState === false)) continue;
-    try { records[index] = await updateRecord(root, record.provider, record.session, current => {
+    if (isArchived && record.providerArchived === true) { remember(); continue; }
+    if (!isArchived && !(record.providerArchived === true && archiveState === false)) { remember(); continue; }
+    try { const updated = await updateRecord(root, record.provider, record.session, current => {
       if (!current) return current;
       current.providerArchived = isArchived;
       if (isArchived) {
@@ -251,11 +267,16 @@ async function discoverSessionCatalog({ root, openClient = openCodexAppServer, l
       }
       return current;
     });
+      if (updated) records[index] = updated;
       if (!isArchived) await recordProviderArchive(root, record.provider, record.session, false, now);
+      remember();
     } catch {
       // Reconciliation can contend with a hook writer or an unreclaimable
       // legacy lock. Preserve stored state and retry on the next refresh;
       // one record must not discard either provider's entire catalog.
+      // A successfully persisted positive fence already revokes execution.
+      // Retry its JSON reconciliation on the next attempt, not each old prefix.
+      if (isArchived) remember();
     }
   }
   assertActive();

package/src/session-supervision/owner-transport.js

@@ -18,7 +18,10 @@ export async function createOwnerTransport({ root, nonce, allowedActions, dispat
   let latest;
   const send = (peer, frame) => {
     if (peer.destroyed) return;
-    if (frame.type !== 'status' && peer.writableLength > 8 * 1024 * 1024) { peer.destroy(); return; }
+    // A valid full-history status can already occupy up to 64 MiB of the
+    // socket queue. Preserve room for bounded control receipts rather than
+    // disconnecting the viewer as soon as it requests a result behind it.
+    if (frame.type !== 'status' && peer.writableLength > (64 + 8) * 1024 * 1024) { peer.destroy(); return; }
     writers.get(peer).write(JSON.stringify(frame) + '\n', frame.type === 'status');
   };
   const server = createServer(peer => {

package/src/session-supervision/progressive-discovery.js

@@ -1,7 +1,9 @@
 // A deadline releases the caller even when an adapter ignores cancellation.
 // The adapter still receives an abort signal; late values never reach the UI.
-export async function boundedDiscovery(work, { signal, timeoutMs = 30_000, onDrain } = {}) {
+export async function boundedDiscovery(work, { signal, timeoutMs = 30_000, historyTimeoutMs = timeoutMs, onDrain } = {}) {
   const controller = new AbortController();
+  const startedAt = Date.now();
+  let historyStarted = false;
   let timer, rejectStop;
   const stopped = new Promise((_, reject) => { rejectStop = reject; });
   const cancel = () => {
@@ -9,14 +11,23 @@ export async function boundedDiscovery(work, { signal, timeoutMs = 30_000, onDra
     controller.abort(error); rejectStop(error);
   };
   signal?.addEventListener('abort', cancel, { once: true });
-  timer = setTimeout(() => {
+  const expire = () => {
     const error = Object.assign(new Error('Conversation discovery timed out. Refresh to retry.'), { code: 'discovery_timeout' });
     controller.abort(error); rejectStop(error);
-  }, timeoutMs);
+  };
+  timer = setTimeout(expire, timeoutMs);
+  const startHistory = () => {
+    if (historyStarted || controller.signal.aborted) return;
+    historyStarted = true;
+    clearTimeout(timer);
+    // The background budget is measured from the original request. Repeated
+    // pages cannot postpone the absolute deadline indefinitely.
+    timer = setTimeout(expire, Math.max(0, startedAt + Math.max(timeoutMs, historyTimeoutMs) - Date.now()));
+  };
   try {
     if (signal?.aborted) cancel();
     const operation = Promise.resolve().then(() => {
-      controller.signal.throwIfAborted(); return work(controller.signal);
+      controller.signal.throwIfAborted(); return work(controller.signal, startHistory);
     });
     onDrain?.(operation.then(() => {}, () => {}));
     return await Promise.race([stopped, operation]);
@@ -27,7 +38,7 @@ export async function boundedDiscovery(work, { signal, timeoutMs = 30_000, onDra
   }
 }
 
-export async function discoverProgressively({ discover, onProgress, signal, timeoutMs = 30_000,
+export async function discoverProgressively({ discover, onProgress, signal, timeoutMs = 30_000, historyTimeoutMs = timeoutMs,
   connectedProviders = ['codex', 'claude'], onDrain, ...options }) {
   const values = new Map(), complete = new Set(), settled = new Set();
   let notifications = Promise.resolve();
@@ -46,10 +57,12 @@ export async function discoverProgressively({ discover, onProgress, signal, time
   };
   await Promise.all(connectedProviders.map(async provider => {
     try {
-      const value = await boundedDiscovery(childSignal => discover({ ...options, signal: childSignal,
+      const value = await boundedDiscovery((childSignal, startHistory) => discover({ ...options, signal: childSignal,
         connectedProviders: [provider], onProgress: async value => {
-          childSignal.throwIfAborted(); values.set(provider, value); await notify();
-        } }), { signal, timeoutMs, onDrain });
+          childSignal.throwIfAborted();
+          if (value.sessions?.length) startHistory();
+          values.set(provider, value); await notify();
+        } }), { signal, timeoutMs, historyTimeoutMs, onDrain });
       signal?.throwIfAborted();
       values.set(provider, value);
       if (['ready', 'local_index'].includes(value.providers?.[provider]?.discovery)) complete.add(provider);

package/src/session-supervision/remote-hosts.js

@@ -9,7 +9,7 @@ import { compareSessionWork } from './work-state.js';
 import { manualAcceptanceCommand, matchesManualAcceptanceControls, manualAcceptanceContinuation } from './manual-acceptance-command.js';
 import { remoteHostRecovery } from './remote-host-recovery.js';
 
-const MAX_FRAME = 8 * 1024 * 1024;
+const MAX_FRAME = 64 * 1024 * 1024;
 const MAX_HOSTS = 8;
 const aliasPattern = /^[a-zA-Z0-9][a-zA-Z0-9._@-]{0,127}$/;
 // Resolve the saved alias on every connection. A user's multiplexed SSH master

package/src/sqm/local-tests.js

@@ -16,7 +16,8 @@ const profiles = {
     // finite catalog-owned deadline while allowing slow local process I/O.
     { id: 'repair-and-stop-boundaries', timeoutMs: 1_200_000, files: ['test/purpose-search.test.js', 'test/delivery-explicit-resume.test.js', 'test/purpose-continuation.test.js'] },
     { id: 'sqm-runner', files: ['test/sqm-local-tests.test.js'] },
-    { id: 'provider-startup', files: ['test/codex-app-server-discovery.test.js', 'test/session-supervision.test.js'] },
+    { id: 'provider-startup', files: ['test/codex-app-server-discovery.test.js', 'test/session-supervision.test.js',
+      'test/progressive-discovery.test.js', 'test/desktop-record-index.test.js', 'test/desktop-background-performance.test.js'] },
     { id: 'handoff-and-audit-recovery', files: ['test/consistency-handoff.test.js', 'test/consistency-monitor.test.js', 'test/consistency-auditor.test.js', 'test/desktop-host.test.js'] },
     { id: 'migration-and-current-outcomes', files: ['test/autonomous-upgrade.test.js', 'test/local-delivery-runtime.test.js', 'test/delivery-migration-crash.test.js', 'test/purpose-inspection.test.js', 'test/purpose-search-scenarios.test.js', 'test/sqm-large-diff.test.js'] },
   ],