@openclaw/codex 2026.7.2-beta.7 → 2026.8.1-beta.3

package/dist/{shared-client-DTbvH-XV.js → shared-client-Dw-rzii0.js}

@@ -1,133 +1,46 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { _ as resolveCodexAppServerStartOptionsForAgent, g as resolveCodexAppServerRuntimeOptions, o as isCodexAppServerNativeAuthProfile, p as codexAppServerStartOptionsKey, v as resolveCodexComputerUseConfig, w as resolveCodexAppServerUserHomeDir } from "./session-binding-BXpo9ymA.js";
-import { n as resolveCodexAppServerSpawnEnv, t as createStdioTransport } from "./transport-stdio-DXgGZ7Ib.js";
-import { createRequire } from "node:module";
-import fs, { access } from "node:fs/promises";
+import { a as resolveCodexAppServerStartOptionsForAgent, i as resolveCodexAppServerRuntimeOptions, o as resolveCodexComputerUseConfig, t as codexAppServerStartOptionsKey, x as resolveCodexAppServerUserHomeDir } from "./config-CpNeo5AE.js";
+import { o as isCodexAppServerNativeAuthProfile } from "./session-binding-BTrLf9Qm.js";
+import { n as resolveCodexAppServerSpawnEnv, t as createStdioTransport } from "./transport-stdio-DhoGy33Z.js";
+import { a as CODEX_APP_SERVER_VERSION, n as resolveManagedCodexAppServerStartOptions, o as MIN_SUPPORTED_CODEX_APP_SERVER_VERSION, r as resolveManagedCodexNativeCommand } from "./managed-binary-By4FZC6i.js";
+import { isRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import fs from "node:fs/promises";
 import path from "node:path";
+import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
 import { addTimerTimeoutGraceMs, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
-import { AgentHarnessPreflightError, OPENCLAW_VERSION, embeddedAgentLog } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { AgentHarnessPreflightError, OPENCLAW_VERSION, embeddedAgentLog, formatErrorMessage } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { createHash, randomUUID } from "node:crypto";
-import { ensureAuthProfileStore, findPersistedAuthProfileCredential, loadAuthProfileStoreForSecretsRuntime, refreshOAuthCredentialForRuntime, resolveApiKeyForProfile, resolveAuthProfileOrder, resolveDefaultAgentDir, resolvePersistedAuthProfileOwnerAgentDir, resolveProviderIdForAuth } from "openclaw/plugin-sdk/agent-runtime";
-import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
-import fsSync, { constants, existsSync, readFileSync, realpathSync } from "node:fs";
+import fsSync, { constants, existsSync } from "node:fs";
 import os from "node:os";
 import { isDeepStrictEqual } from "node:util";
+import { ensureAuthProfileStore, findPersistedAuthProfileCredential, loadAuthProfileStoreForSecretsRuntime, refreshOAuthCredentialForRuntime, resolveApiKeyForProfile, resolveAuthProfileOrder, resolveDefaultAgentDir, resolvePersistedAuthProfileOwnerAgentDir, resolveProviderIdForAuth } from "openclaw/plugin-sdk/agent-runtime";
 import { hasUsableOAuthCredential } from "openclaw/plugin-sdk/provider-auth";
 import { readSecretFile } from "openclaw/plugin-sdk/secret-file";
+import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
 import { runExec } from "openclaw/plugin-sdk/process-runtime";
+import { assertNoSymlinkParents, withTimeout } from "openclaw/plugin-sdk/security-runtime";
+import { execFile } from "node:child_process";
 import { createInterface } from "node:readline";
+import { coerceErrorMessage, toStringifiedError } from "openclaw/plugin-sdk/error-runtime";
 import { sliceUtf16Safe, truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
+import { parse } from "semver";
 import { EventEmitter } from "node:events";
 import net from "node:net";
 import { PassThrough, Writable } from "node:stream";
 import { StringDecoder } from "node:string_decoder";
 import WebSocket from "ws";
-import { fileURLToPath } from "node:url";
-import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
-import { withTimeout } from "openclaw/plugin-sdk/security-runtime";
-//#region extensions/codex/src/app-server/attempt-timeouts.ts
-/**
-* Timeout defaults and normalizers for Codex app-server startup and turn
-* liveness watches.
-*/
-/** Minimum startup timeout accepted by the Codex app-server harness. */
-const CODEX_APP_SERVER_STARTUP_TIMEOUT_FLOOR_MS = 100;
-/** Default idle timeout while waiting for app-server turn completion. */
-const CODEX_TURN_COMPLETION_IDLE_TIMEOUT_MS = 6e4;
-/** Short guard after apparent assistant completion. */
-const CODEX_TURN_ASSISTANT_COMPLETION_IDLE_TIMEOUT_MS = 1e4;
-const CODEX_POST_TOOL_RAW_ASSISTANT_COMPLETION_IDLE_TIMEOUT_MS = 5 * 6e4;
-/** Guard after reasoning/commentary progress when no tool handoff occurred. */
-const CODEX_POST_REASONING_REPLY_IDLE_TIMEOUT_MS = 5 * 6e4;
-/** Long terminal idle watch for app-server turns that never send completion. */
-const CODEX_TURN_TERMINAL_IDLE_TIMEOUT_MS = 30 * 6e4;
-var CodexAppServerStartupError = class extends Error {
-	constructor(reason, message = reason === "timed_out" ? "codex app-server startup timed out" : "codex app-server startup aborted") {
-		super(message);
-		this.reason = reason;
-		this.code = "CODEX_APP_SERVER_STARTUP_CANCELLED";
-		this.name = "CodexAppServerStartupError";
-	}
-};
-function isCodexAppServerStartupError(error, reason) {
-	return error instanceof Error && "code" in error && error.code === "CODEX_APP_SERVER_STARTUP_CANCELLED" && "reason" in error && (error.reason === "aborted" || error.reason === "timed_out") && (reason === void 0 || error.reason === reason);
-}
-function resolvePositiveIntegerTimeoutMs(value, fallbackMs) {
-	return resolveTimerTimeoutMs(value, resolveTimerTimeoutMs(fallbackMs, 1));
-}
-/** Runs startup work with abort and timeout handling plus optional cleanup. */
-async function withCodexStartupTimeout(params) {
-	if (params.signal.aborted) throw new CodexAppServerStartupError("aborted");
-	let timeout;
-	let abortCleanup;
-	let timeoutError;
-	let timeoutCleanup;
-	try {
-		return await Promise.race([params.operation(), new Promise((_, reject) => {
-			const rejectOnce = (error) => {
-				if (timeout) {
-					clearTimeout(timeout);
-					timeout = void 0;
-				}
-				reject(error);
-			};
-			timeout = setTimeout(() => {
-				timeoutError = new CodexAppServerStartupError("timed_out");
-				timeoutCleanup = Promise.resolve(params.onTimeout?.()).then(() => void 0, () => void 0);
-				timeoutCleanup.finally(() => {
-					rejectOnce(timeoutError);
-				});
-			}, params.timeoutMs);
-			const abortListener = () => rejectOnce(new CodexAppServerStartupError("aborted"));
-			params.signal.addEventListener("abort", abortListener, { once: true });
-			abortCleanup = () => params.signal.removeEventListener("abort", abortListener);
-		})]);
-	} catch (error) {
-		if (timeoutError) {
-			await timeoutCleanup;
-			throw timeoutError;
-		}
-		throw error;
-	} finally {
-		if (timeout) clearTimeout(timeout);
-		abortCleanup?.();
-	}
-}
-/** Resolves startup timeout while honoring the configured floor. */
-function resolveCodexStartupTimeoutMs(params) {
-	const timeoutFloorMs = resolvePositiveIntegerTimeoutMs(params.timeoutFloorMs, CODEX_APP_SERVER_STARTUP_TIMEOUT_FLOOR_MS);
-	const timeoutMs = resolvePositiveIntegerTimeoutMs(params.timeoutMs, timeoutFloorMs);
-	return Math.max(timeoutFloorMs, timeoutMs);
-}
-/** Resolves the completion-idle timeout for an active turn. */
-function resolveCodexTurnCompletionIdleTimeoutMs(value) {
-	return resolvePositiveIntegerTimeoutMs(value, CODEX_TURN_COMPLETION_IDLE_TIMEOUT_MS);
-}
-/** Resolves the short assistant-completion release timeout. */
-function resolveCodexTurnAssistantCompletionIdleTimeoutMs(value) {
-	return resolvePositiveIntegerTimeoutMs(value, CODEX_TURN_ASSISTANT_COMPLETION_IDLE_TIMEOUT_MS);
-}
-/** Resolves the conservative post-tool raw assistant guard timeout. */
-function resolveCodexPostToolRawAssistantCompletionIdleTimeoutMs(value, fallbackMs) {
-	return resolvePositiveIntegerTimeoutMs(value, Math.max(resolvePositiveIntegerTimeoutMs(void 0, fallbackMs), CODEX_POST_TOOL_RAW_ASSISTANT_COMPLETION_IDLE_TIMEOUT_MS));
-}
-/** Resolves the long terminal turn idle timeout. */
-function resolveCodexTurnTerminalIdleTimeoutMs(value, runTimeoutOverrideMs) {
-	const explicitRunBudgetMs = resolvePositiveIntegerTimeoutMs(runTimeoutOverrideMs, CODEX_TURN_TERMINAL_IDLE_TIMEOUT_MS);
-	return resolvePositiveIntegerTimeoutMs(value, Math.max(CODEX_TURN_TERMINAL_IDLE_TIMEOUT_MS, explicitRunBudgetMs));
-}
-/** Adds gateway grace time to a caller timeout without overflowing invalid values. */
-function resolveCodexGatewayTimeoutWithGraceMs(timeoutMs, graceMs = 1e4) {
-	const timeout = resolvePositiveIntegerTimeoutMs(timeoutMs, 1);
-	return addTimerTimeoutGraceMs(timeout, resolveTimerTimeoutMs(graceMs, 0, 0)) ?? timeout;
-}
-//#endregion
 //#region extensions/codex/src/app-server/auth-start-options.ts
 const CODEX_APP_SERVER_HOME_DIRNAME = "codex-home";
 const CODEX_EPHEMERAL_AUTH_STORE_OVERRIDE = "cli_auth_credentials_store=\"ephemeral\"";
 function resolveCodexAppServerHomeDir(agentDir) {
 	return path.join(path.resolve(agentDir), CODEX_APP_SERVER_HOME_DIRNAME);
 }
+/** Resolves the local CODEX_HOME used when starting one app-server connection. */
+function resolveCodexAppServerLocalHomeDir(startOptions, agentDir, env = process.env) {
+	const configured = startOptions.env?.CODEX_HOME;
+	if (configured?.trim()) return configured;
+	return startOptions.homeScope === "user" ? resolveCodexAppServerUserHomeDir(env) : resolveCodexAppServerHomeDir(agentDir);
+}
 /** Forces OpenClaw-owned Codex auth to remain process-local. */
 function withEphemeralCodexAuthStore(params) {
 	const { startOptions } = params;
@@ -268,108 +181,385 @@ function skippedCacheResult(status, message) {
 	};
 }
 //#endregion
+//#region extensions/codex/src/app-server/computer-use-service-path.ts
+/** Filesystem ownership guards for isolated Computer Use service provisioning. */
+async function assertOwnedServicePath(params) {
+	await assertOwnedCodexHomePath({
+		ownershipRoot: params.ownershipRoot,
+		codexHome: params.codexHome,
+		allowMissing: true
+	});
+	assertPathAtOrInside(params.ownershipRoot, params.targetParent, "Computer Use service parent");
+	await assertNoSymlinkParents({
+		rootDir: params.ownershipRoot,
+		targetPath: params.targetParent,
+		allowMissing: true,
+		requireDirectories: true,
+		messagePrefix: "Computer Use service path"
+	});
+	await assertNotSymlink(params.targetPath, "Computer Use service target");
+}
+async function ensureOwnedCodexHome(codexHomeInput, ownershipRootInput = path.dirname(path.resolve(codexHomeInput))) {
+	const codexHome = path.resolve(codexHomeInput);
+	const ownershipRoot = path.resolve(ownershipRootInput);
+	await fs.mkdir(ownershipRoot, {
+		recursive: true,
+		mode: 448
+	});
+	await assertOwnedCodexHomePath({
+		ownershipRoot,
+		codexHome,
+		allowMissing: true
+	});
+	await ensureRealDirectoryTree(ownershipRoot, codexHome, "isolated Codex home");
+	await assertOwnedCodexHomePath({
+		ownershipRoot,
+		codexHome,
+		allowMissing: false
+	});
+}
+async function prepareOwnedServiceParent(params) {
+	await ensureOwnedCodexHome(params.codexHome, params.ownershipRoot);
+	await ensureRealDirectoryTree(params.ownershipRoot, params.targetParent, "Computer Use service parent");
+	await assertNoSymlinkParents({
+		rootDir: params.ownershipRoot,
+		targetPath: params.targetParent,
+		allowMissing: false,
+		requireDirectories: true,
+		messagePrefix: "Computer Use service path"
+	});
+	const [rootIdentity, parentIdentity] = await Promise.all([readRealDirectoryIdentity(params.ownershipRoot, "Computer Use ownership root"), readRealDirectoryIdentity(params.targetParent, "Computer Use service parent")]);
+	assertPathAtOrInside(rootIdentity.realPath, parentIdentity.realPath, "canonical Computer Use service parent");
+	return parentIdentity;
+}
+async function assertOwnedCodexHomePath(params) {
+	await readRealDirectoryIdentity(params.ownershipRoot, "Computer Use ownership root");
+	assertPathAtOrInside(params.ownershipRoot, params.codexHome, "isolated Codex home");
+	await assertNoSymlinkParents({
+		rootDir: params.ownershipRoot,
+		targetPath: params.codexHome,
+		allowMissing: params.allowMissing,
+		requireDirectories: true,
+		messagePrefix: "Computer Use service path"
+	});
+}
+async function readRealDirectoryIdentity(directoryPath, label) {
+	const logicalPath = path.resolve(directoryPath);
+	const before = await fs.lstat(logicalPath);
+	if (before.isSymbolicLink() || !before.isDirectory()) throw new Error(`${label} must be a real directory: ${logicalPath}`);
+	const realPath = await fs.realpath(logicalPath);
+	const [after, resolved] = await Promise.all([fs.lstat(logicalPath), fs.lstat(realPath)]);
+	if (after.isSymbolicLink() || !after.isDirectory() || !resolved.isDirectory() || before.dev !== after.dev || before.ino !== after.ino || after.dev !== resolved.dev || after.ino !== resolved.ino) throw new Error(`${label} changed while its ownership boundary was being established.`);
+	return {
+		logicalPath,
+		realPath,
+		dev: after.dev,
+		ino: after.ino
+	};
+}
+async function assertOwnedServiceParentStable(parent) {
+	await assertDirectoryIdentityStable(parent, "Computer Use service parent");
+}
+async function assertDirectoryIdentityStable(expected, label) {
+	if (!await directoryIdentityIsStable(expected)) throw new Error(`${label} changed during refresh; refusing to mutate the replacement path.`);
+}
+async function ownedServiceParentIsStable(parent) {
+	return await directoryIdentityIsStable(parent);
+}
+async function directoryIdentityIsStable(expected) {
+	try {
+		const current = await fs.lstat(expected.logicalPath);
+		if (current.isSymbolicLink() || !current.isDirectory() || current.dev !== expected.dev || current.ino !== expected.ino) return false;
+		return await fs.realpath(expected.logicalPath) === expected.realPath;
+	} catch {
+		return false;
+	}
+}
+async function assertNotSymlink(filePath, label) {
+	try {
+		if ((await fs.lstat(filePath)).isSymbolicLink()) throw new Error(`${label} must not be a symbolic link: ${filePath}`);
+	} catch (error) {
+		if (hasNodeErrorCode(error, "ENOENT")) return;
+		throw error;
+	}
+}
+async function ensureRealDirectoryTree(ownershipRoot, directoryPath, label) {
+	const root = path.resolve(ownershipRoot);
+	const target = path.resolve(directoryPath);
+	assertPathAtOrInside(root, target, label);
+	const relative = path.relative(root, target);
+	let current = root;
+	for (const segment of relative.split(path.sep).filter(Boolean)) {
+		current = path.join(current, segment);
+		const existing = await fs.lstat(current).catch((error) => {
+			if (hasNodeErrorCode(error, "ENOENT")) return;
+			throw error;
+		});
+		if (!existing) {
+			try {
+				await fs.mkdir(current, { mode: 448 });
+			} catch (error) {
+				if (!hasNodeErrorCode(error, "EEXIST")) throw error;
+			}
+			const created = await fs.lstat(current);
+			if (created.isSymbolicLink() || !created.isDirectory()) throw new Error(`${label} changed while its directory tree was being created: ${current}`);
+		} else if (existing.isSymbolicLink() || !existing.isDirectory()) throw new Error(`${label} must traverse real directories: ${current}`);
+	}
+	await assertNoSymlinkParents({
+		rootDir: root,
+		targetPath: target,
+		allowMissing: false,
+		requireDirectories: true,
+		messagePrefix: "Computer Use service path"
+	});
+	await readRealDirectoryIdentity(target, label);
+}
+function assertPathAtOrInside(rootPath, candidatePath, label) {
+	const relative = path.relative(path.resolve(rootPath), path.resolve(candidatePath));
+	if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) throw new Error(`${label} must remain inside ${path.resolve(rootPath)}.`);
+}
+function hasNodeErrorCode(error, code) {
+	return Boolean(error && typeof error === "object" && "code" in error && error.code === code);
+}
+//#endregion
 //#region extensions/codex/src/app-server/computer-use-service.ts
 /** Native Computer Use service provisioning for isolated Codex homes. */
 const SERVICE_APP_NAME = "Codex Computer Use.app";
-const CLIENT_RELATIVE_PATH = path.join("Contents", "SharedSupport", "SkyComputerUseClient.app", "Contents", "MacOS", "SkyComputerUseClient");
+const SERVICE_BUNDLE_ID = "com.openai.sky.CUAService";
+const CLIENT_BUNDLE_ID = "com.openai.sky.CUAService.cli";
+const OPENAI_TEAM_ID = "2DC432GLL2";
+const CLIENT_APP_RELATIVE_PATH = path.join("Contents", "SharedSupport", "SkyComputerUseClient.app");
+const CLIENT_RELATIVE_PATH = path.join(CLIENT_APP_RELATIVE_PATH, "Contents", "MacOS", "SkyComputerUseClient");
 const COPY_TIMEOUT_MS = 12e4;
+const INSPECT_TIMEOUT_MS = 3e4;
+const COMPLETED_SYNC_CACHE_MAX_ENTRIES = 64;
 const activeInstalls = /* @__PURE__ */ new Map();
-/** Ensures the official native client exists beneath the CODEX_HOME used by its launcher. */
+const completedSyncs = /* @__PURE__ */ new Map();
+/** Synchronizes the CODEX_HOME native client with the selected signed desktop distribution. */
 async function ensureCodexComputerUseServiceApp(params) {
 	const platform = params.platform ?? process.platform;
 	if (platform !== "darwin") return {
 		status: "unsupported",
 		changed: false
 	};
-	const targetPath = path.join(path.resolve(params.codexHome), "computer-use", SERVICE_APP_NAME);
+	const codexHome = path.resolve(params.codexHome);
+	const ownershipRoot = path.resolve(params.ownershipRoot ?? path.dirname(codexHome));
+	const targetParent = path.join(codexHome, "computer-use");
+	const targetPath = path.join(targetParent, SERVICE_APP_NAME);
+	await ensureOwnedCodexHome(codexHome, ownershipRoot);
+	await assertOwnedServicePath({
+		ownershipRoot,
+		codexHome,
+		targetParent,
+		targetPath
+	});
+	const candidates = params.sourceAppCandidates ?? resolveMacOSDesktopCodexComputerUseServiceAppCandidates(platform, params.appServerCommand);
+	const syncKey = [targetPath, ...candidates].join("\0");
+	const completed = completedSyncs.get(targetPath);
+	if (completed?.syncKey === syncKey) {
+		completedSyncs.delete(targetPath);
+		completedSyncs.set(targetPath, completed);
+		return {
+			status: "already_current",
+			changed: false,
+			targetPath: completed.targetPath,
+			sourcePath: completed.sourcePath,
+			sourceBuild: completed.sourceBuild
+		};
+	}
 	const active = activeInstalls.get(targetPath);
-	if (active) return await active;
+	if (active) {
+		if (active.syncKey === syncKey) return await active.promise;
+		await active.promise.catch(() => void 0);
+		return await ensureCodexComputerUseServiceApp(params);
+	}
+	if (completed) completedSyncs.delete(targetPath);
 	const install = ensureCodexComputerUseServiceAppOnce({
 		...params,
+		codexHome,
+		ownershipRoot,
+		targetParent,
 		targetPath,
-		platform
+		platform,
+		sourceAppCandidates: candidates
+	}).then((result) => {
+		if (isCompletedSyncStatus(result.status)) {
+			completedSyncs.delete(targetPath);
+			completedSyncs.set(targetPath, {
+				syncKey,
+				targetPath: result.targetPath,
+				sourcePath: result.sourcePath,
+				sourceBuild: result.sourceBuild
+			});
+			pruneMapToMaxSize(completedSyncs, COMPLETED_SYNC_CACHE_MAX_ENTRIES);
+		}
+		return result;
 	});
-	activeInstalls.set(targetPath, install);
-	try {
-		return await install;
-	} finally {
-		if (activeInstalls.get(targetPath) === install) activeInstalls.delete(targetPath);
-	}
+	const activeEntry = {
+		syncKey,
+		promise: install
+	};
+	activeInstalls.set(targetPath, activeEntry);
+	const clearActive = () => {
+		if (activeInstalls.get(targetPath) === activeEntry) activeInstalls.delete(targetPath);
+	};
+	install.then(clearActive, clearActive);
+	return await install;
+}
+function isCompletedSyncStatus(status) {
+	return status === "installed" || status === "refreshed" || status === "already_current";
 }
 async function ensureCodexComputerUseServiceAppOnce(params) {
-	if (await hasExecutableClient(params.targetPath)) return {
-		status: "already_installed",
+	const inspectServiceApp = params.inspectServiceApp ?? inspectTrustedServiceApp;
+	const source = await findUsableServiceApp(params.sourceAppCandidates ?? [], inspectServiceApp);
+	if (!source) return {
+		status: "source_missing",
 		changed: false,
 		targetPath: params.targetPath
 	};
-	const sourcePath = await findUsableServiceApp(params.sourceAppCandidates ?? resolveMacOSDesktopCodexComputerUseServiceAppCandidates(params.platform, params.appServerCommand));
-	if (!sourcePath) return {
-		status: "source_missing",
+	const { path: sourcePath, identity: sourceIdentity } = source;
+	const ownedParent = await prepareOwnedServiceParent({
+		ownershipRoot: params.ownershipRoot,
+		codexHome: params.codexHome,
+		targetParent: params.targetParent
+	});
+	const operationTargetPath = path.join(ownedParent.realPath, SERVICE_APP_NAME);
+	await assertNotSymlink(operationTargetPath, "Computer Use service target");
+	const initialTarget = await readServiceAppSnapshot(operationTargetPath, inspectServiceApp);
+	if (initialTarget.identity && identitiesMatch(initialTarget.identity, sourceIdentity)) return {
+		status: "already_current",
 		changed: false,
-		targetPath: params.targetPath
+		targetPath: params.targetPath,
+		sourcePath,
+		sourceBuild: sourceIdentity.build
 	};
-	const targetParent = path.dirname(params.targetPath);
-	await fs.mkdir(targetParent, { recursive: true });
-	const stagingRoot = await fs.mkdtemp(path.join(targetParent, ".service-app.staging-"));
+	await assertOwnedServiceParentStable(ownedParent);
+	const stagingRoot = await fs.mkdtemp(path.join(ownedParent.realPath, ".service-app.staging-"));
+	const stagingRootIdentity = await readRealDirectoryIdentity(stagingRoot, "Computer Use service staging directory");
 	const stagedPath = path.join(stagingRoot, SERVICE_APP_NAME);
-	const backupPath = path.join(targetParent, `.service-app.backup-${process.pid}-${Date.now()}`);
+	const backupPath = path.join(ownedParent.realPath, `.service-app.backup-${process.pid}-${Date.now()}`);
 	let backupCreated = false;
 	try {
 		await (params.copyServiceApp ?? copyServiceAppWithDitto)(sourcePath, stagedPath);
-		if (!await hasExecutableClient(stagedPath)) throw new Error(`Copied Computer Use service app is incomplete at ${stagedPath}.`);
-		if (await pathExists$1(params.targetPath)) {
-			await fs.rename(params.targetPath, backupPath);
+		await assertOwnedServiceParentStable(ownedParent);
+		await assertDirectoryIdentityStable(stagingRootIdentity, "Computer Use service staging directory");
+		await assertNotSymlink(stagedPath, "Copied Computer Use service app");
+		const stagedIdentity = await inspectServiceApp(stagedPath);
+		if (!stagedIdentity || !identitiesMatch(stagedIdentity, sourceIdentity)) throw new Error(`Copied Computer Use service app at ${stagedPath} does not match its selected signed source.`);
+		const stagedSnapshot = await readServiceAppSnapshot(stagedPath, inspectServiceApp);
+		const currentSourceIdentity = await inspectServiceApp(sourcePath);
+		await assertOwnedServiceParentStable(ownedParent);
+		if (!currentSourceIdentity || !identitiesMatch(currentSourceIdentity, sourceIdentity)) throw new Error("Selected Computer Use service source changed during refresh.");
+		await assertNotSymlink(operationTargetPath, "Computer Use service target");
+		if (await pathExists$1(operationTargetPath)) {
+			await assertOwnedServiceParentStable(ownedParent);
+			await fs.rename(operationTargetPath, backupPath);
+			await assertOwnedServiceParentStable(ownedParent);
 			backupCreated = true;
-			if (await hasExecutableClient(backupPath)) {
-				await fs.rename(backupPath, params.targetPath);
+			const movedTarget = await readServiceAppSnapshot(backupPath, inspectServiceApp);
+			if (movedTarget.identity && identitiesMatch(movedTarget.identity, sourceIdentity)) {
+				await assertOwnedServiceParentStable(ownedParent);
+				await fs.rename(backupPath, operationTargetPath);
+				await assertOwnedServiceParentStable(ownedParent);
 				backupCreated = false;
 				return {
-					status: "already_installed",
+					status: "already_current",
 					changed: false,
 					targetPath: params.targetPath,
-					sourcePath
+					sourcePath,
+					sourceBuild: sourceIdentity.build
 				};
 			}
+			if (!snapshotsMatch(initialTarget, movedTarget)) {
+				await assertOwnedServiceParentStable(ownedParent);
+				await fs.rename(backupPath, operationTargetPath);
+				await assertOwnedServiceParentStable(ownedParent);
+				backupCreated = false;
+				throw new Error("Computer Use service target changed to an unexpected generation during refresh.");
+			}
 		}
 		try {
-			await fs.rename(stagedPath, params.targetPath);
+			await assertOwnedServiceParentStable(ownedParent);
+			await fs.rename(stagedPath, operationTargetPath);
+			await assertOwnedServiceParentStable(ownedParent);
 		} catch (error) {
-			if (!await hasExecutableClient(params.targetPath)) {
+			await assertOwnedServiceParentStable(ownedParent);
+			await assertNotSymlink(operationTargetPath, "Computer Use service target");
+			const winnerIdentity = await inspectServiceApp(operationTargetPath);
+			if (!winnerIdentity || !identitiesMatch(winnerIdentity, sourceIdentity)) {
 				if (backupCreated) {
-					await fs.rename(backupPath, params.targetPath);
-					backupCreated = false;
+					if (!await pathExists$1(operationTargetPath)) {
+						await assertOwnedServiceParentStable(ownedParent);
+						await fs.rename(backupPath, operationTargetPath);
+						await assertOwnedServiceParentStable(ownedParent);
+						backupCreated = false;
+					}
 				}
 				throw error;
 			}
 			if (backupCreated) {
+				await assertOwnedServiceParentStable(ownedParent);
+				await assertNotSymlink(backupPath, "Computer Use service backup");
 				await fs.rm(backupPath, {
 					recursive: true,
 					force: true
 				});
+				await assertOwnedServiceParentStable(ownedParent);
 				backupCreated = false;
 			}
 			return {
-				status: "already_installed",
+				status: "already_current",
 				changed: false,
 				targetPath: params.targetPath,
-				sourcePath
+				sourcePath,
+				sourceBuild: sourceIdentity.build
 			};
 		}
+		await assertNotSymlink(operationTargetPath, "Installed Computer Use service app");
+		const installedSnapshot = await readServiceAppSnapshot(operationTargetPath, inspectServiceApp);
+		if (!installedSnapshot.identity || !identitiesMatch(installedSnapshot.identity, sourceIdentity)) {
+			if (filesystemSnapshotsMatch(installedSnapshot, stagedSnapshot)) {
+				await assertOwnedServiceParentStable(ownedParent);
+				await fs.rm(operationTargetPath, {
+					recursive: true,
+					force: true
+				});
+				await assertOwnedServiceParentStable(ownedParent);
+				if (backupCreated) {
+					await fs.rename(backupPath, operationTargetPath);
+					await assertOwnedServiceParentStable(ownedParent);
+					backupCreated = false;
+				}
+			}
+			throw new Error("Installed Computer Use service app failed post-install identity verification.");
+		}
 		if (backupCreated) {
+			await assertOwnedServiceParentStable(ownedParent);
+			await assertNotSymlink(backupPath, "Computer Use service backup");
 			await fs.rm(backupPath, {
 				recursive: true,
 				force: true
 			});
+			await assertOwnedServiceParentStable(ownedParent);
 			backupCreated = false;
 		}
 		return {
-			status: "installed",
+			status: initialTarget.exists ? "refreshed" : "installed",
 			changed: true,
 			targetPath: params.targetPath,
-			sourcePath
+			sourcePath,
+			sourceBuild: sourceIdentity.build,
+			...initialTarget.identity ? { previousBuild: initialTarget.identity.build } : {}
 		};
+	} catch (error) {
+		if (backupCreated && await ownedServiceParentIsStable(ownedParent) && !await pathExists$1(operationTargetPath)) {
+			await assertOwnedServiceParentStable(ownedParent);
+			await fs.rename(backupPath, operationTargetPath);
+			backupCreated = false;
+		}
+		throw error;
 	} finally {
-		await fs.rm(stagingRoot, {
+		if (await ownedServiceParentIsStable(ownedParent) && await directoryIdentityIsStable(stagingRootIdentity)) await fs.rm(stagingRoot, {
 			recursive: true,
 			force: true
 		});
@@ -378,8 +568,43 @@ async function ensureCodexComputerUseServiceAppOnce(params) {
 async function pathExists$1(filePath) {
 	return await fs.lstat(filePath).then(() => true, () => false);
 }
-async function findUsableServiceApp(candidates) {
-	for (const candidate of candidates) if (await hasExecutableClient(candidate)) return candidate;
+async function findUsableServiceApp(candidates, inspectServiceApp) {
+	for (const candidate of candidates) {
+		const identity = await inspectServiceApp(candidate);
+		if (identity) return {
+			path: candidate,
+			identity
+		};
+	}
+}
+async function readServiceAppSnapshot(appPath, inspectServiceApp) {
+	if (!await pathExists$1(appPath)) return { exists: false };
+	return {
+		exists: true,
+		identity: await inspectServiceApp(appPath),
+		filesystemKey: await readServiceAppFilesystemKey(appPath)
+	};
+}
+async function readServiceAppFilesystemKey(appPath) {
+	const paths = [
+		appPath,
+		path.join(appPath, "Contents", "Info.plist"),
+		path.join(appPath, CLIENT_RELATIVE_PATH)
+	];
+	return (await Promise.all(paths.map(async (entryPath) => await fs.stat(entryPath).then((stat) => `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeMs}`, () => "missing")))).join("|");
+}
+function snapshotsMatch(left, right) {
+	if (left.exists !== right.exists) return false;
+	if (!left.exists) return true;
+	if (left.filesystemKey && right.filesystemKey && left.filesystemKey !== right.filesystemKey) return false;
+	if (left.identity || right.identity) return Boolean(left.identity && right.identity && identitiesMatch(left.identity, right.identity));
+	return left.filesystemKey !== void 0 && left.filesystemKey === right.filesystemKey;
+}
+function filesystemSnapshotsMatch(left, right) {
+	return Boolean(left.exists && right.exists && left.filesystemKey && right.filesystemKey && left.filesystemKey === right.filesystemKey);
+}
+function identitiesMatch(left, right) {
+	return left.bundleId === right.bundleId && left.version === right.version && left.build === right.build && left.cdHash === right.cdHash && left.teamId === right.teamId && left.clientBundleId === right.clientBundleId && left.clientCdHash === right.clientCdHash && left.clientTeamId === right.clientTeamId;
 }
 async function hasExecutableClient(appPath) {
 	try {
@@ -389,6 +614,90 @@ async function hasExecutableClient(appPath) {
 		return false;
 	}
 }
+async function inspectTrustedServiceApp(appPath) {
+	if (!await hasExecutableClient(appPath)) return;
+	const clientAppPath = path.join(appPath, CLIENT_APP_RELATIVE_PATH);
+	try {
+		await verifyTrustedBundle(appPath, SERVICE_BUNDLE_ID, true);
+		await verifyTrustedBundle(clientAppPath, CLIENT_BUNDLE_ID, false);
+		const [info, serviceSignature, clientSignature] = await Promise.all([
+			readBundleInfo(appPath),
+			readCodeSignature(appPath),
+			readCodeSignature(clientAppPath)
+		]);
+		if (!info || serviceSignature.identifier !== SERVICE_BUNDLE_ID || serviceSignature.teamId !== OPENAI_TEAM_ID || clientSignature.identifier !== CLIENT_BUNDLE_ID || clientSignature.teamId !== OPENAI_TEAM_ID) return;
+		return {
+			bundleId: serviceSignature.identifier,
+			version: info.version,
+			build: info.build,
+			cdHash: serviceSignature.cdHash,
+			teamId: serviceSignature.teamId,
+			clientBundleId: clientSignature.identifier,
+			clientCdHash: clientSignature.cdHash,
+			clientTeamId: clientSignature.teamId
+		};
+	} catch {
+		return;
+	}
+}
+async function verifyTrustedBundle(appPath, bundleId, deep) {
+	const requirement = `anchor apple generic and certificate leaf[subject.OU] = "${OPENAI_TEAM_ID}" and identifier "${bundleId}"`;
+	await runExec("/usr/bin/codesign", [
+		"--verify",
+		"--strict",
+		...deep ? ["--deep"] : [],
+		`-R=${requirement}`,
+		appPath
+	], {
+		logOutput: false,
+		timeoutMs: INSPECT_TIMEOUT_MS
+	});
+}
+async function readBundleInfo(appPath) {
+	const result = await runExec("/usr/bin/plutil", [
+		"-convert",
+		"json",
+		"-o",
+		"-",
+		"--",
+		path.join(appPath, "Contents", "Info.plist")
+	], {
+		logOutput: false,
+		timeoutMs: INSPECT_TIMEOUT_MS
+	});
+	const parsed = JSON.parse(result.stdout);
+	if (!isRecord(parsed)) return;
+	const version = parsed.CFBundleShortVersionString;
+	const build = parsed.CFBundleVersion;
+	return typeof version === "string" && version && typeof build === "string" && build ? {
+		version,
+		build
+	} : void 0;
+}
+async function readCodeSignature(appPath) {
+	const result = await runExec("/usr/bin/codesign", [
+		"-d",
+		"--verbose=4",
+		appPath
+	], {
+		logOutput: false,
+		timeoutMs: INSPECT_TIMEOUT_MS
+	});
+	const output = `${result.stdout}\n${result.stderr}`;
+	const identifier = readCodeSignField(output, "Identifier");
+	const teamId = readCodeSignField(output, "TeamIdentifier");
+	const cdHash = readCodeSignField(output, "CDHash").toLowerCase();
+	if (!identifier || !teamId || !/^[a-f0-9]+$/.test(cdHash)) throw new Error(`Could not inspect the signed identity at ${appPath}.`);
+	return {
+		identifier,
+		teamId,
+		cdHash
+	};
+}
+function readCodeSignField(output, field) {
+	const prefix = `${field}=`;
+	return output.split(/\r?\n/u).find((candidate) => candidate.startsWith(prefix))?.slice(prefix.length).trim() ?? "";
+}
 async function copyServiceAppWithDitto(sourcePath, targetPath) {
 	await runExec("/usr/bin/ditto", [
 		"--noqtn",
@@ -408,8 +717,8 @@ function flattenCodexDynamicToolFunctions(tools) {
 }
 const CODEX_INTERACTIVE_THREAD_SOURCE_KINDS = ["cli", "vscode"];
 const CODEX_INTERACTIVE_CUSTOM_THREAD_SOURCES = ["atlas", "chatgpt"];
-function isJsonObject$1(value) {
-	return Boolean(value && typeof value === "object" && !Array.isArray(value));
+function isJsonObject(value) {
+	return isRecord(value);
 }
 function isRpcResponse(message) {
 	return "id" in message && !("method" in message);
@@ -436,24 +745,41 @@ const CODEX_HOME_DIRNAME = ".codex";
 const scopedOAuthRefreshQueues = /* @__PURE__ */ new WeakMap();
 async function bridgeCodexAppServerStartOptions(params) {
 	if (params.startOptions.transport !== "stdio") return params.startOptions;
-	const scopedStartOptions = await withCodexHomeEnvironment(withEphemeralCodexAuthStore(params), params.agentDir, params.pluginConfig);
-	if (params.preparedAuth) return withClearedEnvironmentVariables(scopedStartOptions, CODEX_APP_SERVER_PREPARED_AUTH_ENV_VARS);
-	if (params.authProfileId === null) return scopedStartOptions;
+	const scopeStartOptions = () => withCodexHomeEnvironment(withEphemeralCodexAuthStore(params), params.agentDir, params.pluginConfig);
+	if (params.preparedAuth) return withClearedEnvironmentVariables(await scopeStartOptions(), CODEX_APP_SERVER_PREPARED_AUTH_ENV_VARS);
+	if (params.authProfileId === null) return scopeStartOptions();
 	const store = resolveCodexAppServerAuthProfileStore({
 		agentDir: params.agentDir,
 		authProfileId: params.authProfileId,
 		authProfileStore: params.authProfileStore,
 		config: params.config
 	});
+	const authProfileId = resolveCodexAppServerAuthProfileId({
+		authProfileId: params.authProfileId,
+		store,
+		config: params.config
+	});
+	if (!authProfileId) assertNoUnimportedAgentCodexAuthFile(params);
+	const scopedStartOptions = await scopeStartOptions();
 	return shouldClearOpenAiApiKeyForCodexAuthProfile({
 		store,
-		authProfileId: resolveCodexAppServerAuthProfileId({
-			authProfileId: params.authProfileId,
-			store,
-			config: params.config
-		})
+		authProfileId
 	}) ? withClearedEnvironmentVariables(scopedStartOptions, CODEX_APP_SERVER_API_KEY_ENV_VARS) : scopedStartOptions;
 }
+function assertNoUnimportedAgentCodexAuthFile(params) {
+	if (params.authRequirement === "api-key" && resolveCodexAppServerFallbackApiKeyCacheKey({ startOptions: params.startOptions })) return;
+	const message = resolveUnimportedAgentCodexAuthMessage(params);
+	if (message) throw new AgentHarnessPreflightError(message);
+}
+function resolveUnimportedAgentCodexAuthMessage(params) {
+	const managedCodexCli = params.startOptions.commandSource === "managed" || params.startOptions.commandSource === "resolved-managed";
+	if (params.startOptions.transport !== "stdio" || !managedCodexCli || params.startOptions.homeScope === "user") return;
+	const codexHome = resolveCodexAppServerHomeDir(params.agentDir);
+	const authPath = path.join(codexHome, CODEX_AUTH_JSON_FILENAME);
+	if (!fsSync.existsSync(authPath)) return;
+	const targetAgentId = params.agentId?.trim() || "<agent-id>";
+	return `A Codex auth file exists at ${authPath}, but agent-scoped Codex runs use OpenClaw's auth store and do not read that file. Preview only that credential import with \`openclaw migrate plan codex --from <codex-home> --agent ${targetAgentId} --include-secrets --item auth:openai\`, then run \`openclaw migrate apply codex --from <codex-home> --agent ${targetAgentId} --include-secrets --item auth:openai --yes\`. If the plan finds no credentials, remove the stale auth file.`;
+}
 function resolveCodexAppServerAuthProfileId(params) {
 	const requested = params.authProfileId?.trim();
 	if (requested) return requested;
@@ -518,15 +844,20 @@ async function resolveCodexAppServerPreparedAuthProfileSnapshot(params) {
 	if (!loginParams) return;
 	const accountId = loginParams.type === "chatgptAuthTokens" ? loginParams.chatgptAccountId : resolveChatgptAccountId(profileId, credential);
 	const stableChatgptAccountId = resolveStableChatgptAccountId(credential);
+	const secretFreeCacheKey = credential.type === "api_key" && loginParams.type === "apiKey" ? `${accountId}:${fingerprintApiKeyAuthProfileCacheKey(loginParams.apiKey)}` : loginParams.type === "chatgptAuthTokens" && (credential.type === "token" || !stableChatgptAccountId) ? `${accountId}:${fingerprintTokenAuthProfileCacheKey(loginParams.accessToken)}` : accountId;
+	const chatgptAccountId = resolveExplicitChatgptAccountId(credential);
 	return {
 		loginParams,
-		secretFreeCacheKey: credential.type === "api_key" && loginParams.type === "apiKey" ? `${accountId}:${fingerprintApiKeyAuthProfileCacheKey(loginParams.apiKey)}` : loginParams.type === "chatgptAuthTokens" && (credential.type === "token" || !stableChatgptAccountId) ? `${accountId}:${fingerprintTokenAuthProfileCacheKey(loginParams.accessToken)}` : accountId
+		secretFreeCacheKey,
+		...chatgptAccountId ? { chatgptAccountId } : {}
 	};
 }
 /** Maps one prepared route to one mutually exclusive app-server auth handoff. */
 async function resolveCodexAppServerPreparedAuthHandoff(params) {
 	const usesNativeHome = params.homeScope === "user";
-	if (params.authRequirement === "api-key" && !usesNativeHome) {
+	if (params.requirePreparedAuth && usesNativeHome) throw createCodexAppServerAuthError("Codex remote-exec cloud placement requires prepared OpenAI auth. Configure an OpenAI API-key, OAuth, or token profile and use appServer.homeScope=\"agent\"; ambient credentials and native Codex auth are not allowed.");
+	if (usesNativeHome) return { nativeAuthProfile: true };
+	if (params.authRequirement === "api-key") {
 		const apiKey = params.resolvedApiKey?.trim();
 		if (!apiKey) throw new Error("Prepared Codex API-key route is missing its resolved API key.");
 		return {
@@ -544,18 +875,18 @@ async function resolveCodexAppServerPreparedAuthHandoff(params) {
 		agentDir: params.agentDir,
 		config: params.config
 	});
-	if (usesNativeHome || params.authRequirement !== "subscription") return {
+	if (params.authRequirement !== "subscription" && !params.requirePreparedAuth) return {
 		authProfileId,
 		nativeAuthProfile
 	};
-	if (!authProfileId || !nativeAuthProfile) throw createCodexAppServerAuthError(params.subscriptionProfileRequiredError);
+	if (!authProfileId || params.authRequirement === "subscription" && !nativeAuthProfile) throw createCodexAppServerAuthError(params.requirePreparedAuth ? "Codex remote-exec cloud placement requires prepared OpenAI auth. Configure an OpenAI API-key, OAuth, or token profile; ambient CODEX_API_KEY, OPENAI_API_KEY, and native Codex auth are not allowed." : params.subscriptionProfileRequiredError);
 	const snapshot = await resolveCodexAppServerPreparedAuthProfileSnapshot({
 		authProfileId,
 		authProfileStore: params.authProfileStore,
 		agentDir: params.agentDir,
 		config: params.config
 	});
-	if (!snapshot) throw createCodexAppServerAuthError(params.subscriptionProfileUnusableError);
+	if (!snapshot) throw createCodexAppServerAuthError(params.requirePreparedAuth ? "Codex remote-exec cloud placement could not prepare the selected OpenAI auth profile. Repair or replace the profile, then retry." : params.subscriptionProfileUnusableError);
 	return {
 		authProfileId,
 		nativeAuthProfile,
@@ -644,7 +975,7 @@ function fingerprintCodexCliAuthFileApiKeyCacheKey(apiKey) {
 	return `CODEX_AUTH_JSON:sha256:${hash.digest("hex")}`;
 }
 async function withCodexHomeEnvironment(startOptions, agentDir, pluginConfig) {
-	const codexHome = startOptions.env?.[CODEX_HOME_ENV_VAR]?.trim() ? startOptions.env[CODEX_HOME_ENV_VAR] : startOptions.homeScope === "user" ? resolveCodexAppServerUserHomeDir(process.env) : resolveCodexAppServerHomeDir(agentDir);
+	const codexHome = resolveCodexAppServerLocalHomeDir(startOptions, agentDir);
 	const nativeHome = startOptions.env?.[HOME_ENV_VAR]?.trim() ? startOptions.env[HOME_ENV_VAR] : void 0;
 	await fs.mkdir(codexHome, { recursive: true });
 	const computerUseConfig = resolveCodexComputerUseConfig({ pluginConfig });
@@ -652,13 +983,18 @@ async function withCodexHomeEnvironment(startOptions, agentDir, pluginConfig) {
 		codexHome,
 		config: computerUseConfig
 	});
-	if (computerUseConfig.enabled && computerUseConfig.autoInstall) try {
+	const ownsIsolatedCodexHome = startOptions.homeScope !== "user" && !startOptions.env?.[CODEX_HOME_ENV_VAR]?.trim();
+	if (computerUseConfig.enabled && computerUseConfig.autoInstall && ownsIsolatedCodexHome) try {
 		await ensureCodexComputerUseServiceApp({
 			codexHome,
+			ownershipRoot: agentDir,
 			appServerCommand: startOptions.command
 		});
 	} catch (error) {
-		throw new AgentHarnessPreflightError("Codex Computer Use client provisioning failed.", { cause: error });
+		throw new AgentHarnessPreflightError("Codex Computer Use client provisioning failed.", {
+			cause: error,
+			scope: "harness"
+		});
 	}
 	if (nativeHome) await fs.mkdir(nativeHome, { recursive: true });
 	const nextStartOptions = {
@@ -733,7 +1069,7 @@ async function applyCodexAppServerAuthProfile(params) {
 async function assertNativeCodexAccountMatchesRoute(client, authRequirement) {
 	if (!authRequirement) return;
 	const response = await client.request("account/read", { refreshToken: false });
-	const accountType = isJsonObject$1(response.account) ? response.account.type : void 0;
+	const accountType = isJsonObject(response.account) ? response.account.type : void 0;
 	if (authRequirement === "subscription") {
 		if (accountType !== "chatgpt") throw createCodexAppServerAuthError("Codex subscription auth profile could not produce login credentials.");
 		return;
@@ -1019,11 +1355,13 @@ function resolveChatgptAccountId(profileId, credential) {
 	return resolveStableChatgptAccountId(credential) ?? profileId;
 }
 function resolveStableChatgptAccountId(credential) {
+	return resolveExplicitChatgptAccountId(credential) ?? (credential.email?.trim() || void 0);
+}
+function resolveExplicitChatgptAccountId(credential) {
 	if ("accountId" in credential && typeof credential.accountId === "string") {
 		const accountId = credential.accountId.trim();
 		if (accountId) return accountId;
 	}
-	return credential.email?.trim() || void 0;
 }
 //#endregion
 //#region extensions/codex/src/app-server/rate-limit-cache.ts
@@ -1048,7 +1386,7 @@ function rememberCodexRateLimitsRead(client, value, nowMs = Date.now()) {
 }
 /** Merges a sparse rolling notification into one physical client's latest read response. */
 function mergeCodexRateLimitsUpdate(client, value, nowMs = Date.now()) {
-	const update = isJsonObject$1(value) && isJsonObject$1(value.rateLimits) ? value.rateLimits : void 0;
+	const update = isJsonObject(value) && isJsonObject(value.rateLimits) ? value.rateLimits : void 0;
 	if (!update) return;
 	const currentState = rateLimitsByClient.get(client);
 	const current = currentState?.value;
@@ -1075,13 +1413,13 @@ function readRecentCodexRateLimits(client, options) {
 	return maxAgeMs >= 0 && nowMs - state.updatedAtMs > maxAgeMs ? void 0 : state.value;
 }
 function mergeRateLimitUpdate(current, update) {
-	const currentEnvelope = isJsonObject$1(current) ? current : void 0;
-	const currentPrimary = currentEnvelope && isJsonObject$1(currentEnvelope.rateLimits) ? currentEnvelope.rateLimits : void 0;
-	const currentByLimitId = currentEnvelope && isJsonObject$1(currentEnvelope.rateLimitsByLimitId) ? currentEnvelope.rateLimitsByLimitId : void 0;
+	const currentEnvelope = isJsonObject(current) ? current : void 0;
+	const currentPrimary = currentEnvelope && isJsonObject(currentEnvelope.rateLimits) ? currentEnvelope.rateLimits : void 0;
+	const currentByLimitId = currentEnvelope && isJsonObject(currentEnvelope.rateLimitsByLimitId) ? currentEnvelope.rateLimitsByLimitId : void 0;
 	const limitId = readLimitId(update);
 	const currentPrimaryLimitId = currentPrimary ? readLimitId(currentPrimary) : void 0;
-	const currentForLimit = (currentByLimitId && isJsonObject$1(currentByLimitId[limitId]) ? currentByLimitId[limitId] : void 0) ?? (currentPrimaryLimitId === limitId ? currentPrimary : void 0);
-	const merged = mergeSparseSnapshot(isJsonObject$1(currentForLimit) ? currentForLimit : void 0, currentPrimary, update, limitId);
+	const currentForLimit = (currentByLimitId && isJsonObject(currentByLimitId[limitId]) ? currentByLimitId[limitId] : void 0) ?? (currentPrimaryLimitId === limitId ? currentPrimary : void 0);
+	const merged = mergeSparseSnapshot(isJsonObject(currentForLimit) ? currentForLimit : void 0, currentPrimary, update, limitId);
 	const nextPrimary = !currentPrimary || currentPrimaryLimitId === limitId ? merged : currentPrimary;
 	let nextByLimitId;
 	if (currentByLimitId) nextByLimitId = {
@@ -1099,11 +1437,11 @@ function mergeRateLimitUpdate(current, update) {
 	};
 }
 function readRateLimitIds(value) {
-	if (!isJsonObject$1(value)) return [];
+	if (!isJsonObject(value)) return [];
 	const ids = /* @__PURE__ */ new Set();
-	if (isJsonObject$1(value.rateLimits)) ids.add(readLimitId(value.rateLimits));
-	if (isJsonObject$1(value.rateLimitsByLimitId)) for (const [key, snapshot] of Object.entries(value.rateLimitsByLimitId)) {
-		const snapshotLimitId = isJsonObject$1(snapshot) && typeof snapshot.limitId === "string" ? snapshot.limitId.trim() : "";
+	if (isJsonObject(value.rateLimits)) ids.add(readLimitId(value.rateLimits));
+	if (isJsonObject(value.rateLimitsByLimitId)) for (const [key, snapshot] of Object.entries(value.rateLimitsByLimitId)) {
+		const snapshotLimitId = isJsonObject(snapshot) && typeof snapshot.limitId === "string" ? snapshot.limitId.trim() : "";
 		ids.add(snapshotLimitId || key);
 	}
 	return [...ids];
@@ -1126,62 +1464,337 @@ function readLimitId(snapshot) {
 //#endregion
 //#region extensions/codex/src/app-server/client-runtime.ts
 /** Client-scoped Codex auth and account observers. */
+/** Match Codex's native grace window without retaining inactive conversations indefinitely. */
+const CODEX_APP_SERVER_LIVE_THREAD_IDLE_TIMEOUT_MS = 30 * 6e4;
+/** Native-child parents are active ownership, so only otherwise-idle threads count against this cap. */
+const CODEX_APP_SERVER_LIVE_THREAD_MAX_IDLE = 64;
 const configuredClients = /* @__PURE__ */ new WeakMap();
+const physicalThreadReleases = /* @__PURE__ */ new WeakMap();
+const claimedThreadReleaseTokens = /* @__PURE__ */ new WeakMap();
+/** Only an initialized, still-open physical client can own retained native subscriptions. */
+function isCodexAppServerClientRuntimeLive(client) {
+	const runtime = configuredClients.get(client);
+	return runtime !== void 0 && !runtime.closed;
+}
 /** Installs one auth-refresh handler and one rate-limit observer per physical client. */
 function ensureCodexAppServerClientRuntime(client, context) {
 	const existing = configuredClients.get(client);
 	if (existing) {
+		if (existing.closed) return;
 		existing.context = context;
 		return;
 	}
-	const runtime = { context };
+	const runtime = {
+		context,
+		closed: false,
+		retainedThreads: /* @__PURE__ */ new Map(),
+		claimedThreads: /* @__PURE__ */ new Map(),
+		releasingThreads: /* @__PURE__ */ new Map(),
+		protectedThreads: /* @__PURE__ */ new Map()
+	};
 	configuredClients.set(client, runtime);
+	client.addCloseHandler(() => {
+		runtime.closed = true;
+		if (runtime.evictionTimer) {
+			clearTimeout(runtime.evictionTimer);
+			runtime.evictionTimer = void 0;
+		}
+		runtime.retainedThreads.clear();
+		runtime.claimedThreads.clear();
+		runtime.protectedThreads.clear();
+	});
 	client.addRequestHandler(async (request) => {
 		if (request.method !== "account/chatgptAuthTokens/refresh") return;
 		if (runtime.context.authMode === "prepared-api-key") throw new Error("ChatGPT token refresh is unavailable for prepared Codex API-key auth.");
-		return await refreshCodexAppServerAuthTokens({
+		return { ...await refreshCodexAppServerAuthTokens({
 			agentDir: runtime.context.agentDir,
 			authProfileId: runtime.context.authProfileId,
 			...runtime.context.authProfileStore ? { authProfileStore: runtime.context.authProfileStore } : {},
 			config: runtime.context.config
-		});
+		}) };
 	});
 	client.addNotificationHandler((notification) => {
-		if (notification.method === "account/rateLimits/updated") mergeCodexRateLimitsUpdate(client, notification.params);
+		if (notification.method === "account/rateLimits/updated") {
+			mergeCodexRateLimitsUpdate(client, notification.params);
+			return;
+		}
+		if (notification.method === "thread/archived" || notification.method === "thread/deleted" || notification.method === "thread/closed") {
+			const threadId = notification.params?.threadId;
+			if (typeof threadId === "string") {
+				const releasing = runtime.releasingThreads.get(threadId);
+				if (releasing) releasing.invalidated = true;
+				runtime.retainedThreads.delete(threadId);
+				runtime.claimedThreads.delete(threadId);
+				scheduleRetainedThreadEviction(client, runtime);
+			}
+		}
 	});
 }
-/** Keep at most one idle, still-subscribed thread on a physical Codex client. */
-async function retainCodexAppServerLiveThread(client, threadId, releasePreviousThread, configFingerprint) {
+function scheduleRetainedThreadEviction(client, runtime) {
+	if (runtime.evictionTimer) {
+		clearTimeout(runtime.evictionTimer);
+		runtime.evictionTimer = void 0;
+	}
+	if (runtime.closed) return;
+	let expiresAt = Number.POSITIVE_INFINITY;
+	for (const [threadId, thread] of runtime.retainedThreads) if (!runtime.protectedThreads.has(threadId)) expiresAt = Math.min(expiresAt, thread.expiresAt);
+	if (!Number.isFinite(expiresAt)) return;
+	runtime.evictionTimer = setTimeout(() => {
+		runtime.evictionTimer = void 0;
+		evictExpiredRetainedThreads(client, runtime).catch((error) => {
+			embeddedAgentLog.warn("codex retained thread expiry failed", { reason: formatErrorMessage(error) });
+		});
+	}, Math.max(0, expiresAt - Date.now()));
+	runtime.evictionTimer.unref?.();
+}
+async function releaseRetainedThread(client, runtime, threadId) {
+	const pendingRelease = runtime.releasingThreads.get(threadId);
+	if (pendingRelease) {
+		await pendingRelease.completion;
+		return false;
+	}
+	const retained = runtime.retainedThreads.get(threadId);
+	if (!retained) return false;
+	const olderThreadIds = /* @__PURE__ */ new Set();
+	for (const candidateThreadId of runtime.retainedThreads.keys()) {
+		if (candidateThreadId === threadId) break;
+		olderThreadIds.add(candidateThreadId);
+	}
+	runtime.retainedThreads.delete(threadId);
+	scheduleRetainedThreadEviction(client, runtime);
+	const transition = { completion: Promise.resolve().then(() => retained.release(threadId)) };
+	runtime.releasingThreads.set(threadId, transition);
+	try {
+		await transition.completion;
+		return true;
+	} catch (error) {
+		if (!runtime.closed && !transition.invalidated && runtime.releasingThreads.get(threadId) === transition && !runtime.retainedThreads.has(threadId) && !runtime.claimedThreads.has(threadId)) {
+			retained.expiresAt = Date.now() + CODEX_APP_SERVER_LIVE_THREAD_IDLE_TIMEOUT_MS;
+			const newerThreads = [...runtime.retainedThreads.entries()].filter(([candidateThreadId]) => !olderThreadIds.has(candidateThreadId));
+			for (const [candidateThreadId] of newerThreads) runtime.retainedThreads.delete(candidateThreadId);
+			runtime.retainedThreads.set(threadId, retained);
+			for (const [candidateThreadId, newerThread] of newerThreads) runtime.retainedThreads.set(candidateThreadId, newerThread);
+		}
+		throw error;
+	} finally {
+		if (runtime.releasingThreads.get(threadId) === transition) runtime.releasingThreads.delete(threadId);
+		scheduleRetainedThreadEviction(client, runtime);
+	}
+}
+async function evictExpiredRetainedThreads(client, runtime) {
+	const now = Date.now();
+	for (const [threadId, thread] of runtime.retainedThreads) if (thread.expiresAt <= now && !runtime.protectedThreads.has(threadId)) await releaseRetainedThread(client, runtime, threadId);
+	scheduleRetainedThreadEviction(client, runtime);
+}
+async function evictExcessIdleThreads(client, runtime) {
+	let idleThreadIds = [...runtime.retainedThreads.keys()].filter((threadId) => !runtime.protectedThreads.has(threadId));
+	while (idleThreadIds.length > CODEX_APP_SERVER_LIVE_THREAD_MAX_IDLE) {
+		await releaseRetainedThread(client, runtime, idleThreadIds[0]);
+		idleThreadIds = [...runtime.retainedThreads.keys()].filter((threadId) => !runtime.protectedThreads.has(threadId));
+	}
+}
+/** Retain separately owned Codex subscriptions; completing B must never cold-restart A. */
+async function retainCodexAppServerLiveThread(client, threadId, releaseThread, configFingerprint, serviceTier) {
 	const runtime = configuredClients.get(client);
-	if (!runtime) return;
-	if (runtime.retainedThreadRelease) await runtime.retainedThreadRelease;
-	const previousThreadId = runtime.retainedThreadId;
-	if (previousThreadId && previousThreadId !== threadId && releasePreviousThread) {
-		const release = releasePreviousThread(previousThreadId);
-		runtime.retainedThreadRelease = release;
+	if (!runtime || runtime.closed) return false;
+	const claimed = runtime.claimedThreads.get(threadId);
+	if (claimed !== void 0 && (releaseThread === void 0 || claimedThreadReleaseTokens.get(releaseThread) !== claimed)) return false;
+	const pendingRelease = runtime.releasingThreads.get(threadId);
+	if (pendingRelease) {
+		await pendingRelease.completion;
+		if (runtime.closed || claimed !== void 0 && runtime.claimedThreads.get(threadId) !== claimed) return false;
+	}
+	runtime.retainedThreads.delete(threadId);
+	const retained = {
+		configFingerprint,
+		serviceTier,
+		expiresAt: Date.now() + CODEX_APP_SERVER_LIVE_THREAD_IDLE_TIMEOUT_MS,
+		release: (releaseThread ? physicalThreadReleases.get(releaseThread) ?? releaseThread : void 0) ?? (async (releasedThreadId) => {
+			await unsubscribeCodexAppServerLiveThread(client, releasedThreadId, 5e3);
+		})
+	};
+	runtime.retainedThreads.set(threadId, retained);
+	try {
+		await evictExcessIdleThreads(client, runtime);
+	} catch (error) {
+		if (runtime.retainedThreads.get(threadId) === retained) runtime.retainedThreads.delete(threadId);
+		scheduleRetainedThreadEviction(client, runtime);
+		embeddedAgentLog.warn("codex retained thread capacity eviction failed", {
+			threadId,
+			reason: formatErrorMessage(error)
+		});
+		return false;
+	}
+	if (runtime.closed) return false;
+	if (claimed !== void 0 && runtime.claimedThreads.get(threadId) === claimed) runtime.claimedThreads.delete(threadId);
+	scheduleRetainedThreadEviction(client, runtime);
+	return true;
+}
+/** Transfer one idle subscription to its next turn or compaction without touching sibling threads. */
+async function consumeCodexAppServerLiveThread(client, threadId, configFingerprint) {
+	const runtime = configuredClients.get(client);
+	if (!runtime || runtime.closed) return;
+	const pendingRelease = runtime.releasingThreads.get(threadId);
+	if (pendingRelease) {
+		await pendingRelease.completion;
+		return;
+	}
+	const retained = runtime.retainedThreads.get(threadId);
+	if (!retained || configFingerprint !== void 0 && retained.configFingerprint !== configFingerprint) return;
+	return claimCodexAppServerThreadOwnership(client, runtime, threadId, retained);
+}
+/** Claims an observed Codex auto-subscription without exposing a temporarily idle owner. */
+async function claimCodexAppServerLiveThread(client, threadId) {
+	const runtime = configuredClients.get(client);
+	if (!runtime || runtime.closed || runtime.claimedThreads.has(threadId)) return;
+	const pendingRelease = runtime.releasingThreads.get(threadId);
+	if (pendingRelease) {
+		await pendingRelease.completion;
+		return;
+	}
+	return claimCodexAppServerThreadOwnership(client, runtime, threadId, runtime.retainedThreads.get(threadId) ?? {
+		expiresAt: Date.now() + CODEX_APP_SERVER_LIVE_THREAD_IDLE_TIMEOUT_MS,
+		release: async (releasedThreadId) => {
+			await unsubscribeCodexAppServerLiveThread(client, releasedThreadId, 5e3);
+		}
+	});
+}
+function claimCodexAppServerThreadOwnership(client, runtime, threadId, retained) {
+	runtime.retainedThreads.delete(threadId);
+	const claimed = Symbol(threadId);
+	runtime.claimedThreads.set(threadId, claimed);
+	scheduleRetainedThreadEviction(client, runtime);
+	const release = async (releasedThreadId) => {
+		if (releasedThreadId !== threadId || runtime.claimedThreads.get(threadId) !== claimed) return;
+		const pendingRelease = runtime.releasingThreads.get(threadId);
+		if (pendingRelease) {
+			await pendingRelease.completion;
+			return;
+		}
+		const transition = { completion: Promise.resolve().then(async () => {
+			if (runtime.closed || runtime.claimedThreads.get(threadId) !== claimed) return;
+			await retained.release(releasedThreadId);
+		}) };
+		runtime.releasingThreads.set(threadId, transition);
 		try {
-			await release;
-		} catch (error) {
-			runtime.retainedThreadId = void 0;
-			runtime.retainedThreadConfigFingerprint = void 0;
-			throw error;
+			await transition.completion;
+			if (runtime.claimedThreads.get(threadId) === claimed) runtime.claimedThreads.delete(threadId);
 		} finally {
-			if (runtime.retainedThreadRelease === release) runtime.retainedThreadRelease = void 0;
+			if (runtime.releasingThreads.get(threadId) === transition) runtime.releasingThreads.delete(threadId);
 		}
+	};
+	physicalThreadReleases.set(release, retained.release);
+	claimedThreadReleaseTokens.set(release, claimed);
+	return {
+		configFingerprint: retained.configFingerprint,
+		serviceTier: retained.serviceTier,
+		release
+	};
+}
+/** Distinguish active claimed ownership from an already-evicted idle subscription. */
+function isCodexAppServerLiveThreadClaimed(client, threadId) {
+	const runtime = configuredClients.get(client);
+	return runtime !== void 0 && !runtime.closed && runtime.claimedThreads.has(threadId);
+}
+/** Release the exact physical subscription and finish only its observed claim generation. */
+async function unsubscribeCodexAppServerLiveThread(client, threadId, timeoutMs) {
+	const runtime = configuredClients.get(client);
+	const claimed = runtime?.claimedThreads.get(threadId);
+	let transition = runtime?.releasingThreads.get(threadId);
+	if (transition?.physicalRelease) {
+		await transition.physicalRelease;
+		return;
+	}
+	const physicalRelease = Promise.resolve().then(async () => {
+		if (claimed !== void 0 && runtime?.claimedThreads.get(threadId) !== claimed) return;
+		await client.request("thread/unsubscribe", { threadId }, { timeoutMs });
+	});
+	const ownsTransition = runtime !== void 0 && transition === void 0;
+	if (transition) transition.physicalRelease = physicalRelease;
+	else if (runtime) {
+		transition = {
+			completion: physicalRelease,
+			physicalRelease
+		};
+		runtime.releasingThreads.set(threadId, transition);
+	}
+	try {
+		await physicalRelease;
+		if (claimed !== void 0 && runtime?.claimedThreads.get(threadId) === claimed) runtime.claimedThreads.delete(threadId);
+	} finally {
+		if (ownsTransition && runtime.releasingThreads.get(threadId) === transition) runtime.releasingThreads.delete(threadId);
+	}
+}
+/** Reset/end owns the exact thread; failed generation retirement must never release its successor. */
+async function releaseCodexAppServerLiveThread(client, threadId) {
+	const runtime = configuredClients.get(client);
+	return runtime ? await releaseRetainedThread(client, runtime, threadId) : false;
+}
+/** Native child work pins its parent's subscription even after the foreground parent turn ends. */
+function protectCodexAppServerLiveThread(client, threadId) {
+	const runtime = configuredClients.get(client);
+	if (!runtime || runtime.closed) return () => void 0;
+	runtime.protectedThreads.set(threadId, (runtime.protectedThreads.get(threadId) ?? 0) + 1);
+	scheduleRetainedThreadEviction(client, runtime);
+	let protectedThread = true;
+	return () => {
+		if (!protectedThread) return;
+		protectedThread = false;
+		if (runtime.closed) return;
+		const count = runtime.protectedThreads.get(threadId) ?? 0;
+		if (count <= 1) {
+			runtime.protectedThreads.delete(threadId);
+			const retained = runtime.retainedThreads.get(threadId);
+			if (retained) {
+				runtime.retainedThreads.delete(threadId);
+				runtime.retainedThreads.set(threadId, {
+					...retained,
+					expiresAt: Date.now() + CODEX_APP_SERVER_LIVE_THREAD_IDLE_TIMEOUT_MS
+				});
+			}
+		} else runtime.protectedThreads.set(threadId, count - 1);
+		scheduleRetainedThreadEviction(client, runtime);
+		evictExcessIdleThreads(client, runtime).catch((error) => {
+			embeddedAgentLog.warn("codex retained thread unpin eviction failed", {
+				threadId,
+				reason: formatErrorMessage(error)
+			});
+		});
+	};
+}
+//#endregion
+//#region extensions/codex/src/app-server/elicitation-response.ts
+function createCodexElicitationResponse(action, content = null, meta = null) {
+	return {
+		action,
+		content,
+		_meta: meta
+	};
+}
+//#endregion
+//#region extensions/codex/src/app-server/rpc-error.ts
+/** RPC error wrapper that preserves app-server error code and data. */
+var CodexAppServerRpcError = class extends Error {
+	constructor(error, method) {
+		super(formatCodexAppServerRpcErrorMessage(error, method));
+		this.name = "CodexAppServerRpcError";
+		this.code = error.code;
+		this.data = error.data;
+		this.method = method;
 	}
-	runtime.retainedThreadId = threadId;
-	runtime.retainedThreadConfigFingerprint = configFingerprint;
-	return previousThreadId ? { previousThreadId } : {};
+};
+function formatCodexAppServerRpcErrorMessage(error, method) {
+	const message = error.message || `${method} failed`;
+	const detail = readCodexAppServerRpcReloginDetail(error.data);
+	return detail && !message.includes(detail) ? `${message}: ${detail}` : message;
 }
-/** A warm turn can skip resume only when this exact subscription was retained. */
-async function consumeCodexAppServerLiveThread(client, threadId, configFingerprint) {
-	const runtime = configuredClients.get(client);
-	if (!runtime) return false;
-	if (runtime.retainedThreadRelease) await runtime.retainedThreadRelease;
-	if (runtime.retainedThreadId !== threadId || configFingerprint !== void 0 && runtime.retainedThreadConfigFingerprint !== configFingerprint) return false;
-	runtime.retainedThreadId = void 0;
-	runtime.retainedThreadConfigFingerprint = void 0;
-	return true;
+function readCodexAppServerRpcReloginDetail(data) {
+	const record = isJsonObject(data) ? data : void 0;
+	const nested = isJsonObject(record?.error) ? record.error : record;
+	if (!nested) return;
+	const isRelogin = nested.action === "relogin" || nested.reason === "cloudRequirements" && nested.errorCode === "Auth";
+	const detail = typeof nested.detail === "string" ? nested.detail.trim() : "";
+	return isRelogin && detail ? detail : void 0;
 }
 //#endregion
 //#region extensions/codex/src/app-server/transport-websocket.ts
@@ -1189,6 +1802,10 @@ async function consumeCodexAppServerLiveThread(client, threadId, configFingerpri
 * Adapts a remote Codex app-server WebSocket endpoint to the shared stdio-like
 * transport interface.
 */
+const WEBSOCKET_HANDSHAKE_TIMEOUT_MS = 1e4;
+const WEBSOCKET_PING_INTERVAL_MS = 2e4;
+const WEBSOCKET_PONG_TIMEOUT_MS = 2e4;
+const MAX_CONSECUTIVE_MISSED_WEBSOCKET_PONGS = 5;
 /** Opens a WebSocket app-server transport and maps newline-delimited frames to stdout/stdin. */
 function createWebSocketTransport(options) {
 	if (!options.url) throw new Error("codex app-server websocket transport requires plugins.entries.codex.config.appServer.url");
@@ -1200,7 +1817,8 @@ function createWebSocketTransport(options) {
 			...options.headers,
 			...options.authToken ? { Authorization: `Bearer ${options.authToken}` } : {}
 		},
-		perMessageDeflate: false
+		perMessageDeflate: false,
+		...options.transport === "websocket" ? { handshakeTimeout: WEBSOCKET_HANDSHAKE_TIMEOUT_MS } : {}
 	};
 	const unixSocketPath = resolveCodexAppServerUnixSocketPath(options);
 	const socket = unixSocketPath ? new WebSocket("ws://localhost/", {
@@ -1211,6 +1829,58 @@ function createWebSocketTransport(options) {
 	const stdinDecoder = new StringDecoder("utf8");
 	let pendingLine = "";
 	let killed = false;
+	let pingTimeout;
+	let pongTimeout;
+	let expectedPong;
+	let consecutiveMissedPongs = 0;
+	let heartbeatSequence = 0;
+	const clearConnectionHealthTimers = () => {
+		if (pingTimeout) {
+			clearTimeout(pingTimeout);
+			pingTimeout = void 0;
+		}
+		if (pongTimeout) {
+			clearTimeout(pongTimeout);
+			pongTimeout = void 0;
+		}
+		expectedPong = void 0;
+	};
+	const sendHeartbeatPing = () => {
+		if (socket.readyState !== WebSocket.OPEN || pongTimeout) return;
+		const payload = Buffer.from(`openclaw-codex-${++heartbeatSequence}`);
+		expectedPong = payload;
+		pongTimeout = setTimeout(() => {
+			pongTimeout = void 0;
+			expectedPong = void 0;
+			consecutiveMissedPongs += 1;
+			if (consecutiveMissedPongs >= MAX_CONSECUTIVE_MISSED_WEBSOCKET_PONGS) {
+				socket.terminate();
+				return;
+			}
+			sendHeartbeatPing();
+		}, WEBSOCKET_PONG_TIMEOUT_MS);
+		pongTimeout.unref();
+		socket.ping(payload, void 0, (error) => {
+			if (error) socket.terminate();
+		});
+	};
+	const scheduleHeartbeatPing = () => {
+		if (options.transport !== "websocket" || socket.readyState !== WebSocket.OPEN || pingTimeout || pongTimeout) return;
+		pingTimeout = setTimeout(() => {
+			pingTimeout = void 0;
+			sendHeartbeatPing();
+		}, WEBSOCKET_PING_INTERVAL_MS);
+		pingTimeout.unref();
+	};
+	const recordConnectionActivity = () => {
+		consecutiveMissedPongs = 0;
+		if (pongTimeout) {
+			clearTimeout(pongTimeout);
+			pongTimeout = void 0;
+		}
+		expectedPong = void 0;
+		scheduleHeartbeatPing();
+	};
 	const sendFrame = (frame) => {
 		const trimmed = frame.trim();
 		if (!trimmed) return;
@@ -1222,13 +1892,22 @@ function createWebSocketTransport(options) {
 	};
 	socket.once("open", () => {
 		for (const frame of pendingFrames.splice(0)) socket.send(frame);
+		scheduleHeartbeatPing();
+	});
+	socket.on("pong", (payload) => {
+		if (expectedPong?.equals(payload)) recordConnectionActivity();
+	});
+	socket.once("error", (error) => {
+		clearConnectionHealthTimers();
+		events.emit("error", error);
 	});
-	socket.once("error", (error) => events.emit("error", error));
 	socket.once("close", (code, reason) => {
+		clearConnectionHealthTimers();
 		killed = true;
 		events.emit("exit", code, reason.toString("utf8"));
 	});
 	socket.on("message", (data) => {
+		if (options.transport === "websocket") recordConnectionActivity();
 		const text = websocketFrameToText(data);
 		stdout.write(text.endsWith("\n") ? text : `${text}\n`);
 	});
@@ -1262,6 +1941,7 @@ function createWebSocketTransport(options) {
 		},
 		kill: () => {
 			killed = true;
+			clearConnectionHealthTimers();
 			socket.close();
 		},
 		once: (event, listener) => events.once(event, listener)
@@ -1288,11 +1968,273 @@ function websocketFrameToText(data) {
 	return Buffer.from(data).toString("utf8");
 }
 //#endregion
+//#region extensions/codex/src/app-server/transport-process-containment.ts
+const PROCESS_COLUMNS = "pid=,ppid=,pgid=,stat=,lstart=";
+const MAX_CONTAINED_PROCESSES = 512;
+const MAX_PROCESS_CONTAINMENT_MS = 2e3;
+const MAX_PROCESS_QUIESCE_PASSES = 16;
+const PROCESS_INSPECTION_MAX_BYTES = 8 * 1024 * 1024;
+async function terminateCodexAppServerDescendants(child) {
+	const rootPid = child.pid;
+	if (process.platform === "win32" || !rootPid || !child.kill || hasExited(child)) return;
+	const deadline = Date.now() + MAX_PROCESS_CONTAINMENT_MS;
+	const snapshot = await readProcessSnapshot(deadline);
+	if (!snapshot || Date.now() >= deadline) return;
+	const root = snapshot.find((row) => row.pid === rootPid);
+	if (!root || !isSameLiveRoot(root, root)) return;
+	const initialDescendants = collectDescendants(snapshot, [rootPid]);
+	if (initialDescendants.length > MAX_CONTAINED_PROCESSES) return;
+	const stoppedDescendants = /* @__PURE__ */ new Map();
+	if (!await signalSameRoot(root, "SIGSTOP", deadline)) return;
+	let resumeRootOnUnwind = true;
+	try {
+		const descendants = await quiesceDescendants(root, initialDescendants, stoppedDescendants, deadline);
+		if (!descendants) return;
+		for (const descendant of descendants.toReversed()) {
+			if (Date.now() >= deadline) return;
+			if (!descendant.state.startsWith("Z")) {
+				if (!await signalSameProcess(descendant, "SIGKILL", deadline) || Date.now() >= deadline) return;
+			}
+		}
+		resumeRootOnUnwind = false;
+		let resumed = false;
+		return () => {
+			if (resumed) return;
+			resumed = true;
+			resumeTransportRoot(child, root, false);
+		};
+	} finally {
+		if (resumeRootOnUnwind) {
+			for (const descendant of stoppedDescendants.values()) signalProcess(descendant.pid, "SIGCONT");
+			resumeTransportRoot(child, root, true);
+		}
+	}
+}
+async function quiesceDescendants(root, initialDescendants, stopped, deadline) {
+	const provenByPid = new Map(initialDescendants.map((descendant) => [descendant.pid, descendant]));
+	const stopFailures = /* @__PURE__ */ new Map();
+	for (let pass = 0; pass < MAX_PROCESS_QUIESCE_PASSES; pass += 1) {
+		if (Date.now() >= deadline) return;
+		const snapshot = await readProcessSnapshot(deadline);
+		if (!snapshot || Date.now() >= deadline) return;
+		const currentRoot = snapshot.find((row) => row.pid === root.pid);
+		if (!currentRoot || !isSameLiveRoot(currentRoot, root)) return;
+		if (!isSameLiveRoot(currentRoot, root, true)) {
+			if (!await signalSameRoot(root, "SIGSTOP", deadline) || Date.now() >= deadline) return;
+			continue;
+		}
+		const snapshotByPid = new Map(snapshot.map((process) => [process.pid, process]));
+		const liveProven = [];
+		for (const proven of provenByPid.values()) {
+			const current = snapshotByPid.get(proven.pid);
+			if (!current) {
+				provenByPid.delete(proven.pid);
+				stopped.delete(identityKey(proven));
+				continue;
+			}
+			if (!hasSameIdentity(proven, current)) return;
+			provenByPid.set(current.pid, current);
+			const key = identityKey(current);
+			if (stopped.has(key)) stopped.set(key, current);
+			liveProven.push(current);
+		}
+		const descendants = collectDescendants(snapshot, [root.pid, ...liveProven.map(({ pid }) => pid)]);
+		for (const descendant of descendants) {
+			const proven = provenByPid.get(descendant.pid);
+			if (proven && !hasSameIdentity(proven, descendant)) return;
+			provenByPid.set(descendant.pid, descendant);
+		}
+		if (provenByPid.size > MAX_CONTAINED_PROCESSES) return;
+		const quiescenceTargets = new Map(liveProven.map((process) => [process.pid, process]));
+		for (const descendant of descendants) quiescenceTargets.set(descendant.pid, descendant);
+		let allStopped = true;
+		for (const descendant of quiescenceTargets.values()) {
+			if (Date.now() >= deadline) return;
+			if (isStoppedState(descendant.state)) continue;
+			const stopQueued = await signalSameProcess(descendant, "SIGSTOP", deadline);
+			if (Date.now() >= deadline) return;
+			if (stopQueued) {
+				stopFailures.delete(identityKey(descendant));
+				stopped.set(identityKey(descendant), descendant);
+			} else {
+				const key = identityKey(descendant);
+				const failures = (stopFailures.get(key) ?? 0) + 1;
+				if (failures >= 2) return;
+				stopFailures.set(key, failures);
+			}
+			if (!isUninterruptibleState(descendant.state) || !stopQueued) allStopped = false;
+		}
+		if (allStopped) return [...provenByPid.values()];
+	}
+}
+async function readProcessSnapshot(deadline) {
+	return await readProcesses(["-axo", PROCESS_COLUMNS], deadline);
+}
+async function readProcess(pid, deadline) {
+	return (await readProcesses([
+		"-o",
+		PROCESS_COLUMNS,
+		"-p",
+		String(pid)
+	], deadline))?.find((row) => row.pid === pid);
+}
+async function readProcesses(args, deadline) {
+	const remainingMs = deadline - Date.now();
+	if (remainingMs <= 0) return;
+	return await new Promise((resolve) => {
+		let settled = false;
+		const settle = (processes) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			resolve(processes);
+		};
+		const inspector = execFile("ps", args, {
+			encoding: "utf8",
+			maxBuffer: PROCESS_INSPECTION_MAX_BYTES
+		}, (error, stdout) => {
+			settle(error ? void 0 : parseProcesses(stdout));
+		});
+		const timer = setTimeout(() => {
+			settle(void 0);
+			inspector.stdout?.destroy();
+			inspector.stderr?.destroy();
+			inspector.kill("SIGKILL");
+			inspector.unref();
+		}, Math.max(1, remainingMs));
+		timer.unref?.();
+	});
+}
+function parseProcesses(output) {
+	const rows = [];
+	for (const line of output.split("\n")) {
+		const match = /^\s*(\d+)\s+(\d+)\s+(\d+)\s+(\S+)\s+(.+?)\s*$/.exec(line);
+		if (!match) continue;
+		const pid = Number(match[1] ?? "");
+		const ppid = Number(match[2] ?? "");
+		const pgid = Number(match[3] ?? "");
+		const startedAt = (match[5] ?? "").trim().replace(/\s+/g, " ");
+		if (![
+			pid,
+			ppid,
+			pgid
+		].every(Number.isSafeInteger) || pid <= 0 || ppid < 0 || pgid <= 0 || !startedAt) continue;
+		rows.push({
+			pid,
+			ppid,
+			pgid,
+			state: match[4] ?? "",
+			startedAt
+		});
+	}
+	return rows;
+}
+function collectDescendants(snapshot, rootPids) {
+	const childrenByParent = /* @__PURE__ */ new Map();
+	for (const row of snapshot) {
+		const children = childrenByParent.get(row.ppid) ?? [];
+		children.push(row);
+		childrenByParent.set(row.ppid, children);
+	}
+	const descendants = [];
+	const pending = [...new Set(rootPids)];
+	const seen = new Set(pending);
+	for (const parentPid of pending) for (const child of childrenByParent.get(parentPid) ?? []) {
+		if (seen.has(child.pid)) continue;
+		seen.add(child.pid);
+		descendants.push(child);
+		pending.push(child.pid);
+	}
+	return descendants;
+}
+function isStoppedState(state) {
+	return state.startsWith("T") || state.startsWith("t") || state.startsWith("Z");
+}
+function isQuiescedState(state) {
+	return isStoppedState(state) || isUninterruptibleState(state);
+}
+function isUninterruptibleState(state) {
+	return state.startsWith("D") || state.startsWith("U");
+}
+function isSameLiveProcess(current, expected) {
+	return current.pgid === expected.pgid && !current.state.startsWith("Z") && hasSameIdentity(current, expected);
+}
+function isSameLiveRoot(current, expected, requireStopped = false) {
+	return current.ppid === process.pid && (!requireStopped || isQuiescedState(current.state)) && isSameLiveProcess(current, expected);
+}
+async function signalSameRoot(root, signal, deadline) {
+	const current = await readProcess(root.pid, deadline);
+	return Boolean(current && isSameLiveRoot(current, root) && signalProcess(current.pid, signal));
+}
+function resumeTransportRoot(child, root, allowSynchronousPidFallback) {
+	try {
+		if (child.kill) {
+			child.kill("SIGCONT");
+			return;
+		}
+	} catch {
+		if (!allowSynchronousPidFallback) return;
+	}
+	if (allowSynchronousPidFallback) signalProcess(root.pid, "SIGCONT");
+}
+async function signalSameProcess(expected, signal, deadline) {
+	const current = await readProcess(expected.pid, deadline);
+	return Boolean(current && isSameLiveProcess(current, expected) && signalProcess(current.pid, signal));
+}
+function hasSameIdentity(left, right) {
+	return identityKey(left) === identityKey(right);
+}
+function identityKey(row) {
+	return `${row.pid}\0${row.startedAt}`;
+}
+function hasExited(child) {
+	return child.exitCode != null || child.signalCode != null;
+}
+function signalProcess(pid, signal) {
+	try {
+		process.kill(pid, signal);
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
 //#region extensions/codex/src/app-server/transport.ts
+/**
+* Shared transport lifecycle helpers for stdio and WebSocket Codex app-server
+* connections.
+*/
+const CODEX_APP_SERVER_TRANSPORT_CLOSES = /* @__PURE__ */ new WeakMap();
 /** Starts graceful transport shutdown and schedules a force kill fallback. */
 function closeCodexAppServerTransport(child, options = {}) {
-	child.stdin.end?.();
-	child.stdin.destroy?.();
+	beginCodexAppServerTransportClose(child, options);
+}
+function beginCodexAppServerTransportClose(child, options) {
+	const current = CODEX_APP_SERVER_TRANSPORT_CLOSES.get(child);
+	if (current) return current;
+	if (process.platform === "win32" || !child.pid || !child.kill || hasCodexAppServerTransportExited(child)) {
+		finishCodexAppServerTransportClose(child, options);
+		const completed = Promise.resolve();
+		CODEX_APP_SERVER_TRANSPORT_CLOSES.set(child, completed);
+		return completed;
+	}
+	const closing = (async () => {
+		let resumeRoot;
+		try {
+			resumeRoot = await terminateCodexAppServerDescendants(child);
+		} catch {
+			resumeRoot = void 0;
+		}
+		try {
+			finishCodexAppServerTransportClose(child, options, resumeRoot);
+		} catch {
+			signalCodexAppServerTransport(child, "SIGKILL");
+		}
+	})();
+	CODEX_APP_SERVER_TRANSPORT_CLOSES.set(child, closing);
+	return closing;
+}
+function finishCodexAppServerTransportClose(child, options, resumeRoot) {
 	const forceKillDelayMs = options.forceKillDelayMs ?? 1e3;
 	const forceKill = setTimeout(() => {
 		if (hasCodexAppServerTransportExited(child)) return;
@@ -1304,6 +2246,12 @@ function closeCodexAppServerTransport(child, options = {}) {
 		child.stdout.destroy?.();
 		child.stderr.destroy?.();
 	});
+	try {
+		child.stdin.end?.();
+		child.stdin.destroy?.();
+	} finally {
+		resumeRoot?.();
+	}
 	child.unref?.();
 	child.stdout.unref?.();
 	child.stderr.unref?.();
@@ -1311,7 +2259,7 @@ function closeCodexAppServerTransport(child, options = {}) {
 }
 /** Closes a transport and waits briefly for an exit event. */
 async function closeCodexAppServerTransportAndWait(child, options = {}) {
-	if (!hasCodexAppServerTransportExited(child)) closeCodexAppServerTransport(child, options);
+	if (!hasCodexAppServerTransportExited(child)) await beginCodexAppServerTransportClose(child, options);
 	return await waitForCodexAppServerTransportExit(child, options.exitTimeoutMs ?? 2e3);
 }
 function hasCodexAppServerTransportExited(child) {
@@ -1344,15 +2292,6 @@ function signalCodexAppServerTransport(child, signal) {
 	child.kill?.(signal);
 }
 //#endregion
-//#region extensions/codex/src/app-server/version.ts
-/**
-* Version and package pins for the managed Codex app-server runtime.
-*/
-/** Exact Codex app-server version shipped and supported by the OpenClaw Codex bridge. */
-const CODEX_APP_SERVER_VERSION = "0.146.0";
-/** npm package name for the managed Codex app-server binary. */
-const MANAGED_CODEX_APP_SERVER_PACKAGE = "@openai/codex";
-//#endregion
 //#region extensions/codex/src/app-server/client.ts
 /**
 * JSON-RPC client for Codex app-server transports, including request/response
@@ -1379,16 +2318,6 @@ function getCodexAppServerClientInstanceId(client) {
 function resolveCodexAppServerClientInstanceId(client) {
 	return client.getInstanceId?.call(client) ?? getCodexAppServerClientInstanceId(client);
 }
-/** RPC error wrapper that preserves app-server error code and data. */
-var CodexAppServerRpcError = class extends Error {
-	constructor(error, method) {
-		super(formatCodexAppServerRpcErrorMessage(error, method));
-		this.name = "CodexAppServerRpcError";
-		this.code = error.code;
-		this.data = error.data;
-		this.method = method;
-	}
-};
 var CodexAppServerLocalRequestCancellationError = class extends Error {
 	constructor(method, reason, mayHaveWritten) {
 		super(`${method} ${reason}`);
@@ -1431,22 +2360,6 @@ function isCodexAppServerPrewriteRequestCancellationError(error) {
 function isCodexAppServerIndeterminateTransportError(error) {
 	return error instanceof Error && "code" in error && error.code === "CODEX_APP_SERVER_REQUEST_TRANSPORT_INDETERMINATE" && "mayHaveWritten" in error && error.mayHaveWritten === true;
 }
-function formatCodexAppServerRpcErrorMessage(error, method) {
-	const message = error.message || `${method} failed`;
-	const detail = readCodexAppServerRpcReloginDetail(error.data);
-	return detail && !message.includes(detail) ? `${message}: ${detail}` : message;
-}
-function readCodexAppServerRpcReloginDetail(data) {
-	const record = isJsonObject(data) ? data : void 0;
-	const nested = isJsonObject(record?.error) ? record.error : record;
-	if (!nested) return;
-	const isRelogin = nested.action === "relogin" || nested.reason === "cloudRequirements" && nested.errorCode === "Auth";
-	const detail = typeof nested.detail === "string" ? nested.detail.trim() : "";
-	return isRelogin && detail ? detail : void 0;
-}
-function isJsonObject(value) {
-	return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
 /** Returns true for errors that mean the app-server transport is closed. */
 function isCodexAppServerConnectionClosedError(error) {
 	if (!(error instanceof Error)) return false;
@@ -1469,8 +2382,8 @@ var CodexAppServerClient = class CodexAppServerClient {
 		this.child = child;
 		this.lines = createInterface({ input: child.stdout });
 		this.lines.on("line", (line) => this.handleLine(line));
-		this.lines.on("error", (error) => this.closeWithError(error instanceof Error ? error : new Error(String(error))));
-		child.stdout.on("error", (error) => this.closeWithError(error instanceof Error ? error : new Error(String(error))));
+		this.lines.on("error", (error) => this.closeWithError(toStringifiedError(error)));
+		child.stdout.on("error", (error) => this.closeWithError(toStringifiedError(error)));
 		child.stderr.setEncoding("utf8");
 		child.stderr.on("data", (text) => {
 			this.stderrTail = appendBoundedTail(this.stderrTail, text, CODEX_APP_SERVER_STDERR_TAIL_MAX);
@@ -1480,12 +2393,12 @@ var CodexAppServerClient = class CodexAppServerClient {
 		child.stderr.on("error", (error) => {
 			embeddedAgentLog.warn("codex app-server stderr stream failed", { error });
 		});
-		child.once("error", (error) => this.closeWithError(error instanceof Error ? error : new Error(String(error))));
+		child.once("error", (error) => this.closeWithError(toStringifiedError(error)));
 		child.once("exit", (code, signal) => {
 			this.transportExited = true;
 			this.closeWithError(buildCodexAppServerExitError(code, signal, this.stderrTail));
 		});
-		child.stdin.on?.("error", (error) => this.closeWithError(error instanceof Error ? error : new Error(String(error))));
+		child.stdin.on?.("error", (error) => this.closeWithError(toStringifiedError(error)));
 	}
 	/** Starts a new app-server client using resolved runtime start options. */
 	static start(options) {
@@ -1512,7 +2425,13 @@ var CodexAppServerClient = class CodexAppServerClient {
 				title: "OpenClaw",
 				version: OPENCLAW_VERSION
 			},
-			capabilities: { experimentalApi: true }
+			capabilities: {
+				experimentalApi: true,
+				extensions: {
+					"openai/standard-form-input": {},
+					"openai/form": {}
+				}
+			}
 		});
 		this.serverVersion = assertSupportedCodexAppServerVersion(response);
 		this.runtimeIdentity = buildCodexAppServerRuntimeIdentity(response, this.serverVersion);
@@ -1531,6 +2450,10 @@ var CodexAppServerClient = class CodexAppServerClient {
 	getStderrDiagnostic() {
 		return redactCodexAppServerLinePreview(this.stderrTail) || void 0;
 	}
+	/** Returns the terminal transport error that closed this physical client. */
+	getCloseError() {
+		return this.closeError;
+	}
 	/** Stable generation id for this exact physical client instance. */
 	getInstanceId() {
 		return this.instanceId;
@@ -1700,7 +2623,7 @@ var CodexAppServerClient = class CodexAppServerClient {
 				onWriteAttempt?.();
 				this.writeMessage(message, (error) => rejectPending(error));
 			} catch (error) {
-				rejectPending(error instanceof Error ? error : new Error(String(error)));
+				rejectPending(toStringifiedError(error));
 			}
 		});
 	}
@@ -1871,7 +2794,7 @@ var CodexAppServerClient = class CodexAppServerClient {
 				result: defaultServerRequestResponse(request)
 			});
 		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
+			const message = coerceErrorMessage(error);
 			embeddedAgentLog.warn("codex app-server server request handler failed", {
 				id: request.id,
 				method: request.method,
@@ -1958,7 +2881,7 @@ function defaultServerRequestResponse(request) {
 		scope: "turn"
 	};
 	if (request.method === "item/tool/requestUserInput") return { answers: {} };
-	if (request.method === "mcpServer/elicitation/request") return { action: "decline" };
+	if (request.method === "mcpServer/elicitation/request") return createCodexElicitationResponse("decline", null, { message: "OpenClaw has no interactive handler for this elicitation." });
 	return {};
 }
 function stringifyCodexAppServerMessage(message) {
@@ -1978,24 +2901,30 @@ function timeoutServerRequestResponse(request) {
 var CodexAppServerVersionError = class extends Error {
 	constructor(detectedVersion) {
 		const detected = detectedVersion ? `detected ${detectedVersion}` : "OpenClaw could not determine the running Codex version";
-		super(`Codex app-server ${CODEX_APP_SERVER_VERSION} is required, but ${detected}. Update the configured Codex app-server binary, or remove custom command overrides to use the managed binary.`);
+		super(`Codex app-server ${MIN_SUPPORTED_CODEX_APP_SERVER_VERSION} or newer is required, but ${detected}. Update the configured Codex app-server binary, or remove custom command overrides to use the managed binary.`);
 		this.name = "CodexAppServerVersionError";
 		this.detectedVersion = detectedVersion;
 	}
 };
 function assertSupportedCodexAppServerVersion(response) {
 	const detectedVersion = readCodexVersionFromUserAgent(response.userAgent);
-	if (detectedVersion !== "0.146.0") throw new CodexAppServerVersionError(detectedVersion);
+	if (!detectedVersion) throw new CodexAppServerVersionError(detectedVersion);
+	const detected = parse(detectedVersion);
+	if (!detected || detected.compare("0.147.0") < 0) throw new CodexAppServerVersionError(detectedVersion);
+	if (detected.compare("0.149.1") > 0) embeddedAgentLog.warn("codex app-server is newer than OpenClaw's managed runtime; continuing with normal startup validation", {
+		detectedVersion,
+		validatedVersion: CODEX_APP_SERVER_VERSION
+	});
 	return detectedVersion;
 }
 function isUnsupportedCodexAppServerVersionError(error) {
 	return error instanceof CodexAppServerVersionError;
 }
 function buildCodexAppServerRuntimeIdentity(response, serverVersion) {
-	const userAgent = readNonEmptyInitializeString(response.userAgent);
-	const codexHome = readNonEmptyInitializeString(response.codexHome);
-	const platformFamily = readNonEmptyInitializeString(response.platformFamily);
-	const platformOs = readNonEmptyInitializeString(response.platformOs);
+	const userAgent = normalizeOptionalString(response.userAgent);
+	const codexHome = normalizeOptionalString(response.codexHome);
+	const platformFamily = normalizeOptionalString(response.platformFamily);
+	const platformOs = normalizeOptionalString(response.platformOs);
 	return {
 		serverVersion,
 		...userAgent ? { userAgent } : {},
@@ -2004,10 +2933,6 @@ function buildCodexAppServerRuntimeIdentity(response, serverVersion) {
 		...platformOs ? { platformOs } : {}
 	};
 }
-function readNonEmptyInitializeString(value) {
-	const trimmed = value?.trim();
-	return trimmed ? trimmed : void 0;
-}
 /** Extracts the Codex version from the app-server initialize user-agent field. */
 function readCodexVersionFromUserAgent(userAgent) {
 	return (userAgent?.match(/^[^/]+\/(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?)(?:[\s(]|$)/))?.[1];
@@ -2027,7 +2952,7 @@ function buildCodexAppServerExitError(code, signal, stderrTail) {
 }
 function shouldBufferCodexAppServerParseFailure(value, error) {
 	if (!value.startsWith("{") && !value.startsWith("[")) return false;
-	const message = error instanceof Error ? error.message : String(error);
+	const message = coerceErrorMessage(error);
 	return message.includes("Unterminated string") || message.includes("Unexpected end of JSON input");
 }
 function logCodexAppServerParseFailure(value, error, fragmentCount) {
@@ -2035,7 +2960,7 @@ function logCodexAppServerParseFailure(value, error, fragmentCount) {
 	const suffix = fragmentCount > 1 ? ` fragments=${fragmentCount}` : "";
 	embeddedAgentLog.warn("failed to parse codex app-server message", {
 		error,
-		errorMessage: error instanceof Error ? error.message : String(error),
+		errorMessage: coerceErrorMessage(error),
 		fragmentCount,
 		linePreview,
 		consoleMessage: `failed to parse codex app-server message${suffix}: preview=${JSON.stringify(linePreview)}`
@@ -2056,206 +2981,101 @@ function formatExitValue(value) {
 	return "unknown";
 }
 //#endregion
-//#region extensions/codex/src/app-server/managed-binary.ts
+//#region extensions/codex/src/app-server/attempt-timeouts.ts
 /**
-* Resolves the managed Codex app-server binary shipped with or installed beside
-* the Codex plugin before stdio startup.
+* Timeout defaults and normalizers for Codex app-server startup and turn
+* liveness watches.
 */
-const CODEX_PLUGIN_ROOT = resolveDefaultCodexPluginRoot(path.dirname(fileURLToPath(import.meta.url)));
-const MACOS_DESKTOP_CODEX_APP_SERVER_COMMANDS = ["/Applications/ChatGPT.app/Contents/Resources/codex", "/Applications/Codex.app/Contents/Resources/codex"];
-/** Rewrites managed stdio start options to point at an executable Codex binary path. */
-async function resolveManagedCodexAppServerStartOptions(startOptions, options = {}) {
-	if (startOptions.transport !== "stdio" || startOptions.commandSource !== "managed") return startOptions;
-	const platform = options.platform ?? process.platform;
-	const paths = resolveManagedCodexAppServerPaths({
-		platform,
-		pluginRoot: options.pluginRoot,
-		managedCommandOrder: startOptions.managedCommandOrder
-	});
-	const pathExists = options.pathExists ?? commandPathExists;
-	const commandPaths = await findManagedCodexAppServerCommandPaths({
-		candidateCommandPaths: paths.candidateCommandPaths,
-		pathExists,
-		platform
-	});
-	const commandPath = expectDefined(commandPaths[0], "resolved managed Codex command path");
-	const managedFallbackCommandPaths = commandPaths.slice(1);
-	return {
-		...startOptions,
-		command: commandPath,
-		commandSource: "resolved-managed",
-		...managedFallbackCommandPaths.length > 0 ? { managedFallbackCommandPaths } : {}
-	};
-}
-/** Resolves the native artifact behind a successful managed launcher selection. */
-function resolveManagedCodexNativeCommand(command, options = {}) {
-	const platform = options.platform ?? process.platform;
-	if (platform === "darwin" && MACOS_DESKTOP_CODEX_APP_SERVER_COMMANDS.some((candidate) => candidate === command)) return command;
-	const target = resolveCodexNativeTarget(platform, options.arch ?? process.arch);
-	if (!target) return;
-	const packageRoot = resolveManagedCodexPackageRootForCommand(command, platform);
-	if (!packageRoot) return;
-	const resolvePackageJson = options.resolvePackageJson ?? resolvePackageJsonFromRoot;
-	const pathExists = options.pathExists ?? existsSync;
-	for (const packageName of [target.packageName, MANAGED_CODEX_APP_SERVER_PACKAGE]) {
-		const packageJsonPath = resolvePackageJson(packageName, packageRoot);
-		if (!packageJsonPath) continue;
-		const candidate = path.join(path.dirname(packageJsonPath), "vendor", target.triple, "bin", platform === "win32" ? "codex.exe" : "codex");
-		if (pathExists(candidate)) return candidate;
-	}
-}
-function resolveManagedCodexPackageRootForCommand(command, platform) {
-	const pathApi = pathForPlatform(platform);
-	const commandPaths = [command];
-	try {
-		commandPaths.unshift(realpathSync(command));
-	} catch {}
-	for (const commandPath of commandPaths) {
-		let current = pathApi.dirname(commandPath);
-		while (true) {
-			if (pathApi.basename(current) === "codex" && pathApi.basename(pathApi.dirname(current)) === "@openai") return current;
-			if (pathApi.basename(current) === ".bin") return pathApi.join(pathApi.dirname(current), "@openai", "codex");
-			const parent = pathApi.dirname(current);
-			if (parent === current) break;
-			current = parent;
-		}
+/** Minimum startup timeout accepted by the Codex app-server harness. */
+const CODEX_APP_SERVER_STARTUP_TIMEOUT_FLOOR_MS = 100;
+/** Default idle timeout while waiting for app-server turn completion. */
+const CODEX_TURN_COMPLETION_IDLE_TIMEOUT_MS = 6e4;
+/** Short guard after apparent assistant completion. */
+const CODEX_TURN_ASSISTANT_COMPLETION_IDLE_TIMEOUT_MS = 1e4;
+const CODEX_POST_TOOL_RAW_ASSISTANT_COMPLETION_IDLE_TIMEOUT_MS = 5 * 6e4;
+/** Guard after reasoning/commentary progress when no tool handoff occurred. */
+const CODEX_POST_REASONING_REPLY_IDLE_TIMEOUT_MS = 5 * 6e4;
+/** Long terminal idle watch for app-server turns that never send completion. */
+const CODEX_TURN_TERMINAL_IDLE_TIMEOUT_MS = 30 * 6e4;
+var CodexAppServerStartupError = class extends Error {
+	constructor(reason, message = reason === "timed_out" ? "codex app-server startup timed out" : "codex app-server startup aborted") {
+		super(message);
+		this.reason = reason;
+		this.code = "CODEX_APP_SERVER_STARTUP_CANCELLED";
+		this.name = "CodexAppServerStartupError";
 	}
+};
+function isCodexAppServerStartupError(error, reason) {
+	return error instanceof Error && "code" in error && error.code === "CODEX_APP_SERVER_STARTUP_CANCELLED" && "reason" in error && (error.reason === "aborted" || error.reason === "timed_out") && (reason === void 0 || error.reason === reason);
 }
-function resolveCodexNativeTarget(platform, arch) {
-	if ((platform === "linux" || platform === "android") && arch === "x64") return {
-		packageName: "@openai/codex-linux-x64",
-		triple: "x86_64-unknown-linux-musl"
-	};
-	if ((platform === "linux" || platform === "android") && arch === "arm64") return {
-		packageName: "@openai/codex-linux-arm64",
-		triple: "aarch64-unknown-linux-musl"
-	};
-	if (platform === "darwin" && arch === "x64") return {
-		packageName: "@openai/codex-darwin-x64",
-		triple: "x86_64-apple-darwin"
-	};
-	if (platform === "darwin" && arch === "arm64") return {
-		packageName: "@openai/codex-darwin-arm64",
-		triple: "aarch64-apple-darwin"
-	};
-	if (platform === "win32" && arch === "x64") return {
-		packageName: "@openai/codex-win32-x64",
-		triple: "x86_64-pc-windows-msvc"
-	};
-	if (platform === "win32" && arch === "arm64") return {
-		packageName: "@openai/codex-win32-arm64",
-		triple: "aarch64-pc-windows-msvc"
-	};
+function resolvePositiveIntegerTimeoutMs(value, fallbackMs) {
+	return resolveTimerTimeoutMs(value, resolveTimerTimeoutMs(fallbackMs, 1));
 }
-function resolvePackageJsonFromRoot(packageName, root) {
+/** Runs startup work with abort and timeout handling plus optional cleanup. */
+async function withCodexStartupTimeout(params) {
+	if (params.signal.aborted) throw new CodexAppServerStartupError("aborted");
+	let timeout;
+	let abortCleanup;
+	let timeoutError;
+	let timeoutCleanup;
 	try {
-		return createRequire(path.join(root, "package.json")).resolve(`${packageName}/package.json`);
-	} catch {
-		return;
-	}
-}
-/** Returns the preferred and fallback managed Codex binary paths for a plugin root. */
-function resolveManagedCodexAppServerPaths(params) {
-	const platform = params.platform ?? process.platform;
-	const candidateCommandPaths = resolveManagedCodexAppServerCommandCandidates(params.pluginRoot ?? CODEX_PLUGIN_ROOT, platform, params.managedCommandOrder ?? "package-first");
-	return {
-		commandPath: candidateCommandPaths[0] ?? "",
-		candidateCommandPaths
-	};
-}
-function resolveManagedCodexAppServerCommandCandidates(pluginRoot, platform, managedCommandOrder) {
-	const pathApi = pathForPlatform(platform);
-	const commandName = platform === "win32" ? "codex.cmd" : "codex";
-	const roots = resolveManagedCodexAppServerCandidateRoots(pluginRoot, platform);
-	const packageCommandPaths = [...roots.map((root) => pathApi.join(root, "node_modules", ".bin", commandName)), ...resolveManagedCodexPackageBinCandidates(roots, platform)];
-	const desktopCommandPaths = resolveDesktopCodexAppServerCommandCandidates(platform);
-	const orderedCommandPaths = managedCommandOrder === "desktop-first" ? [...desktopCommandPaths, ...packageCommandPaths] : [...packageCommandPaths, ...desktopCommandPaths];
-	return [...new Set(orderedCommandPaths)];
-}
-function resolveDesktopCodexAppServerCommandCandidates(platform) {
-	return platform === "darwin" ? [...MACOS_DESKTOP_CODEX_APP_SERVER_COMMANDS] : [];
-}
-function resolveDefaultCodexPluginRoot(moduleDir) {
-	const moduleBaseName = path.basename(moduleDir);
-	if (moduleBaseName === "dist" || moduleBaseName === "dist-runtime") return path.dirname(moduleDir);
-	return path.resolve(moduleDir, "..", "..");
-}
-function resolveManagedCodexAppServerCandidateRoots(pluginRoot, platform) {
-	const pathApi = pathForPlatform(platform);
-	const directRoots = [
-		pluginRoot,
-		pathApi.dirname(pluginRoot),
-		pathApi.dirname(pathApi.dirname(pluginRoot)),
-		isDistExtensionRoot(pluginRoot, platform) ? pathApi.dirname(pathApi.dirname(pathApi.dirname(pluginRoot))) : null
-	].filter((root) => Boolean(root));
-	return [.../* @__PURE__ */ new Set([...directRoots, ...resolveNearestNodeModulesProjectRoots(directRoots, platform)])];
-}
-function resolveNearestNodeModulesProjectRoots(roots, platform) {
-	const pathApi = pathForPlatform(platform);
-	const projectRoots = [];
-	for (const root of roots) {
-		let current = pathApi.resolve(root);
-		while (true) {
-			if (pathApi.basename(current) === "node_modules") {
-				projectRoots.push(pathApi.dirname(current));
-				break;
-			}
-			const parent = pathApi.dirname(current);
-			if (parent === current) break;
-			current = parent;
+		return await Promise.race([params.operation(), new Promise((_, reject) => {
+			const rejectOnce = (error) => {
+				if (timeout) {
+					clearTimeout(timeout);
+					timeout = void 0;
+				}
+				reject(error);
+			};
+			timeout = setTimeout(() => {
+				timeoutError = new CodexAppServerStartupError("timed_out");
+				timeoutCleanup = Promise.resolve(params.onTimeout?.()).then(() => void 0, () => void 0);
+				timeoutCleanup.finally(() => {
+					rejectOnce(timeoutError);
+				});
+			}, params.timeoutMs);
+			const abortListener = () => rejectOnce(new CodexAppServerStartupError("aborted"));
+			params.signal.addEventListener("abort", abortListener, { once: true });
+			abortCleanup = () => params.signal.removeEventListener("abort", abortListener);
+		})]);
+	} catch (error) {
+		if (timeoutError) {
+			await timeoutCleanup;
+			throw timeoutError;
 		}
+		throw error;
+	} finally {
+		if (timeout) clearTimeout(timeout);
+		abortCleanup?.();
 	}
-	return projectRoots;
-}
-function resolveManagedCodexPackageBinCandidates(roots, platform) {
-	if (platform === "win32") return [];
-	const candidates = [];
-	for (const root of roots) {
-		const candidate = resolveManagedCodexPackageBinCandidate(root);
-		if (candidate) candidates.push(candidate);
-	}
-	return candidates;
 }
-function resolveManagedCodexPackageBinCandidate(root) {
-	try {
-		const packageJsonPath = createRequire(path.join(root, "package.json")).resolve(`${MANAGED_CODEX_APP_SERVER_PACKAGE}/package.json`);
-		const packageRoot = path.dirname(packageJsonPath);
-		const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
-		const binPath = typeof packageJson.bin === "string" ? packageJson.bin : isRecord(packageJson.bin) && typeof packageJson.bin.codex === "string" ? packageJson.bin.codex : null;
-		return binPath ? path.resolve(packageRoot, binPath) : null;
-	} catch {
-		return null;
-	}
+/** Resolves startup timeout while honoring the configured floor. */
+function resolveCodexStartupTimeoutMs(params) {
+	const timeoutFloorMs = resolvePositiveIntegerTimeoutMs(params.timeoutFloorMs, CODEX_APP_SERVER_STARTUP_TIMEOUT_FLOOR_MS);
+	const timeoutMs = resolvePositiveIntegerTimeoutMs(params.timeoutMs, timeoutFloorMs);
+	return Math.max(timeoutFloorMs, timeoutMs);
 }
-function isRecord(value) {
-	return typeof value === "object" && value !== null;
+/** Resolves the completion-idle timeout for an active turn. */
+function resolveCodexTurnCompletionIdleTimeoutMs(value) {
+	return resolvePositiveIntegerTimeoutMs(value, CODEX_TURN_COMPLETION_IDLE_TIMEOUT_MS);
 }
-function isDistExtensionRoot(pluginRoot, platform) {
-	const pathApi = pathForPlatform(platform);
-	const extensionsDir = pathApi.dirname(pluginRoot);
-	const distDir = pathApi.dirname(extensionsDir);
-	return pathApi.basename(extensionsDir) === "extensions" && (pathApi.basename(distDir) === "dist" || pathApi.basename(distDir) === "dist-runtime");
+/** Resolves the short assistant-completion release timeout. */
+function resolveCodexTurnAssistantCompletionIdleTimeoutMs(value) {
+	return resolvePositiveIntegerTimeoutMs(value, CODEX_TURN_ASSISTANT_COMPLETION_IDLE_TIMEOUT_MS);
 }
-function pathForPlatform(platform) {
-	return platform === "win32" ? path.win32 : path.posix;
+/** Resolves the conservative post-tool raw assistant guard timeout. */
+function resolveCodexPostToolRawAssistantCompletionIdleTimeoutMs(value, fallbackMs) {
+	return resolvePositiveIntegerTimeoutMs(value, Math.max(resolvePositiveIntegerTimeoutMs(void 0, fallbackMs), CODEX_POST_TOOL_RAW_ASSISTANT_COMPLETION_IDLE_TIMEOUT_MS));
 }
-async function findManagedCodexAppServerCommandPaths(params) {
-	const commandPaths = [];
-	for (const commandPath of params.candidateCommandPaths) if (await params.pathExists(commandPath, params.platform)) commandPaths.push(commandPath);
-	if (commandPaths.length > 0) return commandPaths;
-	throw new Error([
-		`Managed Codex app-server binary was not found for ${MANAGED_CODEX_APP_SERVER_PACKAGE}.`,
-		"Reinstall or update OpenClaw, or run pnpm install in a source checkout.",
-		"Set plugins.entries.codex.config.appServer.command or OPENCLAW_CODEX_APP_SERVER_BIN to use a custom Codex binary."
-	].join(" "));
+/** Resolves the long terminal turn idle timeout. */
+function resolveCodexTurnTerminalIdleTimeoutMs(value, runTimeoutOverrideMs) {
+	const explicitRunBudgetMs = resolvePositiveIntegerTimeoutMs(runTimeoutOverrideMs, CODEX_TURN_TERMINAL_IDLE_TIMEOUT_MS);
+	return resolvePositiveIntegerTimeoutMs(value, Math.max(CODEX_TURN_TERMINAL_IDLE_TIMEOUT_MS, explicitRunBudgetMs));
 }
-async function commandPathExists(filePath, platform) {
-	try {
-		await access(filePath, platform === "win32" ? constants.F_OK : constants.X_OK);
-		return true;
-	} catch {
-		return false;
-	}
+/** Adds gateway grace time to a caller timeout without overflowing invalid values. */
+function resolveCodexGatewayTimeoutWithGraceMs(timeoutMs, graceMs = 1e4) {
+	const timeout = resolvePositiveIntegerTimeoutMs(timeoutMs, 1);
+	return addTimerTimeoutGraceMs(timeout, resolveTimerTimeoutMs(graceMs, 0, 0)) ?? timeout;
 }
 //#endregion
 //#region extensions/codex/src/app-server/native-config-fence.ts
@@ -2325,6 +3145,9 @@ async function waitForPreviousFence(previous, options) {
 * Thin Codex app-server timeout adapter around OpenClaw's shared security
 * runtime timeout helper.
 */
+function resolveAbortError(signal) {
+	return signal.reason instanceof Error ? signal.reason : new Error("Codex app-server operation aborted", { cause: signal.reason });
+}
 /** Awaits a promise with a Codex-specific timeout error message. */
 async function withTimeout$1(promise, timeoutMs, timeoutMessage, createError) {
 	return await withTimeout(promise, timeoutMs, {
@@ -2332,6 +3155,22 @@ async function withTimeout$1(promise, timeoutMs, timeoutMessage, createError) {
 		...createError ? { createError } : {}
 	});
 }
+/** Bounds an operation by both its owner lifecycle and one total wall-clock budget. */
+async function withAbortableTimeout(params) {
+	const signal = params.signal;
+	if (signal?.aborted) throw resolveAbortError(signal);
+	let removeAbortListener;
+	const operation = signal ? Promise.race([params.promise, new Promise((_, reject) => {
+		const onAbort = () => reject(resolveAbortError(signal));
+		signal.addEventListener("abort", onAbort, { once: true });
+		removeAbortListener = () => signal.removeEventListener("abort", onAbort);
+	})]) : params.promise;
+	try {
+		return await withTimeout$1(operation, params.timeoutMs, params.timeoutMessage, params.createTimeoutError);
+	} finally {
+		removeAbortListener?.();
+	}
+}
 //#endregion
 //#region extensions/codex/src/app-server/shared-client.ts
 /**
@@ -2358,7 +3197,6 @@ var shared_client_exports = /* @__PURE__ */ __exportAll({
 	withLeasedCodexAppServerClientStartSelectionRetry: () => withLeasedCodexAppServerClientStartSelectionRetry
 });
 const CODEX_APP_SERVER_INITIALIZE_TIMEOUT_MESSAGE = "codex app-server initialize timed out";
-const suspectClosedClients = /* @__PURE__ */ new WeakSet();
 const SHARED_CODEX_APP_SERVER_CLIENT_STATE = Symbol.for("openclaw.codexAppServerClientState");
 const SHARED_CODEX_APP_SERVER_CLIENT_DISPOSER = Symbol.for("openclaw.codexAppServerClientDisposer");
 const CODEX_APP_SERVER_CLIENT_START_METADATA = Symbol.for("openclaw.codexAppServerClientStartMetadata");
@@ -2366,6 +3204,8 @@ function getSharedCodexAppServerClientState() {
 	const globalState = globalThis;
 	globalState[SHARED_CODEX_APP_SERVER_CLIENT_STATE] ??= {
 		clients: /* @__PURE__ */ new Map(),
+		liveClients: /* @__PURE__ */ new Set(),
+		entriesByClient: /* @__PURE__ */ new WeakMap(),
 		leasedReleases: /* @__PURE__ */ new WeakMap()
 	};
 	return globalState[SHARED_CODEX_APP_SERVER_CLIENT_STATE];
@@ -2480,9 +3320,11 @@ async function resolveCodexAppServerClientStartContext(options) {
 				startOptions: requestedStartOptions,
 				agentDir
 			})),
+			agentId: options?.agentId,
 			agentDir,
 			authProfileId: usesNativeAuth || preparedAuth?.kind === "api-key" ? null : authProfileId,
 			...resolvedPreparedAuth ? { preparedAuth: resolvedPreparedAuth } : {},
+			authRequirement,
 			config: options?.config,
 			pluginConfig: options?.pluginConfig,
 			...authProfileStore ? { authProfileStore } : {}
@@ -2725,14 +3567,21 @@ function createSharedCodexAppServerClientStartup(params) {
 		runtimeArtifactSignal: params.runtimeArtifactSignal,
 		config: params.config,
 		onStartedClient: (startedClient) => {
+			const state = getSharedCodexAppServerClientState();
 			params.entry.client = startedClient;
+			state.liveClients.add(startedClient);
+			startedClient.addCloseHandler((closedClient) => {
+				state.liveClients.delete(closedClient);
+				if (state.entriesByClient.get(closedClient) === params.entry) clearSharedClientEntryIfCurrent(params.key, closedClient);
+			});
 			for (const callback of params.entry.onStartedClientCallbacks) callback(startedClient);
 			retirePendingSharedClientEntryIfUnclaimed(params.key, params.entry);
 		},
 		onInitializedClient: () => initialized.resolve()
 	}).then((client) => {
+		const state = getSharedCodexAppServerClientState();
 		params.entry.client = client;
-		client.addCloseHandler((closedClient) => clearSharedClientEntryIfCurrent(params.key, closedClient));
+		state.entriesByClient.set(client, params.entry);
 		return client;
 	}, (error) => {
 		initialized.reject(error);
@@ -2772,7 +3621,7 @@ async function startInitializedCodexAppServerClient(params) {
 	const timeoutMs = params.timeoutMs ?? 0;
 	const startOptionsCandidates = resolveManagedFallbackStartOptions(params.startOptions);
 	for (const [index, startOptions] of startOptionsCandidates.entries()) {
-		const runtimeArtifactModule = params.runtimeArtifactMode ? await import("./runtime-artifact-CmtG_t1L.js") : void 0;
+		const runtimeArtifactModule = params.runtimeArtifactMode ? await import("./runtime-artifact-BvyT1uyd.js") : void 0;
 		const nativeCommandBeforeStart = startOptions.commandSource === "resolved-managed" ? resolveManagedCodexNativeCommand(startOptions.command) : void 0;
 		const runtimeArtifactBeforeStart = runtimeArtifactModule ? await runtimeArtifactModule.captureCodexAppServerRuntimeArtifactBeforeStart({
 			startOptions,
@@ -2922,11 +3771,9 @@ function retireSharedCodexAppServerClientIfCurrent(client, opts) {
 		entry.closeWhenIdle = true;
 		if (opts?.failActiveLeases) {
 			entry.closeError = /* @__PURE__ */ new Error("codex app-server client is closed");
-			const closed = closeRetiredSharedClientEntry(entry);
-			if (closed) suspectClosedClients.add(client);
 			return {
 				activeLeases: entry.activeLeases,
-				closed
+				closed: closeRetiredSharedClientEntry(entry)
 			};
 		}
 		const closed = closeRetiredSharedClientEntryIfIdle(entry);
@@ -2935,18 +3782,17 @@ function retireSharedCodexAppServerClientIfCurrent(client, opts) {
 			closed
 		};
 	}
-	const activeLeases = state.leasedReleases.get(client)?.length ?? 0;
-	if (activeLeases > 0) {
-		if (opts?.failActiveLeases && !suspectClosedClients.has(client)) {
-			suspectClosedClients.add(client);
-			client.close();
+	const detachedEntry = state.entriesByClient.get(client);
+	if (detachedEntry && (detachedEntry.client === client || detachedEntry.closeError)) {
+		if (opts?.failActiveLeases && !detachedEntry.closeError) {
+			detachedEntry.closeError = /* @__PURE__ */ new Error("codex app-server client is closed");
 			return {
-				activeLeases,
-				closed: true
+				activeLeases: detachedEntry.activeLeases,
+				closed: closeRetiredSharedClientEntry(detachedEntry)
 			};
 		}
 		return {
-			activeLeases,
+			activeLeases: detachedEntry.activeLeases,
 			closed: false
 		};
 	}
@@ -3063,7 +3909,7 @@ function retirePendingSharedClientEntryIfUnclaimed(key, entry) {
 	closeRetiredSharedClientEntry(entry);
 }
 function collectSharedClients(state) {
-	return [...new Set([...state.clients.values()].map((entry) => entry.client).filter((client) => Boolean(client)))];
+	return [...state.liveClients];
 }
 //#endregion
-export { resolveCodexTurnAssistantCompletionIdleTimeoutMs as $, retainCodexAppServerLiveThread as A, CODEX_INTERACTIVE_CUSTOM_THREAD_SOURCES as B, isCodexAppServerIndeterminateRequestCancellationError as C, resolveCodexAppServerClientInstanceId as D, isCodexAppServerRequestTimeoutError as E, resolveCodexAppServerAuthProfileId as F, resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath as G, CODEX_OPENCLAW_DIRECT_DYNAMIC_TOOL_NAMESPACE as H, resolveCodexAppServerAuthProfileIdForAgent as I, CodexAppServerStartupError as J, resolveCodexAppServerHomeDir as K, resolveCodexAppServerFallbackApiKeyCacheKey as L, readRecentCodexRateLimits as M, rememberCodexRateLimitsRead as N, consumeCodexAppServerLiveThread as O, resolveCodexAppServerAuthAccountCacheKey as P, resolveCodexStartupTimeoutMs as Q, resolveCodexAppServerPreparedApiKeyCacheKey as R, isCodexAppServerConnectionClosedError as S, isCodexAppServerPrewriteRequestCancellationError as T, flattenCodexDynamicToolFunctions as U, CODEX_INTERACTIVE_THREAD_SOURCE_KINDS as V, isJsonObject$1 as W, resolveCodexGatewayTimeoutWithGraceMs as X, isCodexAppServerStartupError as Y, resolveCodexPostToolRawAssistantCompletionIdleTimeoutMs as Z, acquireCodexNativeConfigFence as _, getLeasedSharedCodexAppServerClient as a, isCodexAppServerApprovalRequest as b, releaseCodexAppServerClientLease as c, retainSharedCodexAppServerClientByInstanceId as d, resolveCodexTurnCompletionIdleTimeoutMs as et, retainSharedCodexAppServerClientIfCurrent as f, withTimeout$1 as g, withLeasedCodexAppServerClientStartSelectionRetry as h, createIsolatedCodexAppServerClient as i, readCodexRateLimitsRevision as j, ensureCodexAppServerClientRuntime as k, releaseLeasedSharedCodexAppServerClient as l, shared_client_exports as m, clearSharedCodexAppServerClientIfCurrentAndUnclaimed as n, withCodexStartupTimeout as nt, getSharedCodexAppServerClient as o, retireSharedCodexAppServerClientIfCurrent as p, CODEX_POST_REASONING_REPLY_IDLE_TIMEOUT_MS as q, clearSharedCodexAppServerClientIfCurrentAndWait as r, isCodexAppServerStartSelectionChangedError as s, clearSharedCodexAppServerClientIfCurrent as t, resolveCodexTurnTerminalIdleTimeoutMs as tt, resolveCodexNativeConfigFenceKey as u, CodexAppServerRpcError as v, isCodexAppServerIndeterminateTransportError as w, isCodexAppServerBrokenPipeError as x, getCodexAppServerClientInstanceId as y, resolveCodexAppServerPreparedAuthHandoff as z };
+export { rememberCodexRateLimitsRead as $, isCodexAppServerApprovalRequest as A, CodexAppServerRpcError as B, resolveCodexPostToolRawAssistantCompletionIdleTimeoutMs as C, resolveCodexTurnTerminalIdleTimeoutMs as D, resolveCodexTurnCompletionIdleTimeoutMs as E, isCodexAppServerPrewriteRequestCancellationError as F, isCodexAppServerClientRuntimeLive as G, claimCodexAppServerLiveThread as H, isCodexAppServerRequestTimeoutError as I, releaseCodexAppServerLiveThread as J, isCodexAppServerLiveThreadClaimed as K, isUnsupportedCodexAppServerVersionError as L, isCodexAppServerConnectionClosedError as M, isCodexAppServerIndeterminateRequestCancellationError as N, withCodexStartupTimeout as O, isCodexAppServerIndeterminateTransportError as P, readRecentCodexRateLimits as Q, resolveCodexAppServerClientInstanceId as R, resolveCodexGatewayTimeoutWithGraceMs as S, resolveCodexTurnAssistantCompletionIdleTimeoutMs as T, consumeCodexAppServerLiveThread as U, createCodexElicitationResponse as V, ensureCodexAppServerClientRuntime as W, unsubscribeCodexAppServerLiveThread as X, retainCodexAppServerLiveThread as Y, readCodexRateLimitsRevision as Z, withTimeout$1 as _, getLeasedSharedCodexAppServerClient as a, resolveCodexAppServerPreparedAuthHandoff as at, CodexAppServerStartupError as b, releaseCodexAppServerClientLease as c, CODEX_OPENCLAW_DIRECT_DYNAMIC_TOOL_NAMESPACE as ct, retainSharedCodexAppServerClientByInstanceId as d, resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath as dt, resolveCodexAppServerAuthAccountCacheKey as et, retainSharedCodexAppServerClientIfCurrent as f, resolveCodexAppServerHomeDir as ft, withAbortableTimeout as g, withLeasedCodexAppServerClientStartSelectionRetry as h, createIsolatedCodexAppServerClient as i, resolveCodexAppServerPreparedApiKeyCacheKey as it, isCodexAppServerBrokenPipeError as j, getCodexAppServerClientInstanceId as k, releaseLeasedSharedCodexAppServerClient as l, flattenCodexDynamicToolFunctions as lt, shared_client_exports as m, clearSharedCodexAppServerClientIfCurrentAndUnclaimed as n, resolveCodexAppServerAuthProfileIdForAgent as nt, getSharedCodexAppServerClient as o, CODEX_INTERACTIVE_CUSTOM_THREAD_SOURCES as ot, retireSharedCodexAppServerClientIfCurrent as p, resolveCodexAppServerLocalHomeDir as pt, protectCodexAppServerLiveThread as q, clearSharedCodexAppServerClientIfCurrentAndWait as r, resolveCodexAppServerFallbackApiKeyCacheKey as rt, isCodexAppServerStartSelectionChangedError as s, CODEX_INTERACTIVE_THREAD_SOURCE_KINDS as st, clearSharedCodexAppServerClientIfCurrent as t, resolveCodexAppServerAuthProfileId as tt, resolveCodexNativeConfigFenceKey as u, isJsonObject as ut, acquireCodexNativeConfigFence as v, resolveCodexStartupTimeoutMs as w, isCodexAppServerStartupError as x, CODEX_POST_REASONING_REPLY_IDLE_TIMEOUT_MS as y, closeCodexAppServerTransportAndWait as z };