@openclaw/codex 2026.9.5 → 2026.9.7

package/dist/.setup/{session-catalog-fUdWDx-U.mjs → session-catalog-4sCdv5qx.mjs}

@@ -1,16 +1,22 @@
-import { p as sessionBindingIdentity } from "./session-binding-record-TH3xA0zj.mjs";
-import { _ as resolveCodexAppServerUserHomeDir, f as assertCodexThreadForkParams, g as resolveCodexAppServerLocalHomeDir, h as resolveCodexAppServerHomeDir } from "./config-security-BRQ2mgW9.mjs";
-import { d as readCodexPluginConfig } from "./config-parsing-CcB9iPoq.mjs";
-import { A as parseTranscriptPage, B as unwrapNodeInvokePayload, E as isInteractiveThreadSource, I as requireOnlyKeys, M as readControlCursor, N as readGatewayParams, O as parseCatalogPage, P as readPageParams, S as catalogError, T as filterCatalogPageByTitle, _ as MAX_CURSOR_LENGTH, b as NODE_INVOKE_TIMEOUT_MS, d as CODEX_APP_SERVER_THREADS_CAPABILITY, f as CODEX_APP_SERVER_THREADS_LIST_COMMAND, g as CatalogParamsError, h as CODEX_LOCAL_SESSION_HOST_ID, j as readBoundedOptionalString, k as parseJsonParams, m as CODEX_CATALOG_TRANSCRIPT_READ_COMMAND, p as CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND, y as MAX_TRANSCRIPT_PAGE_BYTES } from "./session-catalog-native-projection-ChV3cCtm.mjs";
-import { a as isCodexThreadReadMissingError, i as CodexAppServerRpcError, n as withTimeout } from "./timeout-DZF05XrR.mjs";
-import { t as CODEX_CONTROL_METHODS } from "./capabilities-_vXcZGSx.mjs";
-import { r as compareCodexCatalogRows } from "./session-catalog-index-order-Cc5BzlQr.mjs";
-import { n as readLegacyCodexHistoryPage, t as readCodexThreadHistoryPage } from "./thread-history-page-BTx-4xsg.mjs";
-import { i as projectCodexUserItemText } from "./transcript-history-projection-DHNBDhCU.mjs";
+import { A as unwrapNodeInvokePayload, C as readGatewayParams, E as requireOnlyKeys, S as readControlCursor, _ as normalizeLimit, a as CODEX_LOCAL_SESSION_HOST_ID, b as parseTranscriptPage, f as catalogError, g as isInteractiveThreadSource, h as filterCatalogPageByTitle, i as CODEX_CATALOG_TRANSCRIPT_READ_COMMAND, l as MAX_TRANSCRIPT_PAGE_BYTES, n as CODEX_APP_SERVER_THREADS_LIST_COMMAND, o as CatalogParamsError, r as CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND, s as MAX_CURSOR_LENGTH, t as CODEX_APP_SERVER_THREADS_CAPABILITY, u as NODE_INVOKE_TIMEOUT_MS, v as parseCatalogPage, w as readPageParams, x as readBoundedOptionalString, y as parseJsonParams } from "./session-catalog-parsing-CPGaPYr-.mjs";
+import { n as assertCodexThreadForkParams } from "./protocol-CANUwXJ3.mjs";
+import { v as sessionBindingIdentity } from "./session-binding-record-Oe9L-CNY.mjs";
+import { d as readCodexPluginConfig } from "./config-parsing-b088LyhT.mjs";
+import { n as resolveCodexAppServerLocalHomeDir, r as resolveCodexAppServerUserHomeDir, t as resolveCodexAppServerHomeDir } from "./auth-start-options-BPIPeEX8.mjs";
+import { i as hasActiveSharedCodexAppServerWork, r as getSharedCodexAppServerClientState } from "./shared-client-lifecycle-DJIgqgMw.mjs";
+import { n as CodexAppServerRpcError, r as isCodexThreadReadMissingError } from "./rpc-error-BlD2vuzn.mjs";
+import { t as CODEX_CONTROL_METHODS } from "./capabilities-B3WEZl4e.mjs";
+import { n as codexCatalogHomeIdFromCanonicalPath } from "./session-catalog-home-id-vlih0B_g.mjs";
+import { i as withTimeout } from "./timeout-CXOfNoaX.mjs";
+import { a as CodexCatalogLoadingError, n as currentCodexCatalogListRequest, r as withCodexCatalogListRequest, t as CodexCatalogListRequest } from "./session-catalog-list-request-CvtxrYSe.mjs";
+import { t as lookupNodeCodexCatalogRecord } from "./session-catalog-node-lookup-CtAXI5W5.mjs";
+import { r as projectCodexUserItemText } from "./transcript-history-projection-DRSifI-1.mjs";
 import { r as codexUpstreamContinueResult } from "./session-upstream-marker-D15C9NHp.mjs";
-import { t as buildCodexAppServerConnectionFingerprint } from "./plugin-app-cache-key-BOxKP7db.mjs";
-import { c as readCodexSessionMeta, o as codexCatalogHomeIdFromCanonicalPath, t as codexCatalogResidentHomeKey } from "./session-catalog-events-jMcYfQyd.mjs";
-import { a as setCodexCatalogConnectionHomeResolver } from "./binding-connection-Bm38niE8.mjs";
+import { t as buildCodexAppServerConnectionFingerprint } from "./plugin-app-cache-key-BL9B5H0L.mjs";
+import { n as findCodexAppServerSpawnError } from "./spawn-error-CL3n6MAa.mjs";
+import { n as readCodexSessionMeta } from "./session-catalog-provenance-DoAvktcj.mjs";
+import { t as codexCatalogResidentHomeKey } from "./session-catalog-events-DePDzzjc.mjs";
+import { a as setCodexCatalogConnectionHomeResolver } from "./binding-connection-DTtN1KrX.mjs";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { randomUUID } from "node:crypto";
 import { embeddedAgentLog, resolveDefaultAgentDir } from "openclaw/plugin-sdk/agent-harness-registration";
@@ -18,6 +24,7 @@ import { listAgentIds, resolveAgentDir, resolveDefaultAgentId, resolveSessionAge
 import { z } from "zod";
 import path from "node:path";
 import fs from "node:fs/promises";
+import { canonicalPathFromExistingAncestor } from "openclaw/plugin-sdk/file-access-runtime";
 import { scheduler } from "node:timers/promises";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { isMainThread, threadId } from "node:worker_threads";
@@ -201,6 +208,14 @@ function currentCodexCatalogListDiagnostics() {
 	const observation = listScope.getStore();
 	return observation?.closed ? void 0 : observation;
 }
+function startCodexCatalogListTiming(field, counter) {
+	const observation = currentCodexCatalogListDiagnostics();
+	const started = observation ? performance.now() : 0;
+	if (observation && counter) observation.fields[counter]++;
+	return () => {
+		if (observation && !observation.closed) observation.fields[field] = (observation.fields[field] ?? 0) + performance.now() - started;
+	};
+}
 /** One logical list scope survives admission pauses; finishing drops its captured context. */
 function createCodexCatalogListScope() {
 	const observation = start("list phases", {
@@ -287,98 +302,108 @@ function startCodexCatalogControlRequestDiagnostics(page) {
 	return observation;
 }
 //#endregion
-//#region extensions/codex/src/session-catalog-availability.ts
-var CodexCatalogLoadingError = class extends Error {
+//#region extensions/codex/src/session-catalog-node-snapshot.ts
+/** One query-compatible native page per node, owned by the registered catalog provider. */
+var CodexCatalogNodeSnapshots = class {
 	constructor() {
-		super("Codex session catalog is still loading. Retry shortly.");
-		this.code = "APP_SERVER_UNAVAILABLE";
+		this.generation = 0;
+		this.inventoryGeneration = 0;
+		this.configGeneration = 0;
+		this.nodes = /* @__PURE__ */ new Map();
 	}
-};
-/** One generation promise wakes cold callers; native pages remain owned by the index. */
-var CodexCatalogAvailability = class {
-	constructor() {
-		this.complete = false;
-		this.changed = createDeferred();
+	start(config) {
+		if (this.config !== config) {
+			this.nodes.clear();
+			this.config = config;
+			this.configGeneration = this.generation + 1;
+			this.inventoryGeneration = this.configGeneration;
+		}
+		return ++this.generation;
 	}
-	begin() {
-		this.failure = void 0;
+	observe(generation, nodes) {
+		if (generation < this.inventoryGeneration) return;
+		this.inventoryGeneration = generation;
+		const connected = new Map(nodes.filter((node) => node.connected).map((node) => [node.nodeId, node]));
+		for (const [nodeId, publication] of this.nodes) {
+			const node = connected.get(nodeId);
+			if (!node || node.connectedAtMs !== publication.connection) this.nodes.delete(nodeId);
+		}
+		for (const node of connected.values()) if (!this.nodes.has(node.nodeId)) this.nodes.set(node.nodeId, {
+			connection: node.connectedAtMs,
+			generation: 0
+		});
 	}
-	publish(frontier, complete = false) {
-		if (this.complete) return;
-		if (frontier && (!this.frontier || compareCodexCatalogRows(frontier, this.frontier) > 0)) {
-			const { threadId, updatedAt, recencyAt, sourceOrder } = frontier;
-			this.frontier = {
-				threadId,
-				updatedAt,
-				recencyAt,
-				sourceOrder
+	forNode(node, generation, key) {
+		let publication = this.nodes.get(node.nodeId);
+		if (!publication) {
+			publication = {
+				connection: node.connectedAtMs,
+				generation: 0
 			};
+			if (generation >= this.inventoryGeneration) this.nodes.set(node.nodeId, publication);
 		}
-		this.complete = complete;
-		this.notify();
-	}
-	fail(error) {
-		this.failure = { error };
-		this.notify();
-	}
-	notify() {
-		const previous = this.changed;
-		this.changed = createDeferred();
-		previous.resolve();
-	}
-	async until(promise, deadline) {
-		const remaining = deadline - performance.now();
-		if (remaining <= 0) throw new CodexCatalogLoadingError();
-		return await withTimeout(promise, remaining, "Codex session catalog is still loading", () => new CodexCatalogLoadingError());
-	}
-	async next(deadline) {
-		if (this.failure) throw this.failure.error;
-		await this.until(this.changed.promise, deadline);
+		const valid = () => generation >= this.configGeneration && this.nodes.get(node.nodeId) === publication && publication.connection === node.connectedAtMs;
+		return {
+			read: () => valid() && publication.snapshot?.key === key ? publication.snapshot : void 0,
+			publish: (host) => {
+				if (!valid() || generation < publication.generation) return false;
+				publication.generation = generation;
+				publication.snapshot = node.connected && host.connected ? {
+					key,
+					generation,
+					host
+				} : void 0;
+				return true;
+			},
+			isCurrent: (snapshot) => valid() && publication.snapshot === snapshot,
+			valid
+		};
 	}
 };
-//#endregion
-//#region extensions/codex/src/session-catalog-node-lookup.ts
-async function lookupNodeCodexCatalogRecord(params) {
-	const deadline = performance.now() + NODE_INVOKE_TIMEOUT_MS;
-	const unverified = () => new CatalogParamsError("Codex session eligibility could not be verified");
-	const remaining = () => {
-		const timeoutMs = Math.ceil(deadline - performance.now());
-		if (timeoutMs <= 0) throw unverified();
-		return timeoutMs;
+function createNodeHostPublication(publication, adopted, sourceKey, onHost, signal, partial, waitUntil) {
+	let publishedSnapshot;
+	let publishedHost;
+	const project = (host) => ({
+		...host,
+		sessions: host.sessions.map((session) => {
+			const entry = session.sourceHomeId ? adopted.get(sourceKey(host.hostId, session.threadId, session.sourceHomeId)) : void 0;
+			return entry ? {
+				...session,
+				sessionKey: entry.key
+			} : session;
+		})
+	});
+	const emit = (host) => {
+		publishedHost = project(host);
+		return onHost?.(publishedHost);
 	};
-	let cursor;
-	const seenCursors = /* @__PURE__ */ new Set();
-	for (;;) {
-		const timeoutMs = remaining();
-		const raw = await withTimeout(params.runtime.nodes.invoke({
-			nodeId: params.nodeId,
-			command: CODEX_APP_SERVER_THREADS_LIST_COMMAND,
-			params: {
-				agentId: params.agentId,
-				limit: 100,
-				...cursor ? { cursor } : {}
-			},
-			timeoutMs,
-			scopes: ["operator.write"]
-		}), timeoutMs, "Codex session eligibility could not be verified", unverified);
-		remaining();
-		const page = parseCatalogPage(unwrapNodeInvokePayload(raw));
-		const record = page.sessions.find((candidate) => candidate.threadId === params.threadId);
-		if (record) return {
-			kind: "found",
-			record
-		};
-		const nextCursor = page.nextCursor?.trim();
-		if (!nextCursor) break;
-		if (seenCursors.has(nextCursor)) return { kind: "cursor-cycle" };
-		seenCursors.add(nextCursor);
-		if (seenCursors.size > 2e4) {
-			const oldest = seenCursors.values().next().value;
-			if (oldest !== void 0) seenCursors.delete(oldest);
+	return {
+		project,
+		readPublished: () => publishedHost,
+		publish: (host) => {
+			if (signal?.aborted) return partial ? void 0 : onHost?.(project(host));
+			if (!publication.valid()) return;
+			if (publication.publish(host)) {
+				publishedSnapshot = publication.read();
+				return emit(host);
+			}
+			const latest = publication.read();
+			return emit(latest?.host ?? host);
+		},
+		publishCached: (snapshot) => {
+			if (signal?.aborted || snapshot === publishedSnapshot || !publication.isCurrent(snapshot)) return;
+			const completion = createDeferred();
+			completion.promise.catch(() => void 0);
+			try {
+				waitUntil?.(completion.promise);
+				completion.resolve(emit(snapshot.host));
+				publishedSnapshot = snapshot;
+			} catch (error) {
+				completion.reject(error);
+				throw error;
+			}
 		}
-		cursor = nextCursor;
-	}
-	return { kind: "missing" };
+	};
 }
 //#endregion
 //#region extensions/codex/src/session-catalog-terminal.ts
@@ -390,6 +415,7 @@ function createCodexTerminalStartNodeHostCommand() {
 		cap: CODEX_APP_SERVER_THREADS_CAPABILITY,
 		dangerous: false,
 		duplex: true,
+		hasActiveWork: () => false,
 		isAvailable: ({ env }) => Boolean(resolveNodeHostExecutable("codex", {
 			env,
 			strategy: "direct"
@@ -416,6 +442,7 @@ function resolveCodexCatalogTerminalHome(sources) {
 	if (!runtimeConfig) throw new Error("OpenClaw runtime config is unavailable");
 	const agentDir = sources.source?.agentDir ?? (sources.agentId ? resolveAgentDir(runtimeConfig, sources.agentId) : resolveDefaultAgentDir(runtimeConfig));
 	const startOptions = sources.source?.appServer.start ?? sources.resolveRuntimeOptions({ pluginConfig: sources.getPluginConfig() }).start;
+	if (startOptions.transport !== "stdio") throw new CatalogParamsError("Native terminal requires a local Codex source");
 	return resolveCodexAppServerLocalHomeDir(startOptions, agentDir);
 }
 function resolveLocalCodexTerminalExecutable(env = process.env) {
@@ -441,7 +468,8 @@ function createCodexTerminalNodeHostCommand(bindRequest) {
 		cap: CODEX_APP_SERVER_THREADS_CAPABILITY,
 		dangerous: false,
 		duplex: true,
-		isAvailable: ({ env }) => Boolean(resolveNodeHostExecutable("codex", {
+		hasActiveWork: () => false,
+		isAvailable: ({ config, env }) => (readCodexPluginConfig(config.plugins?.entries?.codex?.config).appServer?.transport ?? "stdio") === "stdio" && Boolean(resolveNodeHostExecutable("codex", {
 			env,
 			pathEnv: env.PATH ?? env.Path ?? "",
 			strategy: "direct"
@@ -449,6 +477,7 @@ function createCodexTerminalNodeHostCommand(bindRequest) {
 		handle: async (paramsJSON, io) => {
 			if (!io) throw new Error("Codex terminal command requires duplex transport");
 			const request = await bindRequest(paramsJSON);
+			if (request.transport !== "stdio") throw new CatalogParamsError("Native terminal requires a local Codex source");
 			const resume = decodeNodePtyResumeParams(request.paramsJSON, (value) => {
 				if (typeof value !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu.test(value)) throw new CatalogParamsError("threadId must be a UUID");
 				return value;
@@ -460,9 +489,11 @@ function createCodexTerminalNodeHostCommand(bindRequest) {
 				strategy: "direct"
 			});
 			if (!resolution) throw new Error("Codex CLI is unavailable");
+			request.assertCurrent();
 			return JSON.stringify(await runNodePtyCommand({
 				file: resolution.executable,
 				args: ["resume", resume.threadId],
+				assertCurrent: () => request.assertCurrent(),
 				...record.cwd ? { cwd: record.cwd } : {},
 				env: { CODEX_HOME: request.codexHome },
 				cols: resume.cols,
@@ -500,7 +531,8 @@ async function openCodexCatalogTerminal(params) {
 		agentId: params.agentId,
 		runtime: params.api.runtime,
 		nodeId,
-		threadId: params.threadId
+		threadId: params.threadId,
+		sourceHomeId: params.sourceHomeId
 	});
 	if (lookup.kind !== "found" || !isInteractiveThreadSource(lookup.record.source)) throw new CatalogParamsError("Codex session is not a non-archived interactive Codex session");
 	const record = lookup.record;
@@ -511,7 +543,8 @@ async function openCodexCatalogTerminal(params) {
 		uploadPathStyle: "native",
 		paramsJSON: JSON.stringify({
 			agentId: params.agentId,
-			threadId: params.threadId
+			threadId: params.threadId,
+			...lookup.sourceHomeId ? { sourceHomeId: lookup.sourceHomeId } : {}
 		}),
 		...record.cwd ? { cwd: record.cwd } : {},
 		title
@@ -542,120 +575,6 @@ async function startCodexCatalogTerminal(params) {
 	};
 }
 //#endregion
-//#region extensions/codex/src/session-catalog-list-request.ts
-const listRequest = new AsyncLocalStorage();
-function currentCodexCatalogListRequest() {
-	return listRequest.getStore();
-}
-/** One foreground request owns its native read budget and source-health outcome. */
-var CodexCatalogListRequest = class {
-	constructor() {
-		this.pages = 0;
-		this.closed = false;
-		this.attempts = /* @__PURE__ */ new Map();
-	}
-	get hasPages() {
-		return this.pages < 20;
-	}
-	deadline(timeoutMs) {
-		this.assertActive();
-		return this.deadlineAt ??= performance.now() + timeoutMs;
-	}
-	constrainDeadline(absolute) {
-		this.assertActive();
-		this.deadlineAt = Math.min(this.deadlineAt ?? absolute, absolute);
-		return this.deadlineAt;
-	}
-	remaining(timeoutMs) {
-		const remaining = Math.min(timeoutMs, this.deadline(timeoutMs) - performance.now());
-		if (remaining <= 0) throw new CodexCatalogLoadingError();
-		return remaining;
-	}
-	assertActive() {
-		if (this.closed) throw new DOMException("Codex session catalog request is closed", "AbortError");
-		if (this.deadlineAt !== void 0 && this.deadlineAt <= performance.now()) throw new CodexCatalogLoadingError();
-	}
-	async run(run) {
-		this.assertActive();
-		const pending = listRequest.run(this, run);
-		const remaining = this.deadlineAt === void 0 ? void 0 : this.deadlineAt - performance.now();
-		if (remaining !== void 0 && remaining <= 0) {
-			pending.catch(() => {});
-			throw new CodexCatalogLoadingError();
-		}
-		const result = remaining === void 0 ? await pending : await withTimeout(pending, remaining, "Codex session catalog is still loading", () => new CodexCatalogLoadingError());
-		this.assertActive();
-		return result;
-	}
-	async read(timeoutMs, read) {
-		const remaining = this.remaining(timeoutMs);
-		if (!this.hasPages) throw new CatalogParamsError("Codex catalog native page budget is exhausted");
-		this.pages++;
-		try {
-			const result = await withTimeout(read(remaining), remaining, "Codex session catalog is still loading", () => new CodexCatalogLoadingError());
-			this.assertActive();
-			return result;
-		} catch (error) {
-			if (!this.closed) this.failure ??= { error };
-			throw error;
-		}
-	}
-	attempt(owner, key, start) {
-		this.assertActive();
-		let attempts = this.attempts.get(owner);
-		const existing = attempts?.get(key);
-		if (existing) return existing;
-		const attempt = start();
-		if (!attempts) {
-			attempts = /* @__PURE__ */ new Map();
-			this.attempts.set(owner, attempts);
-		}
-		attempts.set(key, attempt);
-		return attempt;
-	}
-	resolved() {
-		if (this.failure) {
-			this.rejected(this.failure.error);
-			return;
-		}
-		this.settle((attempt) => attempt.resolved());
-	}
-	rejected(error) {
-		if (error instanceof Error && error.name === "AbortError") {
-			this.close();
-			return;
-		}
-		const reason = this.failure?.error ?? error;
-		this.settle((attempt) => attempt.rejected(reason));
-	}
-	close() {
-		this.settle((attempt) => attempt.abandoned());
-	}
-	settle(settle) {
-		if (this.closed) return;
-		this.closed = true;
-		for (const attempts of this.attempts.values()) for (const attempt of attempts.values()) if (attempt.allowed) settle(attempt);
-		this.attempts.clear();
-		this.failure = void 0;
-	}
-};
-async function withCodexCatalogListRequest(run) {
-	const current = currentCodexCatalogListRequest();
-	if (current) {
-		current.assertActive();
-		return await run(current);
-	}
-	const scope = new CodexCatalogListRequest();
-	try {
-		const result = await scope.run(() => run(scope));
-		scope.resolved();
-		return result;
-	} catch (error) {
-		scope.rejected(error);
-		throw error;
-	}
-}
-//#endregion
 //#region extensions/codex/src/session-catalog-visible-page.ts
 /** Fill exclusions from bounded resident pages. */
 var CodexCatalogVisiblePage = class {
@@ -687,9 +606,7 @@ var CodexCatalogVisiblePage = class {
 		if (this.complete) throw new Error("Codex catalog page is already complete");
 		const params = this.params;
 		params.signal?.throwIfAborted();
-		const diagnostics = currentCodexCatalogListDiagnostics();
-		const started = diagnostics ? performance.now() : 0;
-		if (diagnostics) diagnostics.fields.controlPageCalls++;
+		const finishTiming = startCodexCatalogListTiming("controlWaitSumMs", "controlPageCalls");
 		let rawPage;
 		try {
 			rawPage = await params.control.listPage({
@@ -699,7 +616,7 @@ var CodexCatalogVisiblePage = class {
 				...params.cwd ? { cwd: params.cwd } : {}
 			});
 		} finally {
-			if (diagnostics && !diagnostics.closed) diagnostics.fields.controlWaitSumMs = (diagnostics.fields.controlWaitSumMs ?? 0) + performance.now() - started;
+			finishTiming();
 		}
 		this.request.assertActive();
 		params.signal?.throwIfAborted();
@@ -752,6 +669,24 @@ async function listVisiblePage(params) {
 }
 //#endregion
 //#region extensions/codex/src/session-catalog-list-operation.ts
+async function boundedHost(pending) {
+	let timer;
+	try {
+		return await Promise.race([pending, new Promise((resolve) => {
+			timer = setTimeout(() => resolve(void 0), 250);
+		})]);
+	} finally {
+		clearTimeout(timer);
+	}
+}
+function measureNodeHost(host, diagnostics, started) {
+	return diagnostics ? host.finally(() => {
+		if (!diagnostics.closed) {
+			diagnostics.fields.pairedNodeSettled = (diagnostics.fields.pairedNodeSettled ?? 0) + 1;
+			diagnostics.fields.nodeWaitSumMs = (diagnostics.fields.nodeWaitSumMs ?? 0) + performance.now() - started;
+		}
+	}) : host;
+}
 function hostFailure(source, error) {
 	return {
 		hostId: source?.hostId ?? "gateway:local",
@@ -767,12 +702,10 @@ function hostFailure(source, error) {
 }
 async function projectLocalHost(params, agentId, source, page) {
 	params.signal?.throwIfAborted();
-	const { listAdoptedSessionEntries } = await import("./session-catalog-adoption-CR_whkEW.mjs");
+	const { listAdoptedSessionEntries } = await import("./session-catalog-adoption-BU_pHWG7.mjs");
 	const { sessionCatalogAdoptedSourceKey } = await import("openclaw/plugin-sdk/session-catalog");
 	params.signal?.throwIfAborted();
-	const diagnostics = currentCodexCatalogListDiagnostics();
-	const started = diagnostics ? performance.now() : 0;
-	if (diagnostics) diagnostics.fields.adoptionCalls++;
+	const finishTiming = startCodexCatalogListTiming("adoptionSumMs", "adoptionCalls");
 	let adopted;
 	try {
 		adopted = await listAdoptedSessionEntries({
@@ -783,7 +716,7 @@ async function projectLocalHost(params, agentId, source, page) {
 			sessionEntries: params.sessionEntries
 		});
 	} finally {
-		if (diagnostics && !diagnostics.closed) diagnostics.fields.adoptionSumMs = (diagnostics.fields.adoptionSumMs ?? 0) + performance.now() - started;
+		finishTiming();
 	}
 	const hostId = source?.hostId ?? "gateway:local";
 	const sourceHomeId = source?.sourceHomeId ?? "gateway:local";
@@ -809,9 +742,7 @@ async function projectLocalHost(params, agentId, source, page) {
 function managedMarker(store, sourceHomeId, managed) {
 	return async ({ threadId, rolloutPath }) => {
 		if (managed?.has(threadId)) return;
-		const diagnostics = currentCodexCatalogListDiagnostics();
-		const started = diagnostics ? performance.now() : 0;
-		if (diagnostics) diagnostics.fields.exclusionMarkCalls++;
+		const finishTiming = startCodexCatalogListTiming("exclusionMarkSumMs", "exclusionMarkCalls");
 		try {
 			await store.mark({
 				sourceHomeId,
@@ -819,10 +750,23 @@ function managedMarker(store, sourceHomeId, managed) {
 				...rolloutPath ? { rolloutPath } : {}
 			});
 		} finally {
-			if (diagnostics && !diagnostics.closed) diagnostics.fields.exclusionMarkSumMs = (diagnostics.fields.exclusionMarkSumMs ?? 0) + performance.now() - started;
+			finishTiming();
 		}
 	};
 }
+async function finishLocalHost(params, agentId, host) {
+	try {
+		for (;;) {
+			const step = await host.page.next();
+			params.signal?.throwIfAborted();
+			if (step.done) return await projectLocalHost(params, agentId, host.source, step.page);
+		}
+	} catch (error) {
+		return hostFailure(host.source, error);
+	} finally {
+		host.page.close();
+	}
+}
 function createNodePublicationTracker(publications, waitUntil) {
 	const settled = () => {
 		publications.pending--;
@@ -838,6 +782,7 @@ var CodexCatalogListDriver = class {
 	constructor(params) {
 		this.locals = [];
 		this.nodeActive = false;
+		this.nodeResults = [];
 		this.nodeDiscoveryFailed = false;
 		this.nodePublications = { pending: 0 };
 		this.nodesStarted = false;
@@ -846,6 +791,8 @@ var CodexCatalogListDriver = class {
 		this.running = false;
 		this.complete = false;
 		this.params = params;
+		this.nodeSnapshots = params.nodeSnapshots ?? new CodexCatalogNodeSnapshots();
+		this.nodeGeneration = this.nodeSnapshots.start(params.config);
 	}
 	request() {
 		if (!this.params) throw new Error("Codex catalog list operation is closed");
@@ -908,6 +855,20 @@ var CodexCatalogListDriver = class {
 	}
 	async readHost(host) {
 		const params = this.request();
+		if (params.allowPartialResults === true && params.onHost && params.waitUntil) {
+			host.background = true;
+			const completion = finishLocalHost(params, this.selection().agentId, host);
+			completion.then(host.completion.resolve, host.completion.reject);
+			host.value = await boundedHost(completion) ?? {
+				hostId: host.source?.hostId ?? "gateway:local",
+				label: host.source?.label ?? "Local Codex",
+				kind: "gateway",
+				connected: true,
+				pending: true,
+				sessions: []
+			};
+			return;
+		}
 		try {
 			const page = await host.page.next();
 			params.signal?.throwIfAborted();
@@ -940,9 +901,11 @@ var CodexCatalogListDriver = class {
 		const started = diagnostics ? performance.now() : 0;
 		if (diagnostics) diagnostics.fields.nodeRegistryCalls = 1;
 		let nodes;
+		let inventory;
 		try {
 			try {
-				nodes = (await (params.listNodes?.() ?? params.runtime.nodes.list())).nodes.filter((node) => node.gatewayLocal !== true && (node.commands?.includes("codex.appServer.threads.list.v1") || codexNodeTerminalCapability(node).canStartTerminal) && (!requestedHostIds || requestedHostIds.has(`node:${node.nodeId}`))).slice(0, 100 - this.locals.length);
+				inventory = (await (params.listNodes?.() ?? params.runtime.nodes.list())).nodes;
+				nodes = inventory.filter((node) => node.gatewayLocal !== true && (node.commands?.includes("codex.appServer.threads.list.v1") || codexNodeTerminalCapability(node).canStartTerminal) && (!requestedHostIds || requestedHostIds.has(`node:${node.nodeId}`))).slice(0, 100 - this.locals.length);
 			} finally {
 				if (diagnostics && !diagnostics.closed) diagnostics.fields.nodeRegistryMs = performance.now() - started;
 			}
@@ -961,8 +924,9 @@ var CodexCatalogListDriver = class {
 			return [host];
 		}
 		params.signal?.throwIfAborted();
-		const { listNodeAdoptedSessionEntries } = await import("./session-catalog-node-adoption-BVRsYOSh.mjs");
-		const { compareNodeLabels, listPairedNode } = await import("./session-catalog-node-continue-Dowv8osw.mjs");
+		this.nodeSnapshots.observe(this.nodeGeneration, inventory);
+		const { listNodeAdoptedSessionEntries, nodeAdoptedSourceKey } = await import("./session-catalog-node-adoption-DgXvSGu0.mjs");
+		const { compareNodeLabels, listPairedNode, nodeLabel } = await import("./session-catalog-node-continue-DjKXHBbi.mjs");
 		params.signal?.throwIfAborted();
 		const adopted = listNodeAdoptedSessionEntries({
 			agentId,
@@ -975,26 +939,61 @@ var CodexCatalogListDriver = class {
 			diagnostics.fields.pairedNodeSettled = 0;
 		}
 		const trackPublication = createNodePublicationTracker(this.nodePublications, params.waitUntil);
+		const partial = params.allowPartialResults === true && Boolean(params.onHost && params.waitUntil);
 		const pendingHosts = nodes.toSorted(compareNodeLabels).map((node) => {
+			const key = JSON.stringify([
+				agentId,
+				query.limitPerHost,
+				query.search,
+				query.cursors?.[`node:${node.nodeId}`],
+				node.displayName,
+				node.remoteIp,
+				node.caps,
+				node.commands,
+				node.invocableCommands
+			]);
+			const publication = this.nodeSnapshots.forNode(node, this.nodeGeneration, key);
+			const { project, publish, publishCached, readPublished } = createNodeHostPublication(publication, adopted, nodeAdoptedSourceKey, params.onHost, params.signal, partial, trackPublication);
+			const cached = partial ? publication.read() : void 0;
+			let result;
+			this.nodeResults.push(() => {
+				const latest = partial ? publication.read() : void 0;
+				if (latest) {
+					publishCached(latest);
+					return project(latest.host);
+				}
+				return !partial ? result : publication.valid() ? readPublished() ?? result : void 0;
+			});
+			if (cached) publishCached(cached);
 			const nodeStarted = diagnostics ? performance.now() : 0;
 			if (diagnostics && !diagnostics.closed) diagnostics.fields.pairedNodeCalls = (diagnostics.fields.pairedNodeCalls ?? 0) + 1;
-			const host = listPairedNode({
+			const completion = measureNodeHost(listPairedNode({
 				agentId,
 				runtime: params.runtime,
 				node,
 				query,
-				adoptedSessions: adopted,
 				terminalCapabilities: codexNodeTerminalCapability(node),
 				waitUntil: trackPublication,
 				signal: params.signal,
-				...params.onHost ? { onHost: params.onHost } : {}
+				onHost: publish
+			}), diagnostics, nodeStarted);
+			if (cached) {
+				completion.catch(() => void 0);
+				return Promise.resolve(project(cached.host));
+			}
+			return (partial ? boundedHost(completion) : completion).then((value) => {
+				result = value ? project(value) : {
+					hostId: `node:${node.nodeId}`,
+					label: nodeLabel(node),
+					kind: "node",
+					nodeId: node.nodeId,
+					connected: true,
+					pending: true,
+					...codexNodeTerminalCapability(node),
+					sessions: []
+				};
+				return result;
 			});
-			return diagnostics ? host.finally(() => {
-				if (!diagnostics.closed) {
-					diagnostics.fields.pairedNodeSettled = (diagnostics.fields.pairedNodeSettled ?? 0) + 1;
-					diagnostics.fields.nodeWaitSumMs = (diagnostics.fields.nodeWaitSumMs ?? 0) + performance.now() - nodeStarted;
-				}
-			}) : host;
 		});
 		try {
 			return await Promise.all(pendingHosts);
@@ -1021,13 +1020,20 @@ var CodexCatalogListDriver = class {
 		if (this.active > 0 || !this.step) return;
 		if (this.failure) {
 			if (!this.nodeActive) this.step.reject(this.failure.error);
-		} else if (this.nodeHosts && this.locals.every((host) => host.value !== void 0)) {
+		} else if (this.nodeHosts && this.locals.every((host) => host.value !== void 0)) try {
 			this.complete = true;
 			this.step.resolve({
 				done: true,
-				hosts: [...this.locals.flatMap((host) => host.value ? [host.value] : []), ...this.nodeHosts]
+				hosts: [...this.locals.flatMap((host) => host.value ? [host.value] : []), ...this.nodeResults.length ? this.nodeResults.flatMap((read) => {
+					const host = read();
+					return host ? [host] : [];
+				}) : this.nodeHosts]
 			});
-		} else if (this.canPause()) this.step.resolve({ done: false });
+		} catch (error) {
+			this.failure ??= { error };
+			this.step.reject(error);
+		}
+		else if (this.canPause()) this.step.resolve({ done: false });
 	}
 	async next() {
 		const params = this.request();
@@ -1052,12 +1058,13 @@ var CodexCatalogListDriver = class {
 		const reason = this.failure?.error ?? this.params.signal?.reason ?? /* @__PURE__ */ new Error("Codex catalog list operation closed");
 		this.params = void 0;
 		for (const host of this.locals) {
-			host.page.close();
+			if (!host.background) host.page.close();
 			if (!host.value) host.completion.reject(reason);
 		}
 		this.locals = [];
 		this.prepared = void 0;
 		this.nodeHosts = void 0;
+		this.nodeResults = [];
 		this.failure = void 0;
 	}
 };
@@ -1082,6 +1089,87 @@ async function listCodexSessionCatalog(params) {
 	return { hosts: await runCatalogListInline(createCodexSessionCatalogListOperation(params)) };
 }
 //#endregion
+//#region extensions/codex/src/app-server/thread-history-page.ts
+const TURN_ITEM_CURSOR_PREFIX = "turn-item:";
+function encodeTurnItemCursor(turnCursor, itemId) {
+	return TURN_ITEM_CURSOR_PREFIX + Buffer.from(JSON.stringify([turnCursor, itemId])).toString("base64url");
+}
+function decodeTurnItemCursor(cursor) {
+	if (!cursor?.startsWith(TURN_ITEM_CURSOR_PREFIX)) return { turnCursor: cursor };
+	let value;
+	try {
+		value = JSON.parse(Buffer.from(cursor.slice(10), "base64url").toString());
+	} catch {
+		throw new CatalogParamsError("invalid Codex transcript item cursor");
+	}
+	if (!Array.isArray(value) || value.length !== 2 || typeof value[0] !== "string" || !value[0] || typeof value[1] !== "string" || !value[1]) throw new CatalogParamsError("invalid Codex transcript item cursor");
+	return {
+		turnCursor: value[0],
+		itemId: value[1]
+	};
+}
+/** Legacy stores expose only turn cursors; an item identity preserves paging across appends. */
+async function readLegacyCodexHistoryPage(readTurns, request, projection) {
+	const { turnCursor, itemId } = decodeTurnItemCursor(request.cursor);
+	const page = parseTranscriptPage(await readTurns({
+		threadId: request.threadId,
+		limit: 1,
+		sortDirection: "desc",
+		itemsView: "full",
+		...turnCursor ? { cursor: turnCursor } : {}
+	}));
+	const source = page.data.flatMap(({ items, ...turn }) => items.toReversed().map((item) => ({
+		turnId: turn.id,
+		item,
+		turn
+	})));
+	const anchorIndex = itemId ? source.findIndex(({ item }) => item.id === itemId) : -1;
+	if (itemId && anchorIndex < 0) throw new CatalogParamsError("Codex transcript changed; refresh the session before loading older items");
+	const remaining = source.slice(anchorIndex + 1);
+	const items = projection.project(remaining.slice(0, request.limit), request.limit);
+	const result = () => {
+		const lastSource = remaining[items.length - 1];
+		const partial = lastSource !== void 0 && items.length < remaining.length;
+		const nativeCursor = partial ? page.backwardsCursor : page.nextCursor;
+		const cursor = nativeCursor ? partial ? encodeTurnItemCursor(nativeCursor, lastSource.item.id) : nativeCursor : void 0;
+		if (partial && !cursor) throw new Error("Codex app-server did not provide a transcript continuation anchor");
+		return {
+			items,
+			...cursor ? { nextCursor: cursor } : {}
+		};
+	};
+	let bounded = result();
+	while (!projection.fits(bounded)) {
+		if (items.length <= 1) throw new Error("Codex transcript item exceeds the safe response size");
+		items.pop();
+		bounded = result();
+	}
+	return bounded;
+}
+/** Callers authorize the thread; this reader owns native cursor and response-size semantics. */
+async function readCodexThreadHistoryPage(control, thread, request, projection) {
+	if (thread.historyMode !== "paginated") return readLegacyCodexHistoryPage((params) => control.listTurnPage(params), request, projection);
+	let limit = request.limit;
+	for (;;) {
+		const page = await control.listItemPage({
+			threadId: request.threadId,
+			limit,
+			sortDirection: "desc",
+			...request.cursor ? { cursor: request.cursor } : {}
+		});
+		const nextCursor = readControlCursor(page.nextCursor, "transcript next response");
+		const items = projection.project(page.data, limit);
+		const result = {
+			items,
+			...nextCursor ? { nextCursor } : {}
+		};
+		const fittingCount = items.length - (projection.fits(result) ? 0 : 1);
+		if (fittingCount === page.data.length) return result;
+		if (fittingCount < 1) throw new Error("Codex transcript item exceeds the safe response size");
+		limit = fittingCount;
+	}
+}
+//#endregion
 //#region extensions/codex/src/session-catalog-transcript-item.ts
 const CODEX_MESSAGE_TYPES = /* @__PURE__ */ new Map([
 	["userMessage", "userMessage"],
@@ -1135,8 +1223,8 @@ const transcriptPageSchema = z.strictObject({
 function parseCodexCatalogTranscriptPage(value) {
 	return transcriptPageSchema.parse(value);
 }
-function projectTranscriptPage(items, limit) {
-	const projected = items.map(toGenericTranscriptItem);
+function projectTranscriptPage(entries, limit) {
+	const projected = entries.map(({ item }) => toGenericTranscriptItem(item));
 	const page = sessionCatalogPaging.boundTranscriptPage(projected.toReversed(), limit, 0).items;
 	for (const [index, item] of page.entries()) if (item.text !== projected[index]?.text && projected[index]?.text) item.truncated = true;
 	return page;
@@ -1147,15 +1235,14 @@ function pageFitsNodeTransport(page) {
 /** The legacy API can anchor a turn, but cannot continue within that turn. */
 async function readLegacyCodexTranscriptPage(readTurns, request) {
 	return readLegacyCodexHistoryPage(readTurns, request, {
-		project: (entries, limit) => projectTranscriptPage(entries.map(({ item }) => item), limit),
+		project: projectTranscriptPage,
 		fits: pageFitsNodeTransport
 	});
 }
 /** Uses the native store's item cursor whenever that store supports item history. */
 async function readCodexCatalogTranscriptPage(control, request) {
-	const thread = await control.requireEligibleThread(request.threadId);
-	return readCodexThreadHistoryPage(control, thread, request, {
-		project: (entries, limit) => projectTranscriptPage(entries.map(({ item }) => item), limit),
+	return readCodexThreadHistoryPage(control, await control.requireEligibleThread(request.threadId), request, {
+		project: projectTranscriptPage,
 		fits: pageFitsNodeTransport
 	});
 }
@@ -1167,19 +1254,42 @@ function createCodexSessionCatalogNodeHostCommands(controlFactory, bindingStore)
 		const parsed = parseJsonParams(paramsJSON);
 		if (!isRecord(parsed)) throw new CatalogParamsError("Codex session catalog parameters must be an object");
 		const agentId = readBoundedOptionalString(parsed, "agentId", 256);
+		const sourceHomeId = readBoundedOptionalString(parsed, "sourceHomeId", 256);
+		const source = await controlFactory.forNode(agentId);
+		if (sourceHomeId && sourceHomeId !== source.sourceHomeId) throw new CatalogParamsError("Codex catalog source home changed. Reopen the session from the catalog.");
 		const request = { ...parsed };
 		delete request.agentId;
+		delete request.sourceHomeId;
 		return {
-			...await controlFactory.forNode(agentId),
+			...source,
 			params: request,
 			paramsJSON: JSON.stringify(request)
 		};
 	};
+	const transcriptCommand = (command, read) => ({
+		command,
+		cap: CODEX_APP_SERVER_THREADS_CAPABILITY,
+		dangerous: false,
+		hasActiveWork: controlFactory.hasActiveWork,
+		onDisconnect: controlFactory.disconnect,
+		handle: async (paramsJSON) => {
+			const request = await bindRequest(paramsJSON);
+			const action = readNodeTranscriptParams(request.params);
+			try {
+				return JSON.stringify(await read(request.control, action));
+			} catch (error) {
+				if (error instanceof CatalogParamsError) throw error;
+				throw new Error("Codex app-server transcript is unavailable", { cause: error });
+			}
+		}
+	});
 	const commands = [
 		{
 			command: CODEX_APP_SERVER_THREADS_LIST_COMMAND,
 			cap: CODEX_APP_SERVER_THREADS_CAPABILITY,
 			dangerous: false,
+			hasActiveWork: controlFactory.hasActiveWork,
+			onDisconnect: controlFactory.disconnect,
 			handle: async (paramsJSON) => {
 				const request = await bindRequest(paramsJSON);
 				const pageParams = readPageParams(request.params);
@@ -1202,50 +1312,27 @@ function createCodexSessionCatalogNodeHostCommands(controlFactory, bindingStore)
 						} } : {},
 						searchTerm: pageParams.searchTerm
 					});
-					return JSON.stringify(page);
+					return JSON.stringify({
+						...page,
+						sourceHomeId: request.sourceHomeId,
+						canContinueCodex: request.transport === "stdio"
+					});
 				} catch {
 					throw new Error("Codex app-server catalog is unavailable");
 				}
 			}
 		},
-		{
-			command: CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND,
-			cap: CODEX_APP_SERVER_THREADS_CAPABILITY,
-			dangerous: false,
-			handle: async (paramsJSON) => {
-				const request = await bindRequest(paramsJSON);
-				const action = readNodeTranscriptParams(request.params);
-				try {
-					await request.control.requireEligibleThread(action.threadId);
-					const page = parseTranscriptPage(await request.control.listTurnPage({
-						threadId: action.threadId,
-						limit: action.limit,
-						sortDirection: "desc",
-						itemsView: "full",
-						...action.cursor ? { cursor: action.cursor } : {}
-					}));
-					return JSON.stringify(page);
-				} catch (error) {
-					if (error instanceof CatalogParamsError) throw error;
-					throw new Error("Codex app-server transcript is unavailable", { cause: error });
-				}
-			}
-		},
-		{
-			command: CODEX_CATALOG_TRANSCRIPT_READ_COMMAND,
-			cap: CODEX_APP_SERVER_THREADS_CAPABILITY,
-			dangerous: false,
-			handle: async (paramsJSON) => {
-				const request = await bindRequest(paramsJSON);
-				const action = readNodeTranscriptParams(request.params);
-				try {
-					return JSON.stringify(await readCodexCatalogTranscriptPage(request.control, action));
-				} catch (error) {
-					if (error instanceof CatalogParamsError) throw error;
-					throw new Error("Codex app-server transcript is unavailable", { cause: error });
-				}
-			}
-		},
+		transcriptCommand(CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND, async (control, action) => {
+			await control.requireEligibleThread(action.threadId);
+			return parseTranscriptPage(await control.listTurnPage({
+				threadId: action.threadId,
+				limit: action.limit,
+				sortDirection: "desc",
+				itemsView: "full",
+				...action.cursor ? { cursor: action.cursor } : {}
+			}));
+		}),
+		transcriptCommand(CODEX_CATALOG_TRANSCRIPT_READ_COMMAND, readCodexCatalogTranscriptPage),
 		createCodexTerminalNodeHostCommand(bindRequest),
 		createCodexTerminalStartNodeHostCommand()
 	];
@@ -1263,19 +1350,14 @@ function readNodeTranscriptParams(value) {
 	const cursor = readBoundedOptionalString(value, "cursor", MAX_CURSOR_LENGTH);
 	return {
 		threadId,
-		limit: readBoundedLimit(value.limit, "limit", 20, 50),
+		limit: normalizeLimit(value.limit, "limit", 20, 50),
 		...cursor ? { cursor } : {}
 	};
 }
-function readBoundedLimit(value, key, fallback, max) {
-	if (value === void 0) return fallback;
-	if (!Number.isInteger(value) || value < 1 || value > max) throw new CatalogParamsError(`${key} must be an integer from 1 to ${max}`);
-	return value;
-}
 /** Reads the persisted transcript for a Gateway-local or paired-node Codex session. */
 async function readCodexSessionTranscript(params) {
 	const cursor = readControlCursor(params.cursor, "transcript request");
-	const limit = readBoundedLimit(params.limit, "limit", 20, 50);
+	const limit = normalizeLimit(params.limit, "limit", 20, 50);
 	if (params.source || params.hostId === "gateway:local") {
 		const page = await readCodexCatalogTranscriptPage(params.control, {
 			threadId: params.threadId,
@@ -1298,6 +1380,7 @@ async function readCodexSessionTranscript(params) {
 		params: {
 			agentId: params.agentId,
 			threadId: params.threadId,
+			...params.sourceHomeId ? { sourceHomeId: params.sourceHomeId } : {},
 			...request
 		},
 		timeoutMs: NODE_INVOKE_TIMEOUT_MS,
@@ -1314,7 +1397,7 @@ async function readCodexSessionTranscript(params) {
 		cursor,
 		limit
 	});
-	const { nodeLabel } = await import("./session-catalog-node-continue-Dowv8osw.mjs");
+	const { nodeLabel } = await import("./session-catalog-node-continue-DjKXHBbi.mjs");
 	return {
 		hostId: params.hostId,
 		label: nodeLabel(node),
@@ -1330,7 +1413,7 @@ function readMarker(probe) {
 	const turnId = probe.marker.turnId;
 	if (turnId !== null && typeof turnId !== "string") return;
 	const count = probe.marker.userMessageCount;
-	if (count !== void 0 && (!Number.isSafeInteger(count) || count < 0)) return;
+	if (count !== void 0 && (typeof count !== "number" || !Number.isSafeInteger(count) || count < 0)) return;
 	return {
 		turnId,
 		...count === void 0 ? {} : { userMessageCount: count }
@@ -1346,7 +1429,7 @@ function classifyCodexUpstreamTurns(params) {
 	if (!newest?.id) return;
 	const markerIndex = marker.turnId === null ? -1 : params.turns.findIndex((turn) => turn.id === marker.turnId);
 	const candidateTurns = markerIndex < 0 ? params.turns : params.turns.slice(0, markerIndex + 1);
-	const newestUserMessageCount = countUserMessages(newest);
+	const newestUserMessageCount = newest.items.filter((item) => item.type === "userMessage").length;
 	if (!(marker.turnId !== newest.id || marker.userMessageCount === void 0 || newestUserMessageCount > marker.userMessageCount)) return;
 	const ownTexts = new Set(params.probe.ownRecentUserTexts);
 	let humanTurns = 0;
@@ -1379,9 +1462,6 @@ function classifyCodexUpstreamTurns(params) {
 		} : {}
 	};
 }
-function countUserMessages(turn) {
-	return turn.items.filter((item) => item.type === "userMessage").length;
-}
 function normalizeUserMessageTexts(item) {
 	const typed = item;
 	const contentTexts = typed.content?.filter((input) => input.type === "text").map((input) => input.text.trim().replace(/\s+/g, " ")).filter(Boolean);
@@ -1400,9 +1480,11 @@ async function checkCodexUpstreamActivity(probes, control, resolveThreadId = (pr
 					limit: CODEX_UPSTREAM_TURN_LIMIT,
 					sortDirection: "desc",
 					itemsView: "full"
+				}).catch((error) => {
+					if (error instanceof CodexAppServerRpcError && error.code === -32600) return;
+					throw error;
 				});
-				const marker = readMarker(probe);
-				if (page.data.length === 0 && marker) {
+				if (!page?.data.length && readMarker(probe)) {
 					try {
 						await pinned.readThread(threadId, false);
 					} catch (error) {
@@ -1413,7 +1495,7 @@ async function checkCodexUpstreamActivity(probes, control, resolveThreadId = (pr
 					}
 					continue;
 				}
-				const activity = classifyCodexUpstreamTurns({
+				const activity = page && classifyCodexUpstreamTurns({
 					probe,
 					turns: page.data
 				});
@@ -1479,8 +1561,8 @@ async function requireEligibleCodexThread(params) {
 		remaining();
 		if (thread.id !== threadId || thread.ephemeral === true || !isInteractiveThreadSource(thread.source)) throw unverified();
 		if (!root) {
-			const { CODEX_CATALOG_NATIVE_PAGE_LIMIT } = await import("./session-catalog-native-projection-ChV3cCtm.mjs").then((n) => n.i);
-			const { CODEX_CATALOG_MAX_ROWS } = await import("./session-catalog-native-projection-ChV3cCtm.mjs").then((n) => n.U);
+			const { CODEX_CATALOG_NATIVE_PAGE_LIMIT } = await import("./session-catalog-native-projection-DjhwGL6x.mjs").then((n) => n.a);
+			const { CODEX_CATALOG_MAX_ROWS } = await import("./session-catalog-limits-DDxOsQeC.mjs").then((n) => n.r);
 			let cursor;
 			const seenCursors = /* @__PURE__ */ new Set();
 			for (;;) {
@@ -1522,6 +1604,91 @@ async function requireEligibleCodexThread(params) {
 	return await withTimeout(verify(), requests.requestTimeoutMs, "Codex session eligibility could not be verified", unverified);
 }
 //#endregion
+//#region extensions/codex/src/session-catalog-control-requests.ts
+function createCodexCatalogRequestSnapshot(requestTimeoutMs, request, index, beginList, catalogRead = false) {
+	const read = (method, params, timeoutMs, observation) => {
+		const scope = catalogRead ? void 0 : currentCodexCatalogListRequest();
+		if (!scope) return request(method, params, timeoutMs, void 0, observation);
+		return scope.read(timeoutMs ?? requestTimeoutMs, async (remaining) => {
+			const attempt = beginList(scope);
+			if (!attempt.allowed) throw attempt.error;
+			return await request(method, params, remaining, void 0, observation);
+		});
+	};
+	return {
+		index,
+		beginList,
+		get requestTimeoutMs() {
+			return catalogRead ? requestTimeoutMs : currentCodexCatalogListRequest()?.remaining(requestTimeoutMs) ?? requestTimeoutMs;
+		},
+		listThreads: (params, timeoutMs, observation) => read(CODEX_CONTROL_METHODS.listThreads, params, timeoutMs, observation),
+		listThreadTurns: (params) => read(CODEX_CONTROL_METHODS.listThreadTurns, params),
+		listThreadItems: (params) => read(CODEX_CONTROL_METHODS.listThreadItems, params),
+		forkThread: (params, assertCurrent) => request(CODEX_CONTROL_METHODS.forkThread, assertCodexThreadForkParams(params), void 0, assertCurrent),
+		readThread: async (threadId, includeTurns, timeoutMs) => (await read(CODEX_CONTROL_METHODS.readThread, {
+			threadId,
+			includeTurns
+		}, timeoutMs)).thread,
+		archiveThread: async (threadId, assertCurrent) => {
+			await request(CODEX_CONTROL_METHODS.archiveThread, { threadId }, void 0, assertCurrent);
+		}
+	};
+}
+function createCodexSessionCatalogControlFromRequests(params) {
+	return {
+		forkContext: params.forkContext,
+		...params.clientId ? { clientId: params.clientId } : {},
+		...params.connectionFingerprint ? { connectionFingerprint: params.connectionFingerprint } : {},
+		withPinnedConnection: params.withPinnedConnection,
+		async initialize() {
+			await (await params.createRequestSnapshot().index()).initialize();
+		},
+		requireEligibleThread: (threadId) => requireEligibleCodexThread({
+			threadId,
+			requests: params.createRequestSnapshot(),
+			localSessionsRoot: params.localSessionsRoot,
+			sourceHomeId: params.sourceHomeId,
+			managedThreads: params.managedThreads,
+			now: params.now
+		}),
+		retireConnection: params.retireConnection,
+		async listPage(pageParams) {
+			readControlCursor(pageParams.cursor, "request");
+			const query = readPageParams(pageParams);
+			return await withCodexCatalogListRequest(async (request) => {
+				const requests = params.createRequestSnapshot();
+				const timeoutMs = Math.min(requests.requestTimeoutMs, 5e3);
+				const deadline = request.constrainDeadline(performance.now() + timeoutMs);
+				return await (await withTimeout(requests.index(), request.remaining(timeoutMs), "Codex session catalog is still loading", () => new CodexCatalogLoadingError())).list(query, deadline);
+			});
+		},
+		async listDescendantPage(listParams) {
+			const requests = params.createRequestSnapshot();
+			return await requests.listThreads(listParams, requests.requestTimeoutMs);
+		},
+		async readThread(threadId, includeTurns = false) {
+			return await params.createRequestSnapshot().readThread(threadId, includeTurns);
+		},
+		async listTurnPage(listParams) {
+			return await params.createRequestSnapshot().listThreadTurns(listParams);
+		},
+		listItemPage: (listParams) => params.createRequestSnapshot().listThreadItems(listParams),
+		async forkThread(forkParams, assertCurrent) {
+			const requests = params.createRequestSnapshot();
+			const index = forkParams.ephemeral === true ? void 0 : await requests.index();
+			const response = await requests.forkThread(forkParams, assertCurrent);
+			if (index && !index.get(response.thread.id)) await index.upsertThread(response.thread);
+			return response;
+		},
+		async archiveThread(threadId, assertCurrent) {
+			const requests = params.createRequestSnapshot();
+			const index = await requests.index();
+			await requests.archiveThread(threadId, assertCurrent);
+			index.archive(threadId);
+		}
+	};
+}
+//#endregion
 //#region extensions/codex/src/session-catalog-homes.ts
 /** Discovers path facts on demand; runtime projections belong only to their requesting owner. */
 function createCodexCatalogHomeResolver(params) {
@@ -1560,7 +1727,7 @@ function createCodexCatalogHomeResolver(params) {
 		const cached = snapshot.paths.get(value);
 		if (cached !== void 0) return cached;
 		const resolved = path.resolve(value);
-		const discovery = fs.realpath(resolved).catch(() => resolved).then(async (canonical) => {
+		const discovery = canonicalPathFromExistingAncestor(resolved).catch(() => resolved).then(async (canonical) => {
 			if (await fs.stat(canonical).then((stat) => stat.isDirectory(), () => false)) snapshot.directories.add(value);
 			snapshot.paths.set(value, canonical);
 			return canonical;
@@ -1582,7 +1749,8 @@ function createCodexCatalogHomeResolver(params) {
 		};
 		for (const id of agentIds(snapshot)) {
 			await scheduler.yield();
-			await append(resolveCodexAppServerHomeDir(agentDir(snapshot, id)), id);
+			const directory = await homePath(snapshot, agentDir(snapshot, id));
+			await append(resolveCodexAppServerHomeDir(directory), id);
 			if (candidates.length === 100) return candidates;
 		}
 		for (const entry of readCodexPluginConfig(snapshot.pluginConfig).sessionCatalog?.homes ?? []) {
@@ -1600,7 +1768,7 @@ function createCodexCatalogHomeResolver(params) {
 		await scheduler.yield();
 		snapshot.assertCurrent();
 		if (!agentIds(snapshot).includes(agentId)) return [];
-		const ownerAgentDir = agentDir(snapshot, agentId);
+		const ownerAgentDir = await homePath(snapshot, agentDir(snapshot, agentId));
 		const base = params.resolveRuntimeOptions({
 			config: snapshot.config,
 			pluginConfig: snapshot.pluginConfig,
@@ -1641,15 +1809,18 @@ function createCodexCatalogHomeResolver(params) {
 				hostId: primary ? CODEX_LOCAL_SESSION_HOST_ID : `${CODEX_LOCAL_SESSION_HOST_ID}:${sourceHomeId}`,
 				label: candidate.label,
 				agentDir: ownerAgentDir,
-				appServer: primary ? base : {
+				appServer: base.start.transport !== "stdio" ? base : {
 					...base,
 					start: {
 						...base.start,
-						homeScope: "user",
-						env: {
-							...base.start.env,
-							CODEX_HOME: candidate.codexHome
-						}
+						codexHome: candidate.codexHome,
+						...!primary ? {
+							homeScope: "user",
+							env: {
+								...base.start.env,
+								CODEX_HOME: candidate.codexHome
+							}
+						} : {}
 					}
 				},
 				...base.connectionClass === "remote" ? {} : { localSessionsRoot: path.join(candidate.codexHome, "sessions") },
@@ -1752,7 +1923,7 @@ var CodexCatalogSourceBackoff = class {
 					if (failure) failure.probing = false;
 					return;
 				}
-				const delayMs = failure ? Math.min(failure.delayMs * 2 || INITIAL_BACKOFF_MS, MAX_BACKOFF_MS) : 0;
+				const delayMs = findCodexAppServerSpawnError(error) ? Infinity : failure ? Math.min(failure.delayMs * 2 || INITIAL_BACKOFF_MS, MAX_BACKOFF_MS) : 0;
 				sources.set(key, { failure: {
 					error,
 					delayMs,
@@ -1768,127 +1939,66 @@ var CodexCatalogSourceBackoff = class {
 };
 //#endregion
 //#region extensions/codex/src/session-catalog-control.ts
-function createCodexCatalogRequestSnapshot(requestTimeoutMs, request, index, beginList, catalogRead = false) {
-	const read = (method, params, timeoutMs, observation) => {
-		const scope = catalogRead ? void 0 : currentCodexCatalogListRequest();
-		if (!scope) return request(method, params, timeoutMs, void 0, observation);
-		return scope.read(timeoutMs ?? requestTimeoutMs, async (remaining) => {
-			const attempt = beginList(scope);
-			if (!attempt.allowed) throw attempt.error;
-			return await request(method, params, remaining, void 0, observation);
-		});
-	};
-	return {
-		index,
-		beginList,
-		get requestTimeoutMs() {
-			return catalogRead ? requestTimeoutMs : currentCodexCatalogListRequest()?.remaining(requestTimeoutMs) ?? requestTimeoutMs;
-		},
-		listThreads: (params, timeoutMs, observation) => read(CODEX_CONTROL_METHODS.listThreads, params, timeoutMs, observation),
-		listThreadTurns: (params) => read(CODEX_CONTROL_METHODS.listThreadTurns, params),
-		listThreadItems: (params) => read(CODEX_CONTROL_METHODS.listThreadItems, params),
-		forkThread: (params, assertCurrent) => request(CODEX_CONTROL_METHODS.forkThread, assertCodexThreadForkParams(params), void 0, assertCurrent),
-		readThread: async (threadId, includeTurns, timeoutMs) => (await read(CODEX_CONTROL_METHODS.readThread, {
-			threadId,
-			includeTurns
-		}, timeoutMs)).thread,
-		archiveThread: async (threadId, assertCurrent) => {
-			await request(CODEX_CONTROL_METHODS.archiveThread, { threadId }, void 0, assertCurrent);
-		}
-	};
-}
-function createCodexSessionCatalogControlFromRequests(params) {
-	return {
-		forkContext: params.forkContext,
-		...params.clientId ? { clientId: params.clientId } : {},
-		...params.connectionFingerprint ? { connectionFingerprint: params.connectionFingerprint } : {},
-		withPinnedConnection: params.withPinnedConnection,
-		async initialize() {
-			await (await params.createRequestSnapshot().index()).initialize();
-		},
-		requireEligibleThread: (threadId) => requireEligibleCodexThread({
-			threadId,
-			requests: params.createRequestSnapshot(),
-			localSessionsRoot: params.localSessionsRoot,
-			sourceHomeId: params.sourceHomeId,
-			managedThreads: params.managedThreads,
-			now: params.now
-		}),
-		retireConnection: params.retireConnection,
-		async listPage(pageParams) {
-			readControlCursor(pageParams.cursor, "request");
-			const query = readPageParams(pageParams);
-			return await withCodexCatalogListRequest(async (request) => {
-				const requests = params.createRequestSnapshot();
-				const deadline = request.deadline(requests.requestTimeoutMs);
-				return await (await withTimeout(requests.index(), request.remaining(requests.requestTimeoutMs), "Codex session catalog is still loading", () => new CodexCatalogLoadingError())).list(query, deadline);
-			});
-		},
-		async listDescendantPage(listParams) {
-			const requests = params.createRequestSnapshot();
-			return await requests.listThreads(listParams, requests.requestTimeoutMs);
-		},
-		async readThread(threadId, includeTurns = false) {
-			return await params.createRequestSnapshot().readThread(threadId, includeTurns);
-		},
-		async listTurnPage(listParams) {
-			return await params.createRequestSnapshot().listThreadTurns(listParams);
-		},
-		listItemPage: (listParams) => params.createRequestSnapshot().listThreadItems(listParams),
-		async forkThread(forkParams, assertCurrent) {
-			const requests = params.createRequestSnapshot();
-			const index = forkParams.ephemeral === true ? void 0 : await requests.index();
-			const response = await requests.forkThread(forkParams, assertCurrent);
-			if (index && !index.get(response.thread.id)) await index.upsertThread(response.thread);
-			return response;
-		},
-		async archiveThread(threadId, assertCurrent) {
-			const requests = params.createRequestSnapshot();
-			const index = await requests.index();
-			await requests.archiveThread(threadId, assertCurrent);
-			index.archive(threadId);
-		}
-	};
-}
 /** Builds the passive catalog over the Codex plugin's canonical shared client. */
 function createCodexSessionCatalogControl(params) {
 	const now = params.now ?? Date.now;
 	const sourceBackoff = new CodexCatalogSourceBackoff(now);
 	const noConfig = {};
-	const getPluginConfig = () => params.getPluginConfig();
+	const resolveRuntimeOptions = (options) => {
+		const runtime = params.resolveRuntimeOptions(options);
+		return runtime.start.transport === "stdio" && runtime.start.commandSource === "managed" ? {
+			...runtime,
+			start: {
+				...runtime.start,
+				managedCommandOrder: "package-only"
+			}
+		} : runtime;
+	};
 	const homeResolver = createCodexCatalogHomeResolver({
 		config: params.config ?? {},
 		getRuntimeConfig: params.getRuntimeConfig,
 		getPluginConfig: params.getPluginConfig,
-		resolveRuntimeOptions: params.resolveRuntimeOptions,
+		resolveRuntimeOptions,
 		...params.env ? { env: params.env } : {}
 	});
 	const requestOptionsByConfig = /* @__PURE__ */ new WeakMap();
 	const indexes = /* @__PURE__ */ new Map();
 	const retiringState = /* @__PURE__ */ new Map();
 	const directHomes = /* @__PURE__ */ new Map();
+	const residentRequests = /* @__PURE__ */ new Set();
 	let generation = params.getRuntimeConfig();
+	let residentEpoch = 0;
+	let starting = 0;
 	let closed = false;
 	let runBackground = (run) => run();
-	let retiring = Promise.resolve();
-	const residentFor = async (agentId, source) => {
+	let retiring;
+	const retireIndexes = () => {
+		residentEpoch++;
+		const closing = [];
+		for (const [homeId, index] of indexes) {
+			const writes = index.retire().finally(() => {
+				if (retiringState.get(homeId) === writes) retiringState.delete(homeId);
+			});
+			retiringState.set(homeId, writes);
+			closing.push(writes, index.close());
+		}
+		indexes.clear();
+		directHomes.clear();
+		const drain = Promise.allSettled([retiring, ...closing]).then(() => {
+			if (retiring === drain) retiring = void 0;
+		});
+		retiring = drain;
+		return drain;
+	};
+	const resolveResident = async (agentId, source) => {
 		if (closed) throw new Error("Codex resident catalog is closed");
 		const config = params.getRuntimeConfig();
 		if (generation !== config) {
 			generation = config;
-			const closing = [];
-			for (const [homeId, index] of indexes) {
-				const writes = index.retire().finally(() => {
-					if (retiringState.get(homeId) === writes) retiringState.delete(homeId);
-				});
-				retiringState.set(homeId, writes);
-				closing.push(writes, index.close());
-			}
-			retiring = Promise.allSettled([retiring, ...closing]).then(() => void 0);
-			indexes.clear();
-			directHomes.clear();
+			retireIndexes();
 		}
-		const runtime = source?.appServer ?? params.resolveRuntimeOptions({ pluginConfig: getPluginConfig() });
+		const epoch = residentEpoch;
+		const runtime = source?.appServer ?? resolveRuntimeOptions({ pluginConfig: params.getPluginConfig() });
 		const requestOptions = resolveRequestOptions(runtime.start, agentId, source);
 		const key = source?.sourceHomeId ?? agentId ?? "";
 		let home = directHomes.get(key);
@@ -1902,12 +2012,12 @@ function createCodexSessionCatalogControl(params) {
 		}
 		const homeId = await home;
 		await retiringState.get(homeId);
-		if (closed || generation !== config) throw new Error("Codex catalog configuration changed");
+		if (closed || generation !== config || residentEpoch !== epoch) throw new Error("Codex catalog configuration changed");
 		let index = indexes.get(homeId);
 		if (!index) {
-			const [{ CodexCatalogIndex }, { canReuseCodexCatalogPreview, projectCodexCatalogDeltaPage, projectCodexCatalogPage }] = await Promise.all([import("./session-catalog-index-B141u15s.mjs"), import("./session-catalog-projection-C1Bj9Jl-.mjs")]);
+			const [{ CodexCatalogIndex }, { canReuseCodexCatalogPreview, projectCodexCatalogDeltaPage, projectCodexCatalogPage }] = await Promise.all([import("./session-catalog-index-CZvDzC6z.mjs"), import("./session-catalog-projection-Cr5qP5Dj.mjs")]);
 			source?.assertCurrent();
-			if (closed || generation !== config) throw new Error("Codex catalog configuration changed");
+			if (closed || generation !== config || residentEpoch !== epoch) throw new Error("Codex catalog configuration changed");
 			index = indexes.get(homeId);
 			if (index) return index;
 			const root = source?.localSessionsRoot ?? (runtime.connectionClass !== "remote" ? path.join(resolveCodexAppServerLocalHomeDir(requestOptions.startOptions, requestOptions.agentDir, params.env), "sessions") : void 0);
@@ -1940,17 +2050,9 @@ function createCodexSessionCatalogControl(params) {
 					const page = await project(response, diagnostics);
 					foreground?.assertActive();
 					outcome = "resolved";
-					if (!foreground && !page.nextCursor) {
-						attempt.resolved();
-						nativeAttempt = void 0;
-					}
 					return page;
 				} catch (error) {
 					observation?.rejected();
-					if (!foreground) {
-						attempt.rejected(error);
-						nativeAttempt = void 0;
-					}
 					throw error;
 				} finally {
 					observation?.close();
@@ -1963,9 +2065,21 @@ function createCodexSessionCatalogControl(params) {
 				runBackground: (run) => runBackground(run),
 				localSessionsRoot: root,
 				state: params.openResidentState?.(homeId),
+				runNativeWalk: async (run) => {
+					try {
+						const result = await run();
+						if (nativeAttempt?.allowed) nativeAttempt.resolved();
+						return result;
+					} catch (error) {
+						if (nativeAttempt?.allowed) nativeAttempt.rejected(error);
+						throw error;
+					} finally {
+						nativeAttempt = void 0;
+					}
+				},
 				assertCurrent: () => {
 					source?.assertCurrent();
-					if (closed || params.getRuntimeConfig() !== config) throw new Error("Codex catalog configuration changed");
+					if (closed || params.getRuntimeConfig() !== config || residentEpoch !== epoch) throw new Error("Codex catalog configuration changed");
 				},
 				readNative: (query, remainingRows, foreground) => readNativePage(query, Math.min(64, remainingRows), async (response, diagnostics) => {
 					const { sanitizeTerminalText } = await import("openclaw/plugin-sdk/text-chunking");
@@ -1988,6 +2102,13 @@ function createCodexSessionCatalogControl(params) {
 		}
 		return index;
 	};
+	const residentFor = (agentId, source) => {
+		const request = resolveResident(agentId, source);
+		residentRequests.add(request);
+		const release = () => residentRequests.delete(request);
+		request.then(release, release);
+		return request;
+	};
 	const resolveRequestOptions = (startOptions, agentId, source) => {
 		source?.assertCurrent();
 		const runtimeConfig = params.getRuntimeConfig();
@@ -2015,11 +2136,11 @@ function createCodexSessionCatalogControl(params) {
 		return resolved;
 	};
 	const createRequestSnapshot = (agentId, source, catalogPreview, catalogPreviewCache, catalogRows) => {
-		const pluginConfig = getPluginConfig();
-		const runtime = source?.appServer ?? params.resolveRuntimeOptions({ pluginConfig });
+		const pluginConfig = params.getPluginConfig();
+		const runtime = source?.appServer ?? resolveRuntimeOptions({ pluginConfig });
 		const requestOptions = resolveRequestOptions(runtime.start, agentId, source);
 		return createCodexCatalogRequestSnapshot(runtime.requestTimeoutMs, async (method, requestParams, timeoutMs, assertCurrent, observation) => {
-			const { codexControlRequest } = await import("./command-rpc-DHFpn4le.mjs").then((n) => n.n);
+			const { codexControlRequest } = await import("./command-rpc-CGJGUQ6Y.mjs").then((n) => n.n);
 			return await codexControlRequest(pluginConfig, method, requestParams, {
 				...requestOptions,
 				authProfileId: null,
@@ -2037,13 +2158,13 @@ function createCodexSessionCatalogControl(params) {
 	const forRequest = (agentId, source) => {
 		source?.assertCurrent();
 		const withPinnedConnection = async (run) => {
-			const pluginConfig = getPluginConfig();
-			const runtime = source?.appServer ?? params.resolveRuntimeOptions({ pluginConfig });
+			const pluginConfig = params.getPluginConfig();
+			const runtime = source?.appServer ?? resolveRuntimeOptions({ pluginConfig });
 			const { agentDir, config: runtimeConfig, startOptions } = resolveRequestOptions(runtime.start, agentId, source);
 			let catalogIndex;
-			const { getLeasedSharedCodexAppServerClient, releaseLeasedSharedCodexAppServerClient, retireSharedCodexAppServerClientIfCurrent } = await import("./shared-client-BpTtuLQ5.mjs").then((n) => n.y);
-			const { resolveCodexAppServerClientInstanceId } = await import("./client-vXs2929Q.mjs").then((n) => n.n);
-			const { requestCodexAppServerClientJson } = await import("./request-BioXJLYa.mjs").then((n) => n.a);
+			const { getLeasedSharedCodexAppServerClient, releaseLeasedSharedCodexAppServerClient, retireSharedCodexAppServerClientIfCurrent } = await import("./shared-client-DqyTMYug.mjs").then((n) => n.v);
+			const { resolveCodexAppServerClientInstanceId } = await import("./client-N0JpgSzF.mjs").then((n) => n.n);
+			const { requestCodexAppServerClientJson } = await import("./request-BHZ1nz8d.mjs").then((n) => n.a);
 			const client = await getLeasedSharedCodexAppServerClient({
 				agentDir,
 				config: runtimeConfig,
@@ -2106,20 +2227,37 @@ function createCodexSessionCatalogControl(params) {
 		return source ? forRequest(agentId, source) : void 0;
 	};
 	return {
+		hasActiveWork: () => starting > 0 || residentRequests.size > 0 || retiring !== void 0 || hasActiveSharedCodexAppServerWork() || [...indexes.values()].some((index) => index.hasActiveWork()),
+		async disconnect() {
+			await retireIndexes();
+			await Promise.allSettled(residentRequests);
+			const clients = getSharedCodexAppServerClientState();
+			if (clients.liveClients.size > 0 || clients.startup.pending.size > 0) {
+				const { clearSharedCodexAppServerClientAndWait } = await import("./shared-client-DqyTMYug.mjs").then((n) => n.v);
+				await clearSharedCodexAppServerClientAndWait();
+			}
+		},
 		async start() {
-			const serviceScope = AsyncLocalStorage.snapshot();
-			runBackground = (run) => serviceScope(run);
-			for (const agentId of listAgentIds(params.getRuntimeConfig() ?? params.config ?? {})) for (const source of await homeResolver.forAgent(agentId)) {
-				if (source.usesProcessHomeFallback) continue;
-				forRequest(agentId, source).initialize().catch((error) => embeddedAgentLog.warn("Codex catalog hydration failed", { error }));
+			const epoch = residentEpoch;
+			starting++;
+			try {
+				const serviceScope = AsyncLocalStorage.snapshot();
+				runBackground = (run) => serviceScope(run);
+				for (const agentId of listAgentIds(params.getRuntimeConfig() ?? params.config ?? {})) for (const source of await homeResolver.forAgent(agentId)) {
+					if (closed || residentEpoch !== epoch) return;
+					if (source.usesProcessHomeFallback) continue;
+					forRequest(agentId, source).initialize().catch((error) => {
+						if (!findCodexAppServerSpawnError(error)) embeddedAgentLog.warn("Codex catalog hydration failed", { error });
+					});
+				}
+			} finally {
+				starting--;
 			}
 		},
 		async stop() {
 			closed = true;
-			await Promise.allSettled([...indexes.values()].map((index) => index.close()));
-			await retiring;
-			indexes.clear();
-			directHomes.clear();
+			await retireIndexes();
+			await Promise.allSettled(residentRequests);
 		},
 		forRequest,
 		forUpstream,
@@ -2127,9 +2265,11 @@ function createCodexSessionCatalogControl(params) {
 		async forNode(agentId) {
 			const source = await homeResolver.forNode(agentId);
 			return {
+				assertCurrent: () => source.assertCurrent(),
 				control: forRequest(source.agentId, source),
 				sourceHomeId: source.sourceHomeId,
-				codexHome: source.codexHome
+				codexHome: source.codexHome,
+				transport: source.appServer.start.transport
 			};
 		}
 	};
@@ -2167,6 +2307,7 @@ function toGenericCatalogHost(host, localTerminalAvailable) {
 		label: host.label,
 		kind: host.kind,
 		connected: host.connected,
+		...host.pending ? { pending: true } : {},
 		...host.nodeId ? { nodeId: host.nodeId } : {},
 		sessions: host.sessions.map((session) => {
 			const continuableStatus = !session.archived && (session.status === "idle" || session.status === "notLoaded");
@@ -2254,15 +2395,15 @@ function withCatalogListScope(initialize) {
 }
 function catalogHostMapper(localTerminalAvailable, localHomes) {
 	return (host) => {
-		const diagnostics = currentCodexCatalogListDiagnostics();
-		const started = diagnostics ? performance.now() : 0;
+		const finishTiming = startCodexCatalogListTiming("mappingMs");
 		try {
+			const localSourceAvailable = localTerminalAvailable && localHomes.some((home) => home.hostId === host.hostId && home.appServer.start.transport === "stdio");
 			return {
-				...toGenericCatalogHost(host, localTerminalAvailable),
-				canStartTerminal: host.kind === "gateway" ? localTerminalAvailable && host.hostId === "gateway:local" && localHomes.some((home) => home.hostId === host.hostId && home.appServer.start.transport === "stdio") : host.canStartTerminal === true
+				...toGenericCatalogHost(host, localSourceAvailable),
+				canStartTerminal: host.kind === "gateway" ? localSourceAvailable && host.hostId === "gateway:local" : host.canStartTerminal === true
 			};
 		} finally {
-			if (diagnostics && !diagnostics.closed) diagnostics.fields.mappingMs = (diagnostics.fields.mappingMs ?? 0) + performance.now() - started;
+			finishTiming();
 		}
 	};
 }
@@ -2312,8 +2453,9 @@ function registerCodexSessionCatalog(params) {
 		};
 	};
 	const checkUpstreamActivity = createChecker(params);
+	const nodeSnapshots = new CodexCatalogNodeSnapshots();
 	const createListOperation = (query) => withCatalogListScope(async () => {
-		const { agentId: requestedAgentId, allowProcessHomeFallback, listNodes, onHost, waitUntil, signal, sessionEntries, ...gatewayQuery } = query;
+		const { agentId: requestedAgentId, allowProcessHomeFallback, allowPartialResults, listNodes, onHost, waitUntil, signal, sessionEntries, ...gatewayQuery } = query;
 		const agentId = resolveRequestAgentId(requestedAgentId);
 		const selectedQuery = readGatewayParams(gatewayQuery);
 		const localHomes = selectedQuery.hostIds && !selectedQuery.hostIds.some(isLocalCodexCatalogHost) ? [] : [...await catalogHomes(agentId, allowProcessHomeFallback)];
@@ -2330,6 +2472,8 @@ function registerCodexSessionCatalog(params) {
 			signal,
 			sessionEntries,
 			localHomes,
+			allowPartialResults,
+			nodeSnapshots,
 			...onHost ? { onHost: mappedHostPublisher(onHost, mapHost) } : {}
 		}), mapHost);
 	});
@@ -2348,6 +2492,7 @@ function registerCodexSessionCatalog(params) {
 				control,
 				hostId: request.hostId,
 				threadId: request.threadId,
+				sourceHomeId: request.sourceHomeId,
 				cursor: request.cursor,
 				limit: request.limit ?? 20,
 				...source ? { source } : {}
@@ -2362,6 +2507,7 @@ function registerCodexSessionCatalog(params) {
 				config,
 				hostId: request.hostId,
 				threadId: request.threadId,
+				sourceHomeId: request.sourceHomeId,
 				clientScopes: request.clientScopes
 			});
 			if (!isLocalCodexCatalogHost(request.hostId)) throw new CatalogParamsError("Codex session catalog hostId is invalid");
@@ -2449,16 +2595,16 @@ const codexSessionCatalogRuntime = {
 	archiveLocal: archiveLocalCodexSession
 };
 async function continueLocalCodexSession(...args) {
-	const { continueLocalCodexSession: run } = await import("./session-catalog-adoption-CR_whkEW.mjs");
+	const { continueLocalCodexSession: run } = await import("./session-catalog-adoption-BU_pHWG7.mjs");
 	return run(...args);
 }
 async function archiveLocalCodexSession(...args) {
-	const { archiveLocalCodexSession: run } = await import("./session-catalog-archive-CwZaPacf.mjs");
+	const { archiveLocalCodexSession: run } = await import("./session-catalog-archive-spHfihri.mjs");
 	return run(...args);
 }
 async function continueNodeCodexSession(...args) {
-	const { continueNodeCodexSession: run } = await import("./session-catalog-node-continue-Dowv8osw.mjs");
+	const { continueNodeCodexSession: run } = await import("./session-catalog-node-continue-DjKXHBbi.mjs");
 	return run(...args);
 }
 //#endregion
-export { withCodexCatalogListRequest as a, createCodexSessionCatalogNodeHostCommands as i, createCodexSessionCatalogNodeInvokePolicies as n, lookupNodeCodexCatalogRecord as o, createCodexSessionCatalogControl as r, CodexCatalogAvailability as s, codexSessionCatalogRuntime as t };
+export { createCodexSessionCatalogNodeHostCommands as i, createCodexSessionCatalogNodeInvokePolicies as n, createCodexSessionCatalogControl as r, codexSessionCatalogRuntime as t };