@openclaw/codex 2026.10.5-beta.4 → 2026.10.10-beta.2

package/dist/.setup/{session-catalog-index-CrnfVEnT.mjs → session-catalog-index-qt4UWBua.mjs}

@@ -1,12 +1,12 @@
-import { S as readControlCursor, _ as normalizeLimit, c as MAX_CWD_LENGTH, d as boundedCatalogString, h as filterCatalogPageByTitle, m as codexCatalogThreadStatus, o as CatalogParamsError, p as codexCatalogThreadName } from "./session-catalog-parsing-DkeoVn60.mjs";
-import { n as detachCodexCatalogString, t as CODEX_CATALOG_MAX_ROWS } from "./session-catalog-limits-BynIoOYm.mjs";
-import { i as retainCodexCatalogRow, n as codexCatalogRowRecency, r as compareCodexCatalogRows, t as CodexCatalogOrdering } from "./session-catalog-index-order-CTfoefow.mjs";
-import { c as CodexCatalogPersistence, i as CodexCatalogAvailability, l as codexCatalogMetadataPage, r as withCodexCatalogListRequest } from "./session-catalog-list-request-D4MYNgDB.mjs";
-import { a as hasLiveCodexCatalogSource, c as setCodexCatalogSource, i as getCodexCatalogSource } from "./session-catalog-source-DGuRdGvM.mjs";
-import { r as projectCodexCatalogNativeThread } from "./session-catalog-native-projection-CWqCU1I_.mjs";
-import { i as subscribeCodexCatalogEvents } from "./session-catalog-events-kR2Ot6nX.mjs";
+import { S as readControlCursor, _ as normalizeLimit, c as MAX_CWD_LENGTH, d as boundedCatalogString, h as filterCatalogPageByTitle, m as codexCatalogThreadStatus, o as CatalogParamsError, p as codexCatalogThreadName } from "./session-catalog-parsing-V6jyFg9g.mjs";
+import { n as detachCodexCatalogString, t as CODEX_CATALOG_MAX_ROWS } from "./session-catalog-limits-Dc6E0BZz.mjs";
+import { i as retainCodexCatalogRow, n as codexCatalogRowRecency, r as compareCodexCatalogRows, t as CodexCatalogOrdering } from "./session-catalog-index-order-0Zqng2u8.mjs";
+import { c as CodexCatalogPersistence, i as CodexCatalogAvailability, l as codexCatalogMetadataPage, r as withCodexCatalogListRequest } from "./session-catalog-list-request-CAjoWjaH.mjs";
+import { i as getCodexCatalogSource, s as setCodexCatalogSource } from "./session-catalog-source-z_mNyQdX.mjs";
+import { r as projectCodexCatalogNativeThread } from "./session-catalog-native-projection-BqBYi6kV.mjs";
+import { i as subscribeCodexCatalogEvents } from "./session-catalog-events-CEi6SuLQ.mjs";
 import { a as reportCodexCatalogSpawnFailure, n as findCodexAppServerSpawnError } from "./spawn-error-CL3n6MAa.mjs";
-import { CodexCatalogProjectionCapacityError, CodexCatalogProjections, mergeCodexCatalogRolloutRow, n as readCodexCatalogRollout, projectCodexCatalogPage, r as resolveCodexCatalogRolloutFingerprint, t as codexCatalogRolloutLogicalPath } from "./session-catalog-projection-BzHiV818.mjs";
+import { CodexCatalogProjectionCapacityError, CodexCatalogProjections, mergeCodexCatalogRolloutRow, n as readCodexCatalogRollout, projectCodexCatalogPage, r as resolveCodexCatalogRolloutFingerprint, t as codexCatalogRolloutLogicalPath } from "./session-catalog-projection-CNyhjZze.mjs";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createHash } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
@@ -108,15 +108,14 @@ var CodexCatalogCurrency = class {
 			this.initial.unref();
 		}
 	}
-	close() {
+	async close() {
 		this.closed = true;
 		this.cancelHydration();
 		clearInterval(this.timer);
 		this.timer = void 0;
 		clearTimeout(this.initial);
 		this.initial = void 0;
-		if (this.running && this.safetyRefresh) return Promise.allSettled([this.running, this.safetyRefresh]).then(() => {});
-		return this.running ?? this.safetyRefresh;
+		await Promise.allSettled([this.running, this.safetyRefresh]);
 	}
 };
 //#endregion
@@ -185,7 +184,7 @@ function encodeCodexNativeCursor(cursor) {
 }
 //#endregion
 //#region extensions/codex/src/session-catalog-index-events.ts
-/** Event scheduling only; the index owns row publication and stale-read fencing. */
+/** Coalesces metadata refreshes while the index owns row publication. */
 var CodexCatalogIndexEvents = class {
 	constructor(owner) {
 		this.owner = owner;
@@ -239,7 +238,7 @@ var CodexCatalogIndexEvents = class {
 		}
 		if (event.method === "turn/started" || event.method === "turn/completed" || event.method === "thread/unarchived" || event.method === "thread/reverted") {
 			if (event.method !== "thread/unarchived" && this.owner.get(id)?.archived) return;
-			this.enqueueRefresh(id, readThread, source, event.method === "turn/started" ? this.owner.reserveTurnStartOrder() : void 0);
+			this.enqueueRefresh(id, readThread, event.method === "turn/started" ? this.owner.reserveTurnStartOrder() : void 0);
 		}
 	}
 	hasCapacity() {
@@ -247,12 +246,11 @@ var CodexCatalogIndexEvents = class {
 		this.owner.report(/* @__PURE__ */ new Error("Codex catalog event queue reached its resident row limit"));
 		return false;
 	}
-	enqueueRefresh(id, readThread, source, sourceOrder) {
+	enqueueRefresh(id, readThread, sourceOrder) {
 		this.owner.requestNativeRefresh();
 		const existing = this.pending.get(id);
 		if (existing) {
 			existing.readThread = readThread;
-			existing.source = source;
 			existing.dirty = true;
 			existing.sourceOrder = sourceOrder ?? existing.sourceOrder;
 			return;
@@ -260,7 +258,6 @@ var CodexCatalogIndexEvents = class {
 		if (!this.hasCapacity()) return;
 		const pending = {
 			readThread,
-			source,
 			dirty: true,
 			sourceOrder,
 			promise: Promise.resolve()
@@ -271,17 +268,11 @@ var CodexCatalogIndexEvents = class {
 				while (!this.closed && pending.dirty) {
 					pending.dirty = false;
 					const observedSourceOrder = pending.sourceOrder;
-					const observedSource = pending.source;
 					try {
-						if (observedSource.closed) throw new Error("Codex catalog observation source closed before its metadata read");
-						const published = await this.owner.refresh(id, pending.readThread, observedSourceOrder);
-						if (published && pending.sourceOrder === observedSourceOrder) pending.sourceOrder = void 0;
-						else if (!published && pending.sourceOrder !== void 0) pending.dirty = true;
+						await this.owner.refresh(id, pending.readThread, observedSourceOrder);
+						if (pending.sourceOrder === observedSourceOrder) pending.sourceOrder = void 0;
 					} catch (error) {
-						if (observedSource.closed) {
-							if (pending.source === observedSource) pending.dirty = false;
-							this.owner.report(new Error("Codex catalog observation interrupted by client closure; metadata refresh deferred to the current catalog owner", { cause: error }), "deferred");
-						} else this.owner.report(error);
+						this.owner.report(error);
 					}
 				}
 			} finally {
@@ -296,45 +287,28 @@ var CodexCatalogIndexEvents = class {
 };
 //#endregion
 //#region extensions/codex/src/session-catalog-index-field.ts
-/** Orders field observations independently from catalog row publication. */
+/** Bounded display observations; later publications replace earlier ones. */
 var CodexCatalogField = class {
 	constructor() {
-		this.revision = 0;
-		this.minimumCapture = 0;
 		this.entries = /* @__PURE__ */ new Map();
 	}
-	capture() {
-		return ++this.revision;
-	}
 	update(threadId, value) {
-		this.put(threadId, {
-			revision: ++this.revision,
-			value
-		});
-	}
-	observe(threadId, value, capturedRevision) {
-		if (capturedRevision < this.minimumCapture || (this.entries.get(threadId)?.revision ?? 0) > capturedRevision) return false;
-		this.put(threadId, {
-			revision: capturedRevision,
-			value
-		});
-		return true;
+		this.put(threadId, value);
 	}
 	get(threadId) {
-		return this.entries.get(threadId)?.value;
+		return this.entries.get(threadId);
 	}
 	some(predicate) {
-		for (const entry of this.entries.values()) if (entry.value !== void 0 && predicate(entry.value)) return true;
+		for (const entry of this.entries.values()) if (predicate(entry)) return true;
 		return false;
 	}
 	delete(threadId) {
-		this.put(threadId, { revision: ++this.revision });
+		this.entries.delete(threadId);
 	}
 	deleteWhere(predicate) {
-		for (const [threadId, entry] of this.entries) if (entry.value !== void 0 && predicate(entry.value)) this.delete(threadId);
+		for (const [threadId, entry] of this.entries) if (predicate(entry)) this.delete(threadId);
 	}
 	invalidate() {
-		this.minimumCapture = ++this.revision;
 		this.entries.clear();
 	}
 	put(threadId, entry) {
@@ -342,26 +316,17 @@ var CodexCatalogField = class {
 		if (!id) return;
 		this.entries.delete(id);
 		this.entries.set(id, entry);
-		if (this.entries.size > 2e4) {
-			const oldest = this.entries.entries().next().value;
-			if (oldest) {
-				this.minimumCapture = Math.max(this.minimumCapture, oldest[1].revision);
-				this.entries.delete(oldest[0]);
-			}
-		}
+		if (this.entries.size > 2e4) this.entries.delete(this.entries.keys().next().value);
 	}
 };
-/** Live field values share revision fencing and source-lifetime invalidation. */
+/** Live field values retain source-lifetime invalidation. */
 var CodexCatalogLiveField = class {
 	constructor() {
 		this.values = new CodexCatalogField();
 	}
-	capture() {
-		return this.values.capture();
-	}
 	get(threadId) {
 		const current = this.values.get(threadId);
-		return current && hasLiveCodexCatalogSource(current.sources) ? current.value : void 0;
+		return current && !current.source.closed ? current.value : void 0;
 	}
 	delete(threadId) {
 		this.values.delete(threadId);
@@ -371,10 +336,7 @@ var CodexCatalogLiveField = class {
 			this.values.invalidate();
 			return;
 		}
-		this.values.deleteWhere((entry) => {
-			entry.sources.delete(source);
-			return !hasLiveCodexCatalogSource(entry.sources);
-		});
+		this.values.deleteWhere((entry) => entry.source === source);
 	}
 };
 //#endregion
@@ -463,7 +425,12 @@ var CodexCatalogRolloutScanner = class {
 		const running = (async () => {
 			await previous?.catch(() => void 0);
 			await setImmediate$1();
-			return this.walk(trackedPaths);
+			try {
+				return await this.walk(trackedPaths);
+			} catch (error) {
+				for (const cached of this.directories.values()) cached.dirty = true;
+				throw error;
+			}
 		})();
 		this.running = running;
 		return running.finally(() => {
@@ -485,12 +452,12 @@ var CodexCatalogRolloutScanner = class {
 			const cached = {
 				watcher,
 				stat,
-				revision: 0,
+				dirty: true,
 				armAt: process.platform === "darwin" ? performance.now() + DARWIN_WATCH_ARM_MS : 0,
 				files: /* @__PURE__ */ new Map()
 			};
 			watcher.on("change", () => {
-				cached.revision++;
+				cached.dirty = true;
 			});
 			const withdraw = () => {
 				if (this.directories.get(directory) === cached) this.forget(directory);
@@ -503,13 +470,11 @@ var CodexCatalogRolloutScanner = class {
 			return;
 		}
 	}
-	async walk(trackedPaths, reuseCache = true) {
+	async walk(trackedPaths) {
 		if (this.closed) throw new Error("Codex catalog rollout scanner is closed");
 		const present = /* @__PURE__ */ new Set();
 		const unvisited = new Set(this.directories.keys());
 		const candidates = new NewestRolloutCandidates();
-		const reused = /* @__PURE__ */ new Map();
-		let cacheWithdrawn = false;
 		let processed = 0;
 		const offer = (file, fingerprint) => {
 			if (trackedPaths.has(codexCatalogRolloutLogicalPath(file))) present.add(codexCatalogRolloutLogicalPath(file));
@@ -528,29 +493,16 @@ var CodexCatalogRolloutScanner = class {
 					this.forget(directory);
 					cached = void 0;
 				}
-				if (reuseCache && cached && cached.scannedRevision === cached.revision) {
-					const revision = cached.revision;
-					reused.set(directory, {
-						cached,
-						revision
-					});
+				if (cached && !cached.dirty) {
 					for (const [file, fingerprint] of cached.files) {
 						offer(file, fingerprint);
-						if (++processed % SCAN_BATCH_SIZE === 0) {
-							await setImmediate$1();
-							if (this.directories.get(directory) !== cached || cached.revision !== revision) {
-								cacheWithdrawn = true;
-								return;
-							}
-						}
+						if (++processed % SCAN_BATCH_SIZE === 0) await setImmediate$1();
 					}
 					return;
 				}
 				cached ??= this.watch(directory, stat);
 			}
-			if (cached) cached.scannedRevision = void 0;
-			const revision = cached?.revision;
-			const armed = cached && performance.now() >= cached.armAt;
+			if (cached) cached.dirty = performance.now() < cached.armAt;
 			const retained = cached ? /* @__PURE__ */ new Map() : void 0;
 			let cacheable = true;
 			const entries = await unlessMissing(fs$1.opendir(directory));
@@ -559,7 +511,6 @@ var CodexCatalogRolloutScanner = class {
 				return;
 			}
 			for await (const entry of entries) {
-				if (cacheWithdrawn) return;
 				if (this.closed) throw new Error("Codex catalog rollout scanner is closed");
 				if (++processed % SCAN_BATCH_SIZE === 0) await setImmediate$1();
 				const file = path.join(directory, entry.name);
@@ -590,12 +541,10 @@ var CodexCatalogRolloutScanner = class {
 				}
 			}
 			if (cached && retained && stat) {
-				const current = await unlessMissing(fs$1.lstat(directory));
-				if (cacheable && !this.closed && this.directories.get(directory) === cached && current?.isDirectory() && sameDirectory(stat, current)) {
+				if (cacheable && !this.closed && this.directories.get(directory) === cached) {
 					this.cachedFiles += retained.size - cached.files.size;
 					cached.files = retained;
 					cached.stat = stat;
-					cached.scannedRevision = armed && cached.revision === revision ? revision : void 0;
 				} else this.forget(directory);
 			}
 		};
@@ -604,7 +553,6 @@ var CodexCatalogRolloutScanner = class {
 			const rootReal = await unlessMissing(fs$1.realpath(this.sessionsRoot));
 			if (rootReal) await scan(rootReal, 0, rootReal);
 		}
-		if (cacheWithdrawn || [...reused].some(([directory, { cached, revision }]) => this.directories.get(directory) !== cached || cached.revision !== revision)) return this.walk(trackedPaths, false);
 		for (const directory of unvisited) this.forget(directory);
 		return {
 			files: candidates.finish(),
@@ -619,7 +567,7 @@ var CodexCatalogRolloutScanner = class {
 //#endregion
 //#region extensions/codex/src/session-catalog-index-files.ts
 /** Plan file reconciliation; the index retains every publication and lifetime decision. */
-async function reconcileCodexCatalogFiles(root, isCurrent, owner) {
+async function reconcileCodexCatalogFiles(root, owner) {
 	const byPath = /* @__PURE__ */ new Map();
 	let processed = 0;
 	for (const row of owner.rows.values()) {
@@ -656,7 +604,6 @@ async function reconcileCodexCatalogFiles(root, isCurrent, owner) {
 			observed.set(file, fingerprint);
 			continue;
 		}
-		if (!isCurrent(thread.id)) continue;
 		const existing = owner.rows.get(thread.id);
 		if (existing?.rolloutPath && codexCatalogRolloutLogicalPath(existing.rolloutPath) !== codexCatalogRolloutLogicalPath(file)) {
 			observed.set(file, fingerprint);
@@ -672,11 +619,9 @@ async function reconcileCodexCatalogFiles(root, isCurrent, owner) {
 			sanitize: sanitizeTerminalText
 		});
 		owner.assertCurrent();
-		if (!isCurrent(thread.id)) continue;
 		observed.set(file, fingerprint);
 		const row = projected.rows[0];
 		if (!row) continue;
-		owner.mark(row.threadId);
 		owner.put(mergeCodexCatalogRolloutRow(row, existing, fingerprint));
 		await setImmediate$1();
 	}
@@ -706,49 +651,6 @@ function applyCodexCatalogName(row, name) {
 	};
 }
 //#endregion
-//#region extensions/codex/src/session-catalog-index-observations.ts
-/** Fences asynchronous observations against later catalog mutations. */
-var CodexCatalogObservations = class {
-	constructor() {
-		this.revision = 0;
-		this.minimumCapture = 0;
-		this.mutations = /* @__PURE__ */ new Map();
-		this.observations = /* @__PURE__ */ new Map();
-	}
-	hasActiveWork() {
-		return this.observations.size > 0;
-	}
-	mark(threadId) {
-		this.revision++;
-		if (this.observations.size) {
-			const id = boundedCatalogString(threadId, 256);
-			if (!id) return;
-			this.mutations.delete(id);
-			this.mutations.set(id, this.revision);
-			if (this.mutations.size > 2e4) {
-				const oldest = this.mutations.entries().next().value;
-				this.minimumCapture = Math.max(this.minimumCapture, oldest[1]);
-				this.mutations.delete(oldest[0]);
-			}
-		}
-	}
-	async observe(read) {
-		const token = Symbol("catalog observation");
-		const revision = this.revision;
-		this.observations.set(token, revision);
-		try {
-			return await read((id) => revision >= this.minimumCapture && (this.mutations.get(id) ?? 0) <= revision);
-		} finally {
-			this.observations.delete(token);
-			const oldest = this.observations.values().next().value ?? Infinity;
-			for (const [id, changed] of this.mutations) {
-				if (changed > oldest) break;
-				this.mutations.delete(id);
-			}
-		}
-	}
-};
-//#endregion
 //#region extensions/codex/src/session-catalog-status.ts
 function applyCodexCatalogLiveFields({ status: _storedStatus, activeFlags: _storedFlags, ...session }, live, settings) {
 	return {
@@ -758,48 +660,24 @@ function applyCodexCatalogLiveFields({ status: _storedStatus, activeFlags: _stor
 		...live?.activeFlags ? { activeFlags: [...live.activeFlags] } : {}
 	};
 }
-const MAX_STATUS_SOURCE_WITNESSES = 64;
-/** Equivalent broadcasts retain at most 64 source witnesses for each bounded resident row. */
+/** One latest display observation; native actions verify their own current state. */
 var CodexCatalogStatusIndex = class extends CodexCatalogLiveField {
 	update(threadId, status, source) {
-		const next = this.next(threadId, status, source);
-		if (next) this.values.update(threadId, next);
-	}
-	observe(row, revision) {
-		const session = row.page.sessions[0];
-		const source = getCodexCatalogSource(row);
-		if (session && source) {
-			const next = this.next(row.threadId, {
-				status: session.status,
-				...session.activeFlags ? { activeFlags: session.activeFlags } : {}
-			}, source);
-			if (next) this.values.observe(row.threadId, next, revision);
-		}
-	}
-	next(threadId, status, source) {
 		if (source.closed) return;
 		const current = this.values.get(threadId);
-		const sources = new Set([...current?.sources ?? []].filter((witness) => !witness.closed));
-		if (status.status === "notLoaded" && current && current.value.status !== "notLoaded" && sources.size) {
-			sources.delete(source);
-			if (sources.size) return {
-				value: current.value,
-				sources
-			};
-		}
-		const flags = status.activeFlags ?? [];
-		const previousFlags = current?.value.activeFlags ?? [];
-		if (current?.value.status === status.status && flags.length === previousFlags.length && flags.every((flag, index) => flag === previousFlags[index])) {
-			if (sources.size < MAX_STATUS_SOURCE_WITNESSES) sources.add(source);
-			return {
-				value: status,
-				sources
-			};
-		}
-		return {
+		if (status.status === "notLoaded" && current && !current.source.closed && current.source !== source) return;
+		this.values.update(threadId, {
 			value: status,
-			sources: /* @__PURE__ */ new Set([source])
-		};
+			source
+		});
+	}
+	observe(row) {
+		const session = row.page.sessions[0];
+		const source = getCodexCatalogSource(row);
+		if (session && source) this.update(row.threadId, {
+			status: session.status,
+			...session.activeFlags ? { activeFlags: session.activeFlags } : {}
+		}, source);
 	}
 };
 //#endregion
@@ -927,7 +805,6 @@ var CodexCatalogNativePages = class {
 			const filterCwdLocally = Boolean(cwd && this.settings.hasLiveCwd());
 			const ascending = position.backwards && !position.anchorThreadId;
 			const pageLimit = position.anchorThreadId ? 64 : limit;
-			const statusRevision = this.status.capture();
 			const page = await request.read(Number.POSITIVE_INFINITY, () => options.readNative({
 				archived: false,
 				modelProviders: [],
@@ -939,7 +816,7 @@ var CodexCatalogNativePages = class {
 				...position.cursor ? { cursor: position.cursor } : {}
 			}, pageLimit, request));
 			options.assertCurrent();
-			for (const row of page.rows) this.status.observe(row, statusRevision);
+			for (const row of page.rows) this.status.observe(row);
 			if (cwd && !filterCwdLocally && this.settings.hasLiveCwd()) continue;
 			let rows = ascending ? page.rows.toReversed() : page.rows;
 			let next = (ascending ? page.backwardsCursor : page.nextCursor) ? at(ascending ? page.backwardsCursor : page.nextCursor, false) : void 0;
@@ -993,7 +870,6 @@ var CodexCatalogNativePages = class {
 };
 //#endregion
 //#region extensions/codex/src/session-catalog-settings.ts
-const MAX_SETTINGS_SOURCE_WITNESSES = 64;
 /** Live settings overlay native stored metadata only while a supporting source stays open. */
 var CodexCatalogSettingsIndex = class extends CodexCatalogLiveField {
 	update(threadId, settings, source) {
@@ -1005,24 +881,16 @@ var CodexCatalogSettingsIndex = class extends CodexCatalogLiveField {
 			...cwd ? { cwd } : {},
 			...modelProvider ? { modelProvider } : {}
 		};
-		const current = this.values.get(threadId);
-		const sources = /* @__PURE__ */ new Set();
-		if (current && current.value.cwd === bounded.cwd && current.value.modelProvider === bounded.modelProvider) {
-			for (const witness of current.sources) if (!witness.closed) sources.add(witness);
-		}
-		if (sources.size < MAX_SETTINGS_SOURCE_WITNESSES) sources.add(source);
 		this.values.update(threadId, {
 			value: bounded,
-			sources
+			source
 		});
 	}
 	hasLiveCwd() {
-		return this.values.some(({ value, sources }) => Boolean(value.cwd) && hasLiveCodexCatalogSource(sources));
+		return this.values.some(({ value, source }) => Boolean(value.cwd) && !source.closed);
 	}
 	withdraw(threadId, source) {
-		const current = this.values.get(threadId);
-		if (!current?.sources.delete(source)) return;
-		if (!hasLiveCodexCatalogSource(current.sources)) this.values.delete(threadId);
+		if (this.values.get(threadId)?.source === source) this.values.delete(threadId);
 	}
 };
 //#endregion
@@ -1045,9 +913,7 @@ var CodexCatalogIndex = class {
 		this.projections = new CodexCatalogProjections();
 		this.observedFiles = /* @__PURE__ */ new Map();
 		this.obsoleteStoredKeys = /* @__PURE__ */ new Set();
-		this.sourceRevision = 0;
 		this.ordering = new CodexCatalogOrdering();
-		this.observations = new CodexCatalogObservations();
 		this.rolloutScanner = options.localSessionsRoot ? new CodexCatalogRolloutScanner(options.localSessionsRoot) : void 0;
 		this.currency = new CodexCatalogCurrency({
 			local: Boolean(options.localSessionsRoot),
@@ -1079,7 +945,7 @@ var CodexCatalogIndex = class {
 				this.currency.requestNativeRefresh();
 				this.remove(id);
 			},
-			report: (error, disposition) => this.report(error, disposition)
+			report: (error) => this.report(error)
 		});
 		this.unsubscribe = subscribeCodexCatalogEvents(options.homeId, (event, readThread, source) => this.events.handle(event, readThread, source), {
 			onEphemeralThread: (id) => this.remove(id),
@@ -1093,7 +959,6 @@ var CodexCatalogIndex = class {
 			},
 			onRemoteReady: () => {
 				if (this.closed || options.localSessionsRoot) return;
-				this.sourceRevision++;
 				if (!this.initializing) {
 					this.initialized = false;
 					this.scheduleHydration();
@@ -1110,8 +975,8 @@ var CodexCatalogIndex = class {
 			throw error;
 		}
 	}
-	report(error, disposition) {
-		if (!this.closed && !this.currency.stopForTerminalFailure(error)) embeddedAgentLog.warn(disposition === "deferred" ? "Codex resident catalog metadata refresh interrupted; deferred for automatic recovery" : "Codex resident catalog background update failed", { error });
+	report(error) {
+		if (!this.closed && !this.currency.stopForTerminalFailure(error)) embeddedAgentLog.warn("Codex resident catalog background update failed", { error });
 	}
 	withName(row) {
 		const known = this.names.get(row.threadId);
@@ -1145,7 +1010,6 @@ var CodexCatalogIndex = class {
 		this.persistence.remove(threadId);
 	}
 	remove(threadId) {
-		this.observations.mark(threadId);
 		this.evict(threadId);
 		this.liveStatus.delete(threadId);
 		this.liveSettings.delete(threadId);
@@ -1158,40 +1022,32 @@ var CodexCatalogIndex = class {
 		if (this.initialized && !this.needsNativeRefresh) return;
 		if (!this.initializing) {
 			this.availability.begin();
-			const sourceRevision = this.sourceRevision;
 			this.initializing = (async () => {
 				await this.restore();
 				await this.persistence.pruneObsolete(this.obsoleteStoredKeys, this.rows.values());
 				this.obsoleteStoredKeys.clear();
 				await this.reconcilingNative?.catch((error) => this.report(error));
-				if (!this.initialized) {
-					let observedRevision;
-					do
-						observedRevision = await this.hydrate(this.availability.complete);
-					while (observedRevision !== this.sourceRevision);
-				} else if (this.needsNativeRefresh) {
+				if (!this.initialized) await this.hydrate(this.availability.complete);
+				else if (this.needsNativeRefresh) {
 					await this.reconcile();
 					await this.reconcileNative();
 				}
 				this.needsNativeRefresh = false;
 				this.initialized = true;
-				this.failure = void 0;
 				this.currency.start();
 			})().catch((error) => {
-				this.failure = { error };
 				this.availability.fail(error);
 				this.currency.stopForTerminalFailure(error);
 				throw error;
 			}).finally(() => {
 				this.initializing = void 0;
-				if (this.failure && sourceRevision !== this.sourceRevision) this.scheduleHydration();
 			});
 		}
 		return this.initializing;
 	}
 	async restore() {
 		if (this.restored) return;
-		this.restoring ??= this.observations.observe(async (isCurrent) => {
+		this.restoring ??= (async () => {
 			try {
 				const snapshot = await this.persistence.readSnapshot();
 				this.assertCurrent();
@@ -1203,19 +1059,17 @@ var CodexCatalogIndex = class {
 						await setImmediate$1();
 						this.assertCurrent();
 					}
-					if (isCurrent(row.threadId)) {
-						const restored = row.rolloutPath ? {
-							...row,
-							rolloutPath: codexCatalogRolloutLogicalPath(row.rolloutPath)
-						} : row;
-						const patched = this.withName(restored);
-						if (patched !== restored) this.persistence.put(patched);
-						const previous = this.rows.get(patched.threadId);
-						const evicted = retainCodexCatalogRow(this.rows, patched);
-						if (evicted) this.evict(evicted.threadId, evicted);
-						if (evicted !== patched) this.ordering.put(patched, previous);
-						this.ordering.restore(row);
-					}
+					const restored = row.rolloutPath ? {
+						...row,
+						rolloutPath: codexCatalogRolloutLogicalPath(row.rolloutPath)
+					} : row;
+					const patched = this.withName(restored);
+					if (patched !== restored) this.persistence.put(patched);
+					const previous = this.rows.get(patched.threadId);
+					const evicted = retainCodexCatalogRow(this.rows, patched);
+					if (evicted) this.evict(evicted.threadId, evicted);
+					if (evicted !== patched) this.ordering.put(patched, previous);
+					this.ordering.restore(row);
 				}
 				this.overflow ||= snapshot.overflow || this.rows.size >= 2e4;
 				if (snapshot.complete) {
@@ -1228,24 +1082,19 @@ var CodexCatalogIndex = class {
 				this.persistence.invalidate(error);
 			}
 			this.restored = true;
-		});
+		})();
 		await this.restoring;
 	}
 	scheduleHydration() {
 		if (this.initialized && !this.needsNativeRefresh || this.initializing || this.closed) return;
 		this.currency.scheduleHydration(() => this.initialize());
 	}
-	captureFields() {
-		return {
-			status: this.liveStatus.capture(),
-			name: this.names.capture()
-		};
-	}
-	observeFields(row, revision) {
+	observeFields(row) {
 		const session = row.page.sessions[0];
 		if (!session) return;
-		this.liveStatus.observe(row, revision.status);
-		if (session.name !== void 0 && this.names.observe(row.threadId, session.name, revision.name)) {
+		this.liveStatus.observe(row);
+		if (session.name !== void 0) {
+			this.names.update(row.threadId, session.name);
 			const current = this.rows.get(row.threadId);
 			if (current && current.page.sessions[0]?.name !== session.name) this.put(current);
 		}
@@ -1258,32 +1107,25 @@ var CodexCatalogIndex = class {
 		return this.reconcilingNative;
 	}
 	hydrate(useStateDbOnly = false, incremental = false) {
-		const run = () => this.observations.observe((isCurrent) => this.hydratePages(isCurrent, useStateDbOnly, incremental));
+		const run = () => this.hydratePages(useStateDbOnly, incremental);
 		return this.options.runNativeWalk?.(run) ?? run();
 	}
-	async hydratePages(isCurrent, useStateDbOnly, incremental) {
+	async hydratePages(useStateDbOnly, incremental) {
 		this.assertCurrent();
 		const files = this.rolloutScanner && !useStateDbOnly ? (await this.rolloutScanner.scan(/* @__PURE__ */ new Set())).files : /* @__PURE__ */ new Map();
 		this.assertCurrent();
-		let observedRevision;
 		let frontier;
 		const batchOrder = this.ordering.captureBatch(this.availability.complete);
 		const remaining = incremental ? void 0 : new Map(this.rows);
 		const pages = readCodexCatalogHydrationPages(async (params, remainingRows) => {
 			this.assertCurrent();
-			const fieldRevision = this.captureFields();
-			return {
-				...await this.options.readNative(params, remainingRows),
-				fieldRevision,
-				sourceRevision: this.sourceRevision
-			};
+			return await this.options.readNative(params, remainingRows);
 		}, useStateDbOnly);
 		for await (const page of pages) {
 			this.assertCurrent();
-			observedRevision ??= page.sourceRevision;
 			let sourceOrder = page.offset;
 			let changed = false;
-			for (const id of page.excludedThreadIds ?? []) if (isCurrent(id)) {
+			for (const id of page.excludedThreadIds ?? []) {
 				changed ||= this.rows.has(id);
 				this.remove(id);
 			}
@@ -1292,13 +1134,8 @@ var CodexCatalogIndex = class {
 				if (position >= 2e4) continue;
 				remaining?.delete(row.threadId);
 				const previous = this.rows.get(row.threadId);
-				this.observeFields(row, page.fieldRevision);
-				if (!isCurrent(row.threadId)) {
-					changed = true;
-					continue;
-				}
+				this.observeFields(row);
 				const fingerprint = resolveCodexCatalogRolloutFingerprint(row.rolloutPath, useStateDbOnly ? previous : void 0, files);
-				this.observations.mark(row.threadId);
 				this.put({
 					...row,
 					sourceOrder: batchOrder(row, previous, position),
@@ -1315,30 +1152,28 @@ var CodexCatalogIndex = class {
 			}
 		}
 		if (remaining && (!useStateDbOnly || !this.options.localSessionsRoot)) {
-			for (const [id, row] of remaining) if (isCurrent(id) && this.rows.get(id) === row) this.remove(id);
+			for (const [id, row] of remaining) if (this.rows.get(id) === row) this.remove(id);
 		}
 		this.availability.publish(frontier, true);
 		await this.persistence.finishHydration(this.overflow);
-		return observedRevision ?? this.sourceRevision;
 	}
 	reconcile() {
-		if (!this.reconciling) this.reconciling = this.observations.observe((isCurrent) => this.reconcileFiles(isCurrent)).finally(() => {
+		if (!this.reconciling) this.reconciling = this.reconcileFiles().finally(() => {
 			this.reconciling = void 0;
 		});
 		return this.reconciling;
 	}
-	async reconcileFiles(isCurrent) {
+	async reconcileFiles() {
 		const root = this.options.localSessionsRoot;
 		if (!root || !this.rolloutScanner || !this.initialized || this.closed) return;
 		this.assertCurrent();
-		this.observedFiles = await reconcileCodexCatalogFiles(root, isCurrent, {
+		this.observedFiles = await reconcileCodexCatalogFiles(root, {
 			rows: this.rows,
 			observedFiles: this.observedFiles,
 			scanner: this.rolloutScanner,
 			assertCurrent: () => this.assertCurrent(),
 			requestNativeRefresh: () => this.currency.requestNativeRefresh(),
 			report: (error) => this.report(error),
-			mark: (id) => this.observations.mark(id),
 			put: (row) => this.put(row),
 			remove: (id) => this.remove(id)
 		});
@@ -1353,11 +1188,7 @@ var CodexCatalogIndex = class {
 		try {
 			this.currency.requestNativeRefresh();
 			const prepared = projectCodexCatalogNativeThread(thread, sanitizeTerminalText);
-			return this.projections.run(() => {
-				this.observations.mark(prepared.id);
-				const fields = this.captureFields();
-				return this.observations.observe((isCurrent) => this.projectThread(prepared, isCurrent, fields));
-			}).then(() => void 0).catch((error) => {
+			return this.projections.run(() => this.projectThread(prepared)).catch((error) => {
 				if (!(error instanceof CodexCatalogProjectionCapacityError)) throw error;
 				this.report(error);
 			});
@@ -1367,40 +1198,34 @@ var CodexCatalogIndex = class {
 	}
 	refreshThread(id, readThread, sourceOrder) {
 		this.assertCurrent();
-		this.observations.mark(id);
-		const fields = this.captureFields();
-		return this.projections.run(() => this.observations.observe((isCurrent) => readThread(id).then((thread) => {
+		return this.projections.run(() => readThread(id).then((thread) => {
 			const prepared = projectCodexCatalogNativeThread(thread, sanitizeTerminalText);
 			if (prepared.id !== id) throw new Error("Codex catalog refresh returned a different thread");
-			return this.closed ? true : this.projectThread(prepared, isCurrent, fields, sourceOrder);
-		})));
+			return this.closed ? void 0 : this.projectThread(prepared, sourceOrder);
+		}));
 	}
-	async projectThread(thread, isCurrent, fieldRevision, sourceOrder) {
+	async projectThread(thread, sourceOrder) {
 		const projected = await projectCodexCatalogPage({ data: [thread] }, {
 			localSessionsRoot: this.options.localSessionsRoot,
 			sanitize: sanitizeTerminalText
 		});
-		if (this.closed) return true;
+		if (this.closed) return;
 		const row = projected.rows[0];
-		if (row) this.observeFields(row, fieldRevision);
-		if (!isCurrent(thread.id)) return false;
+		if (row) this.observeFields(row);
 		if (projected.excludedThreadIds?.includes(thread.id)) this.remove(thread.id);
 		if (row) {
 			const previous = this.rows.get(thread.id);
 			const fingerprint = resolveCodexCatalogRolloutFingerprint(row.rolloutPath, previous);
-			this.observations.mark(thread.id);
 			this.put({
 				...row,
 				...sourceOrder !== void 0 ? { sourceOrder } : {},
 				...fingerprint ? { fingerprint } : {}
 			});
 		}
-		return true;
 	}
 	archive(threadId) {
 		if (this.closed) return;
 		this.currency.requestNativeRefresh();
-		this.observations.mark(threadId);
 		this.liveStatus.delete(threadId);
 		this.liveSettings.delete(threadId);
 		this.names.delete(threadId);
@@ -1415,7 +1240,7 @@ var CodexCatalogIndex = class {
 		return this.rows.get(threadId);
 	}
 	hasActiveWork() {
-		return Boolean(this.initializing || !this.restored && this.restoring || this.reconciling || this.reconcilingNative || this.currency.hasActiveWork() || this.observations.hasActiveWork() || this.events.hasActiveWork() || this.persistence.hasActiveWork());
+		return Boolean(this.initializing || !this.restored && this.restoring || this.reconciling || this.reconcilingNative || this.projections.hasActiveWork() || this.currency.hasActiveWork() || this.events.hasActiveWork() || this.persistence.hasActiveWork());
 	}
 	async list(params, deadline = performance.now() + (this.options.requestTimeoutMs ?? 6e4)) {
 		return await withCodexCatalogListRequest(async (request) => {