@farmslot/protocol 0.83.1 → 0.84.0

package/dist/client-cache/cache.js

@@ -3,6 +3,7 @@ import { Methods } from '../rpc/registry.js';
 import { runListVersion } from '../runs/list-version.js';
 import { ResourceCollectorAdmission } from './collector-admission.js';
 import { resourceBudgetEvictions, resourceContentWithinLimits, verifyResourceContent, verifyResourceContentInSlices, } from './content.js';
+import { createFleetEntityView, createPREntityView, isEntityStoreId, prEntityStoreId, prViewProject, } from './entity-views.js';
 import { canonicalResourceJson, isKnownResourceFamily, RESOURCE_PUBLISH_INTERVAL_MS, RESOURCE_REREAD_INTERVAL_MS, RESOURCE_RETRY_MAX_WAIT_MS, resourceKeyId, } from './keys.js';
 import { createNativeConversationCache, NATIVE_CONVERSATION_STORAGE_PREFIX, nativeConversationStorageId, } from './native-conversation.js';
 import { nativeHistoryParams, nativeHistoryQuery, nativeHistoryStorageId, readNativeHistory, storedNativeHistoryMatches, } from './native-history.js';
@@ -10,6 +11,7 @@ import { resourceQuery } from './registry.js';
 import { createRunDetailSync, runDetailTarget } from './run-details.js';
 import { isRunListCollectionRead, RUN_LIST_COLLECTION_ID, RunListCollection, runListSummaryFlags, } from './run-list-versions.js';
 import { createMemoryResourceStore, normalizeResourceStoreScope, readStoredQueryBatch, resourceStoreScopeId, sameResourceAuthority, } from './store.js';
+import { resourceSyncState } from './sync-state.js';
 import { isUpstreamStoredQuery, upstreamRetentionEvictions } from './upstream-retention.js';
 import { workspaceRetentionEvictions, workspaceRetentionMembership, } from './workspace-retention.js';
 const deletionReasons = new Set([
@@ -64,6 +66,11 @@ function profileId(connection) {
         profileId: connection.scope.profileId,
     });
 }
+/**
+ * A view assembled from pushed entities stores its whole snapshot at most this often; each
+ * pushed row is stored at once. It is the floor a full read of the fleet rereads at.
+ */
+const ENTITY_SNAPSHOT_INTERVAL_MS = RESOURCE_REREAD_INTERVAL_MS.slots ?? 10_000;
 export function createGatewayResourceCache(options) {
     const transport = options.transport;
     const metrics = options.performance ?? transport.performance;
@@ -142,9 +149,13 @@ export function createGatewayResourceCache(options) {
     let storageNotice;
     let needsStore = options.store === undefined && options.openStore !== undefined;
     let deletionRequired = false;
+    let recoveryAttempted = false;
+    let failedWriteKey;
     let barrier = Promise.resolve();
+    let storeOpening = Promise.resolve();
     const entries = new Map();
     const revisions = new Map();
+    const syncListeners = new Map();
     const encoder = new TextEncoder();
     const collectors = new ResourceCollectorAdmission(transport);
     let retiringStore = false;
@@ -162,11 +173,44 @@ export function createGatewayResourceCache(options) {
                 writingStore === store &&
                 incarnation === storeVersion &&
                 !writingStore.deleted;
-            return updateStore(writingStore, current, () => writingStore.mergeRows(RUN_LIST_COLLECTION_ID, merge));
+            return updateStore(writingStore, current, () => writingStore.mergeRows(RUN_LIST_COLLECTION_ID, merge), true, RUN_LIST_COLLECTION_ID);
         },
         maxBodyBytes: resourceQuery(Methods.RUN_LIST).maxBytes,
     });
     let runListLoad;
+    // Entity sync (ADR-071 Amendment 4): fleet.status and each pr.list scope are answered from
+    // entity collections when the gateway advertises entitySync. Rows outlive a connection; their
+    // listing is verified by a versions read on every connection before the view is current.
+    const fleetView = createFleetEntityView();
+    const prViews = new Map();
+    const entitySyncOn = () => connection.capabilities?.resourceChanges?.entitySync === true;
+    const entityViews = () => [fleetView, ...prViews.values()];
+    /** The view a query reads through, created on first use; undefined without entity sync. */
+    function entityViewFor(query) {
+        if (!entitySyncOn())
+            return undefined;
+        if (fleetView.serves(query))
+            return fleetView;
+        const scope = prViewProject(query);
+        const collectionKey = query.dependencies.find((key) => key.family === 'upstream');
+        if (!scope || !collectionKey)
+            return undefined;
+        const storeId = prEntityStoreId(scope.project);
+        let view = prViews.get(storeId);
+        if (!view) {
+            view = createPREntityView(scope.project, collectionKey);
+            prViews.set(storeId, view);
+        }
+        return view;
+    }
+    /** Advances when the views are discarded: stored rows read for an earlier one are dropped. */
+    let entityViewGeneration = 0;
+    function forgetEntityViews() {
+        entityViewGeneration++;
+        for (const view of entityViews())
+            view.clear();
+        prViews.clear();
+    }
     const fallbackDetailTargets = new Map();
     const detailSync = createRunDetailSync({
         connection: () => connection,
@@ -210,6 +254,7 @@ export function createGatewayResourceCache(options) {
         hydrationOwnerVersion++;
         version++;
         forgetRunList();
+        forgetEntityViews();
         for (const entry of entries.values())
             invalidate(entry, true);
         transport.resynchronize();
@@ -238,10 +283,29 @@ export function createGatewayResourceCache(options) {
             console.error(`Resource cache observer of ${entry.query.id} failed:`, error);
         }
     }
+    const failedSyncObservers = new WeakSet();
+    function notifySync() {
+        if (!syncListeners.size)
+            return;
+        const observed = [...entries.values()].filter((entry) => entry.listeners.size > 0);
+        for (const [listener, match] of syncListeners) {
+            const state = resourceSyncState(observed.filter((entry) => !match || match(entry.query)).map((entry) => entry.state), usable);
+            try {
+                listener(state);
+            }
+            catch (error) {
+                if (failedSyncObservers.has(listener))
+                    continue;
+                failedSyncObservers.add(listener);
+                console.error('Resource cache sync observer failed:', error);
+            }
+        }
+    }
     function notify(entry) {
         entry.state = { ...entry.state, storageNotice };
         for (const listener of entry.listeners)
             deliver(entry, listener);
+        notifySync();
     }
     function cancelScheduledRead(entry) {
         if (entry.readTimer !== undefined)
@@ -279,12 +343,20 @@ export function createGatewayResourceCache(options) {
             }
         }
     }
-    async function recoverStore(error, failed = store) {
+    // Healthy small queries and admission no-ops cannot confirm that the failed
+    // collection/row can be persisted. Only that same completed write re-arms it.
+    function confirmPersistentWrite(target, key) {
+        if (target === store && target.persistent && key === failedWriteKey) {
+            recoveryAttempted = false;
+            failedWriteKey = undefined;
+        }
+    }
+    async function recoverStore(error, failed = store, writeKey) {
         // A retired store's late I/O failure cannot replace the new principal's store.
         if (failed !== store || disposed)
             return;
+        failedWriteKey = writeKey;
         replaceStore(createMemoryResourceStore());
-        // Retry on the next connection lifecycle, never in an I/O failure loop.
         needsStore = options.openStore !== undefined && canPersist(connection);
         storageNotice = `Cached data will not survive a restart: ${queryError(error).message}`;
         if (metadata)
@@ -297,14 +369,48 @@ export function createGatewayResourceCache(options) {
             storageNotice += `; ${queryError(closeError).message}`;
         }
         options.onStorageNotice?.(storageNotice);
+        // An I/O failure may have lost a collection merge. Keep visible values, but
+        // require a full gateway versions read and never hydrate its old disk rows.
+        forgetRunList();
+        // Entity rows are admitted only at a version the gateway lists, so a lost merge costs reads.
+        forgetEntityViews();
         for (const entry of entries.values())
+            invalidate(entry);
+        if (needsStore &&
+            metadata &&
+            connection.connected &&
+            connection.foreground !== false &&
+            !recoveryAttempted) {
+            recoveryAttempted = true;
+            const ticket = version;
+            const nextMetadata = metadata;
+            await openFreshStore(nextMetadata, connection, false);
+            if (disposed || ticket !== version)
+                return;
+            try {
+                const recoveredStore = store;
+                await withStoreWriteLock(recoveredStore, async () => {
+                    if (disposed || ticket !== version || recoveredStore !== store)
+                        return;
+                    await recoveredStore.setMetadata(nextMetadata);
+                    await recoveredStore.deleteQuery(RUN_LIST_COLLECTION_ID);
+                });
+            }
+            catch (retryError) {
+                await recoverStore(retryError);
+            }
+        }
+        for (const entry of entries.values()) {
             notify(entry);
+            if (usable)
+                schedule(entry);
+        }
     }
     function withStoreWriteLock(target, write) {
         return target.withWriteLock ? target.withWriteLock(write) : write();
     }
     /** Retention, writes and lifecycle changes share one ordered store boundary. */
-    function updateStore(target, current, update, lockWrites = true) {
+    function updateStore(target, current, update, lockWrites = true, writeKey) {
         const updating = barrier.then(async () => {
             if (!current())
                 return;
@@ -320,20 +426,28 @@ export function createGatewayResourceCache(options) {
                     await write();
             }
             catch (error) {
-                await recoverStore(error, target);
+                await recoverStore(error, target, writeKey);
             }
         });
         barrier = updating;
         return updating;
     }
-    async function openFreshStore(next, nextConnection) {
-        const previous = store;
-        const recoveringMemory = metadata !== undefined && !previous.persistent;
-        metadata = next;
-        try {
+    async function openFreshStore(next, nextConnection, hydrate = true) {
+        // Hydration/content failures can recover outside the write barrier. Serialize
+        // every opener with connection-lifecycle opens, without recursively holding it on failure.
+        const opening = storeOpening.then(async () => {
+            if (disposed)
+                return;
+            const previous = store;
+            const recoveringMemory = metadata !== undefined && !previous.persistent;
+            metadata = next;
             const opened = options.openStore && canPersist(nextConnection)
                 ? await options.openStore(next)
                 : createMemoryResourceStore();
+            if (disposed) {
+                await opened.close();
+                return;
+            }
             if (opened !== previous) {
                 if (recoveringMemory && !opened.persistent) {
                     // A failed retry must not discard the active fallback's cached bodies.
@@ -368,15 +482,22 @@ export function createGatewayResourceCache(options) {
                 storageNotice = 'Offline data will not survive a restart with this gateway version.';
                 options.onStorageNotice?.(storageNotice);
             }
+            needsStore =
+                options.openStore !== undefined && !store.persistent && canPersist(nextConnection);
+            // Same-owner recovery must not replace a newer visible reply with older disk data.
+            if (hydrate)
+                for (const entry of entries.values())
+                    if (entry.state.data === undefined && entry.state.status !== 'ready')
+                        hydrateEntry(entry);
+        });
+        // The caller handles failures; a later opener still gets a usable queue.
+        storeOpening = opening.then(() => undefined, () => undefined);
+        try {
+            await opening;
         }
         catch (error) {
             await recoverStore(error);
         }
-        needsStore = options.openStore !== undefined && !store.persistent && canPersist(nextConnection);
-        // Same-owner recovery must not replace a newer visible reply with older disk data.
-        for (const entry of entries.values())
-            if (entry.state.data === undefined && entry.state.status !== 'ready')
-                hydrateEntry(entry);
     }
     async function warmStoredQueries() {
         if (!store.persistent ||
@@ -406,7 +527,7 @@ export function createGatewayResourceCache(options) {
                 if (saved.bytes > remaining)
                     continue;
                 remaining -= saved.bytes;
-                if (saved.id !== RUN_LIST_COLLECTION_ID)
+                if (saved.id !== RUN_LIST_COLLECTION_ID && !isEntityStoreId(saved.id))
                     startupQueries.set(saved.id, saved);
             }
             // Restore small aliased report bodies before exposing their cached run. Network
@@ -476,7 +597,17 @@ export function createGatewayResourceCache(options) {
             return;
         }
         const ticket = ++version;
+        recoveryAttempted = false;
+        failedWriteKey = undefined;
         runList.abort();
+        // A new connection or epoch: rows stay displayed, unverified until a versions read. A gateway
+        // without entity sync replaces the screen with full reads, which a view held from before
+        // would be older than: the next entity sync starts from what is displayed then.
+        if (next.connected && next.capabilities?.resourceChanges?.entitySync !== true)
+            forgetEntityViews();
+        else
+            for (const view of entityViews())
+                view.unverify();
         // Stored facts belong to an owner, not a socket attempt. Fence a revoked
         // owner's pending I/O synchronously, before queued deletion can run.
         if (revoke || scopeChanged || authorityChanged) {
@@ -484,6 +615,7 @@ export function createGatewayResourceCache(options) {
             residentContent.clear();
             hydrationOwnerVersion++;
             forgetRunList();
+            forgetEntityViews();
         }
         connection = next;
         conversations?.connectionChanged(revoke || scopeChanged || authorityChanged);
@@ -529,6 +661,7 @@ export function createGatewayResourceCache(options) {
                 residentContent.clear();
                 storeVersion++;
                 forgetRunList();
+                forgetEntityViews();
                 for (const entry of entries.values())
                     invalidate(entry, true);
                 // Switching profiles retains the old profile's store; revoked authority deletes it.
@@ -587,6 +720,7 @@ export function createGatewayResourceCache(options) {
             if (disposed || ticket !== version)
                 return;
             usable = next.connected && next.foreground !== false && !revoke;
+            notifySync();
             refreshDetailTargets();
             updateCollectors();
             if (usable)
@@ -615,12 +749,16 @@ export function createGatewayResourceCache(options) {
             updateCollectors();
             version++;
             runList.abort();
+            for (const view of entityViews())
+                view.unverify();
             for (const entry of entries.values())
                 invalidate(entry);
             transport.resynchronize();
             return;
         }
         conversations?.resourcesChanged(payload);
+        const entitySync = entitySyncOn();
+        const changedViews = new Set();
         for (const change of payload.changes) {
             if (!Number.isSafeInteger(change.revision) || change.revision < 0) {
                 usable = false;
@@ -634,13 +772,22 @@ export function createGatewayResourceCache(options) {
             if (change.revision <= (revisions.get(id) ?? -1))
                 continue;
             revisions.set(id, change.revision);
-            const affected = [...entries.values()].filter((entry) => entry.dependencyIds.has(id));
+            if (entitySync)
+                for (const view of entityViews())
+                    if (view.applyChange(change))
+                        changedViews.add(view);
+            // An entity view applied its own collection's change above. Any other dependency changes
+            // what the gateway would serve without a push: the view is stale until it reads again.
+            const affected = [...entries.values()].filter((entry) => entry.dependencyIds.has(id) &&
+                !(entitySync && entityViewFor(entry.query)?.collectionKeyId === id));
             // Coverage counts declared dependencies only, so a known key that no entry declares (another
             // slot, an unopened workspace) changes nothing held. Only a family this client cannot name might.
             if (!affected.length && isKnownResourceFamily(change.key?.family))
                 continue;
             const targets = affected.length ? affected : [...entries.values()];
             for (const entry of targets) {
+                if (entitySync)
+                    entityViewFor(entry.query)?.requireVersions();
                 if (!affected.length)
                     entry.unknownGeneration++;
                 const floor = entry.query.rereadIntervalMs?.[change.key.family] ??
@@ -653,6 +800,31 @@ export function createGatewayResourceCache(options) {
                     schedule(entry);
             }
         }
+        for (const view of changedViews)
+            refreshEntityView(view);
+    }
+    /** A notification changed an entity view: reassemble it now; a read follows only if needed. */
+    function refreshEntityView(view) {
+        for (const entry of entries.values()) {
+            if (!view.serves(entry.query))
+                continue;
+            entry.dirty = true;
+            if (!entry.listeners.size) {
+                // Nobody observes it now: it is stale until someone does, and reassembled then.
+                if (entry.state.status === 'ready')
+                    entry.state = { ...entry.state, status: 'stale' };
+                continue;
+            }
+            if (entry.queued)
+                continue;
+            entry.queued = true;
+            queueMicrotask(() => {
+                entry.queued = false;
+                // Pushed changes are not paced: assembling them costs no read.
+                if (entry.listeners.size && usable && !disposed)
+                    void fetchEntry(entry, false);
+            });
+        }
     }
     const conversationDenials = new Map();
     conversations = createNativeConversationCache(transport.conversations, {
@@ -849,6 +1021,132 @@ export function createGatewayResourceCache(options) {
             }
         })();
     }
+    /** The stamp of an entity view: the revisions this client has applied on this connection. */
+    function appliedRevisionStamp(entry) {
+        const epoch = connection.capabilities?.resourceChanges?.epoch;
+        // Sound only for a verified collection: its versions reply came after every notification
+        // published before it, and every notification since was applied to the collection.
+        return epoch
+            ? {
+                epoch,
+                dependencies: entry.query.dependencies.map((key) => ({
+                    key,
+                    revision: revisions.get(resourceKeyId(key)) ?? 0,
+                })),
+            }
+            : undefined;
+    }
+    /** Rows a previous session stored, loaded once per store before the view's first versions read. */
+    async function hydrateEntityView(view) {
+        const readingStore = store;
+        if (view.hydratedFrom === readingStore || !readingStore.getRows)
+            return;
+        view.hydratedFrom = readingStore;
+        const incarnation = storeVersion;
+        const owner = hydrationOwnerVersion;
+        const generation = entityViewGeneration;
+        let stored;
+        try {
+            stored = await readingStore.getRows(view.storeId);
+        }
+        catch (error) {
+            // A failed store read falls back to memory, as every other store read does.
+            await recoverStore(error, readingStore);
+            return;
+        }
+        if (disposed ||
+            store !== readingStore ||
+            readingStore.deleted ||
+            incarnation !== storeVersion ||
+            owner !== hydrationOwnerVersion ||
+            // The view was discarded meanwhile (a gateway without entity sync): these rows are older
+            // than the full read that replaced the screen.
+            generation !== entityViewGeneration)
+            return;
+        view.hydrate(stored);
+    }
+    /** Writes the rows a view changed since its last write, fenced to the current store. */
+    function persistEntityView(view) {
+        const writingStore = store;
+        const incarnation = storeVersion;
+        const changes = view.takeUnstored();
+        const mergeRows = writingStore.mergeRows?.bind(writingStore);
+        if (!mergeRows || !canPersist(connection) || changes.data === undefined)
+            return;
+        if (!changes.metaChanged && !changes.upserts.length && !changes.deletes.length)
+            return;
+        const current = () => !disposed && writingStore === store && incarnation === storeVersion && !writingStore.deleted;
+        const now = Date.now();
+        void updateStore(writingStore, current, () => mergeRows(view.storeId, {
+            entry: {
+                id: view.storeId,
+                data: changes.data,
+                observedAt: now,
+                accessedAt: now,
+                bytes: changes.bytes,
+            },
+            upserts: changes.upserts.map(({ id, version, body, bytes }) => ({
+                id,
+                version,
+                projection: {},
+                body,
+                bytes,
+            })),
+            deletes: changes.deletes,
+        }));
+    }
+    /** An entity view after one sync: pages publish their rows as they land. */
+    async function readEntityView(entry, view, signal) {
+        // What a full read put on screen is the newest this client holds: it seeds an empty view,
+        // and the listing alone says which rows have gone. Stored rows fill a view nothing seeded.
+        view.seed(entry.state.data);
+        if (!view.held)
+            await hydrateEntityView(view);
+        // The read was cancelled while the store answered (a new connection): it sends nothing.
+        if (signal.aborted)
+            throw Object.assign(new Error('Entity view read superseded'), {
+                code: 'RESOURCE_READ_SUPERSEDED',
+            });
+        let requested = false;
+        const publishPage = (done, total) => {
+            const partial = view.answer();
+            entry.state = {
+                ...entry.state,
+                ...(partial ? { data: partial.data } : {}),
+                catchUpProgress: { done, total },
+            };
+            notify(entry);
+        };
+        try {
+            await view.sync(async (params, readSignal) => {
+                requested = true;
+                return (await request(entry.query.method, params, readSignal)).data;
+            }, publishPage);
+        }
+        catch (error) {
+            if (evictionCodes.has(queryError(error).code)) {
+                const evictingStore = store;
+                view.clear();
+                void updateStore(evictingStore, () => evictingStore === store && !evictingStore.deleted, () => evictingStore.deleteQuery(view.storeId), false);
+            }
+            throw error;
+        }
+        finally {
+            if (entry.state.catchUpProgress !== undefined)
+                entry.state = { ...entry.state, catchUpProgress: undefined };
+        }
+        persistEntityView(view);
+        const answer = view.answer();
+        if (!answer)
+            return request(entry.query.method, entry.query.params, signal);
+        return {
+            data: answer.data,
+            resourceState: appliedRevisionStamp(entry),
+            ...(answer.current ? {} : { incomplete: true }),
+            ...(requested ? {} : { assembled: true }),
+            observedAt: Date.now(),
+        };
+    }
     function isRunListView(query) {
         return query.method === Methods.RUN_LIST && !isRunListCollectionRead(query.params);
     }
@@ -887,8 +1185,17 @@ export function createGatewayResourceCache(options) {
         const flags = runListFlags();
         try {
             // A new view of a current collection needs no read: no runs change since its version reply.
-            if (!runList.complete || !runList.serves(flags) || !stampCovers(entry, runList.resourceState))
+            if (!runList.complete ||
+                !runList.serves(flags) ||
+                !stampCovers(entry, runList.resourceState)) {
+                const refreshingStore = store;
+                const incarnation = storeVersion;
                 await runList.refresh(flags);
+                // Earlier pages cannot prove that the failed later page can be stored.
+                // Confirm only a complete refresh that never switched its store.
+                if (store === refreshingStore && storeVersion === incarnation && runList.complete)
+                    confirmPersistentWrite(refreshingStore, RUN_LIST_COLLECTION_ID);
+            }
         }
         catch (error) {
             // A refused collection read evicts the stored collection, like every refused read.
@@ -1033,11 +1340,14 @@ export function createGatewayResourceCache(options) {
                 entry.lastRequestedAt = performance.now();
                 const fromRunList = isRunListView(entry.query) &&
                     connection.capabilities?.resourceChanges?.versionLists === true;
-                const reply = fromRunList
-                    ? await readRunListView(entry, pending.controller.signal)
-                    : entry.query.method === Methods.NATIVE_SESSION_READ
-                        ? await readNativeHistory(entry.query.params, entry.state.data, (params, signal) => request(Methods.NATIVE_SESSION_READ, params, signal), pending.controller.signal)
-                        : await request(entry.query.method, entry.query.params, pending.controller.signal);
+                const entityView = entityViewFor(entry.query);
+                const reply = entityView
+                    ? await readEntityView(entry, entityView, pending.controller.signal)
+                    : fromRunList
+                        ? await readRunListView(entry, pending.controller.signal)
+                        : entry.query.method === Methods.NATIVE_SESSION_READ
+                            ? await readNativeHistory(entry.query.params, entry.state.data, (params, signal) => request(Methods.NATIVE_SESSION_READ, params, signal), pending.controller.signal)
+                            : await request(entry.query.method, entry.query.params, pending.controller.signal);
                 if (disposed ||
                     store.deleted ||
                     pending.version !== version ||
@@ -1094,7 +1404,16 @@ export function createGatewayResourceCache(options) {
                 entry.retryAt = undefined;
                 entry.lastUsed = ++lastUsed;
                 // Version-list views are derived from the run collection, which is stored on its own.
-                const persistResult = entry.query.persisted && canPersist(connection) && reply.incomplete === undefined;
+                // A view assembled from pushed entities already stored the rows that changed; its whole
+                // snapshot follows no more often than a full read would have been reread.
+                const paced = reply.assembled === true &&
+                    Date.now() - (entry.snapshotStoredAt ?? 0) < ENTITY_SNAPSHOT_INTERVAL_MS;
+                const persistResult = entry.query.persisted &&
+                    canPersist(connection) &&
+                    reply.incomplete === undefined &&
+                    !paced;
+                if (persistResult)
+                    entry.snapshotStoredAt = Date.now();
                 const serialized = persistResult
                     ? JSON.stringify(entry.query.persistedData ? entry.query.persistedData(reply.data) : reply.data)
                     : undefined;
@@ -1172,6 +1491,8 @@ export function createGatewayResourceCache(options) {
                                 .filter((value) => value.id !== saved.id &&
                                 // The run collection is bounded by its own body budget, never by its views.
                                 value.id !== RUN_LIST_COLLECTION_ID &&
+                                // Entity rows are bounded by their collection, never by its views.
+                                !isEntityStoreId(value.id) &&
                                 (retention.cohort === 'upstream'
                                     ? isUpstreamStoredQuery(value.id)
                                     : value.id.startsWith(`${entry.query.method}:`)))
@@ -1195,16 +1516,28 @@ export function createGatewayResourceCache(options) {
                         }
                         if (current()) {
                             await writingStore.putQuery(row);
+                            if (current())
+                                confirmPersistentWrite(writingStore, row.id);
                             if (entry.query.method === Methods.CHAT_ARCHIVE && current())
                                 await writingStore.deleteQuery(`chat.history:${canonicalResourceJson(entry.query.params)}`);
                         }
-                    });
+                    }, true, nativeHistoryStorageId(entry.query));
                 }
                 if (store.persistent && entry.query.method === Methods.RUN_LIST) {
                     const listed = reply.data;
                     if (Array.isArray(listed.runs)) {
-                        for (const run of listed.runs)
+                        for (const run of listed.runs) {
+                            // A slim row (it carries the gateway's evidenceSummary) hashes to no version the
+                            // gateway serves: its version comes only from the version list, and until that is
+                            // held its detail is not treated as changed. An older gateway's trimmed full row is
+                            // the version basis itself, so it keeps the derived version. Trim markers cannot
+                            // tell the two apart: trimRunForList rows carry payloadTrimmed too.
+                            if (run.evidenceSummary !== undefined) {
+                                fallbackDetailTargets.delete(run.id);
+                                continue;
+                            }
                             fallbackDetailTargets.set(run.id, runDetailTarget(run, runListVersion(run)));
+                        }
                     }
                     refreshDetailTargets();
                 }
@@ -1528,12 +1861,14 @@ export function createGatewayResourceCache(options) {
                 });
             }
             deliver(entry, receive);
+            notifySync();
             if (entry.state.status !== 'ready' || entry.dirty)
                 schedule(entry);
             return () => {
                 active = false;
                 cancelPaint?.();
                 entry.listeners.delete(receive);
+                notifySync();
                 updateCollectors();
                 if (!entry.listeners.size) {
                     cancelScheduledRead(entry);
@@ -1544,6 +1879,13 @@ export function createGatewayResourceCache(options) {
                 prune();
             };
         },
+        observeSync(listener, match) {
+            syncListeners.set(listener, match);
+            notifySync();
+            return () => {
+                syncListeners.delete(listener);
+            };
+        },
         read(query) {
             if (disposed)
                 throw new Error('Resource cache is disposed');
@@ -1614,9 +1956,11 @@ export function createGatewayResourceCache(options) {
                 entry.listeners.clear();
             }
             entries.clear();
+            syncListeners.clear();
             await flushingConversations;
             conversationFlush = false;
             await barrier;
+            await storeOpening;
             try {
                 if (reason && deletionReasons.has(reason))
                     await store.deleteAll();