@openclaw/codex 2026.9.6 → 2026.9.7

package/dist/.setup/{client-Cs08OXVQ.mjs → client-N0JpgSzF.mjs}

@@ -1,34 +1,32 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
-import { p as resolveCodexAppServerUserHomeDir } from "./config-security-BEReZ6go.mjs";
-import { d as recordCodexCatalogResponseSource, i as reuseCodexCatalogPreview, o as closeCodexCatalogClientSource, s as codexCatalogSourceForClient } from "./session-catalog-native-projection-DowriLid.mjs";
-import { a as stringifyCodexAppServerMessage, c as isRpcResponse, i as readCodexCatalogDecodeRoute, n as projectCodexCatalogMessage, o as CodexAppServerMessageDecoder, r as listenCodexAppServerLines, s as redactCodexAppServerLinePreview } from "./client-catalog-response-BMgt_4q4.mjs";
+import { a as stringifyCodexAppServerMessage, c as isRpcResponse, i as readCodexCatalogDecodeRoute, n as projectCodexCatalogMessage, o as CodexAppServerMessageDecoder, r as listenCodexAppServerLines, s as redactCodexAppServerLinePreview } from "./client-catalog-response-5HHLdcde.mjs";
 import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
-import { c as MIN_SUPPORTED_CODEX_APP_SERVER_VERSION, s as CODEX_APP_SERVER_VERSION } from "./managed-binary-BnshlFag.mjs";
-import { a as closeCodexAppServerTransportAndWait, i as closeCodexAppServerTransport, o as hasCodexAppServerNaturalExit, t as createStdioTransport } from "./transport-stdio-h2VHOskC.mjs";
-import { a as CODEX_APP_SERVER_OVERLOADED_ERROR_CODE, o as CodexAppServerRpcError } from "./timeout-C910MdAB.mjs";
-import "./config-BoTP_mrL.mjs";
-import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-C8Rw1m1m.mjs";
+import { c as MIN_SUPPORTED_CODEX_APP_SERVER_VERSION, s as CODEX_APP_SERVER_VERSION } from "./managed-binary-kiWRhNRE.mjs";
+import { a as closeCodexAppServerTransportAndWait, i as closeCodexAppServerTransport, o as hasCodexAppServerNaturalExit, t as createStdioTransport } from "./transport-stdio-Bdegpn2V.mjs";
+import { n as CodexAppServerRpcError, t as CODEX_APP_SERVER_OVERLOADED_ERROR_CODE } from "./rpc-error-BlD2vuzn.mjs";
+import { f as recordCodexCatalogResponseSource, i as reuseCodexCatalogPreview, o as closeCodexCatalogClientSource, s as codexCatalogSourceForClient } from "./session-catalog-native-projection-DjhwGL6x.mjs";
+import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-C0NbLms1.mjs";
 import { codexCatalogPageWorkerEntrypoint } from "../catalog-page-worker-entrypoint.js";
+import { t as createWebSocketTransport } from "./transport-websocket-BTBE-LD9.mjs";
+import { t as __exportAll } from "./session-binding-sidecars-jo6H8dFr.mjs";
 import { isRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { randomUUID } from "node:crypto";
-import { addSafeTimeoutDelayGraceMs, addTimerTimeoutGraceMs, parseStrictNonNegativeInteger } from "openclaw/plugin-sdk/number-runtime";
 import { normalizeJsonSchemaForTypeBox } from "openclaw/plugin-sdk/json-schema-runtime";
+import { addSafeTimeoutDelayGraceMs, addTimerTimeoutGraceMs, parseStrictNonNegativeInteger } from "openclaw/plugin-sdk/number-runtime";
 import path from "node:path";
-import { EventEmitter } from "node:events";
 import { coerceErrorMessage, toStringifiedError } from "openclaw/plugin-sdk/error-runtime";
 import { sliceUtf16Safe, truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
+import { AsyncLocalStorage } from "node:async_hooks";
 import { hasPendingInternalDiagnosticEvent } from "openclaw/plugin-sdk/diagnostic-runtime";
 import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
 import { OPENCLAW_VERSION, embeddedAgentLog, formatToolExecutionErrorMessage, normalizeQuestionTimeoutSeconds, resolveToolExecutionErrorKind } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { parse } from "semver";
+import { AsyncWorkScope } from "openclaw/plugin-sdk/concurrency-runtime";
 import { copyInternalToolResultState, runWithAsyncWorkResources } from "openclaw/plugin-sdk/agent-harness-tool-runtime";
 import { Compile } from "typebox/compile";
-import net from "node:net";
-import { PassThrough, Writable } from "node:stream";
-import { StringDecoder } from "node:string_decoder";
-import { WebSocket } from "openclaw/plugin-sdk/websocket-runtime";
 //#region extensions/codex/src/app-server/client-catalog-worker.ts
 const INLINE_CATALOG_MAX_BYTES = 65536;
+const CATALOG_WORKER_IDLE_MS = 6e4;
+const runInCatalogWorkerContext = AsyncLocalStorage.snapshot();
 /** Late responses retain their decode route after cancellation removes the waiter. */
 function codexCatalogRequestId(method, params, sequence, catalogPreview) {
 	const kind = catalogPreview ? method === "thread/list" ? "list" : method === "thread/read" && isJsonObject(params) && params.includeTurns !== true ? "thread" : void 0 : void 0;
@@ -37,6 +35,8 @@ function codexCatalogRequestId(method, params, sequence, catalogPreview) {
 /** Each physical client owns one decoder, including incomplete-line recovery state. */
 var CodexCatalogWorker = class {
 	constructor() {
+		this.setTimeoutFn = setTimeout;
+		this.clearTimeoutFn = clearTimeout;
 		this.closed = false;
 	}
 	get continuation() {
@@ -60,6 +60,10 @@ var CodexCatalogWorker = class {
 				}, projection?.preview);
 			}
 		}
+		this.clearTimeoutFn(this.idleTimer);
+		this.idleTimer = void 0;
+		await this.retirement;
+		if (this.closed) return;
 		if (!this.pool) {
 			const { resolveRuntimeWorkerUrl, WorkerTaskPool } = await import("openclaw/plugin-sdk/process-runtime");
 			if (this.closed) return;
@@ -94,12 +98,24 @@ var CodexCatalogWorker = class {
 		});
 		if (this.closed) return;
 		this.continuationRoute = decoded.pending ? route : void 0;
+		if (!decoded.pending) this.armIdleRetirement();
 		return decoded;
 	}
-	close(error) {
+	armIdleRetirement() {
+		this.idleTimer = runInCatalogWorkerContext(() => this.setTimeoutFn(() => {
+			this.idleTimer = void 0;
+			this.retirement = this.pool?.rotate();
+			this.retirement?.catch(() => void 0);
+		}, CATALOG_WORKER_IDLE_MS));
+		this.idleTimer.unref();
+	}
+	async close(error) {
 		this.closed = true;
+		this.clearTimeoutFn(this.idleTimer);
+		this.idleTimer = void 0;
 		this.continuationRoute = void 0;
-		return this.pool?.close(error) ?? Promise.resolve();
+		await this.retirement?.catch(() => void 0);
+		await this.pool?.close(error);
 	}
 };
 //#endregion
@@ -198,6 +214,19 @@ function buildCodexAppServerInitializeParams() {
 		}
 	};
 }
+function buildCodexAppServerRuntimeIdentity(response, serverVersion) {
+	const userAgent = normalizeOptionalString(response.userAgent);
+	const codexHome = normalizeOptionalString(response.codexHome);
+	const platformFamily = normalizeOptionalString(response.platformFamily);
+	const platformOs = normalizeOptionalString(response.platformOs);
+	return {
+		serverVersion,
+		...userAgent ? { userAgent } : {},
+		...codexHome ? { codexHome } : {},
+		...platformFamily ? { platformFamily } : {},
+		...platformOs ? { platformOs } : {}
+	};
+}
 //#endregion
 //#region extensions/codex/src/app-server/client-response.ts
 /** Settles one wire attempt and reports newly observed native execution. */
@@ -232,14 +261,13 @@ function dispatchCodexAppServerResponse(response, attempts, catalogResponses, so
 }
 //#endregion
 //#region extensions/codex/src/app-server/request-attempt.ts
-/** One wire attempt; local waiter expiry need not imply a native response. */
+/** One caller per wire attempt; local waiter expiry need not imply a native response. */
 function createCodexRequestAttempt(params) {
 	let pending = true;
 	let mayHaveWritten = false;
-	const waiters = /* @__PURE__ */ new Set();
+	let waiter;
 	const diagnostics = params.diagnosticIdentity ? {
 		...params.diagnosticIdentity,
-		waiterOrdinal: 0,
 		attemptCreatedAtMs: performance.now(),
 		firstPossibleWriteAtMs: null,
 		wireOutcomeAtWaiterSettlement: "retained-pending",
@@ -255,27 +283,8 @@ function createCodexRequestAttempt(params) {
 		params.onSettled();
 		return true;
 	};
-	const rejectWaiters = (error, outcome) => {
-		for (const waiter of waiters) waiter.reject(error, outcome);
-	};
-	const currentWaiterError = (waiter) => {
-		if (!params.retainWritten) return;
-		if (waiter.signal?.aborted) return {
-			error: params.cancellationError("aborted", mayHaveWritten, waiter.signal.reason),
-			outcome: "aborted"
-		};
-		if (waiter.deadline !== void 0 && performance.now() >= waiter.deadline) return {
-			error: params.cancellationError("timed out", mayHaveWritten),
-			outcome: "timed-out"
-		};
-		try {
-			waiter.assertCurrent?.();
-		} catch (error) {
-			return {
-				error: toStringifiedError(error),
-				outcome: "authority-rejected"
-			};
-		}
+	const currentWaiterError = () => {
+		if (!params.retainWritten || !waiter) return;
 		if (waiter.signal?.aborted) return {
 			error: params.cancellationError("aborted", mayHaveWritten, waiter.signal.reason),
 			outcome: "aborted"
@@ -291,7 +300,7 @@ function createCodexRequestAttempt(params) {
 			return pending;
 		},
 		wait(options, deadline) {
-			const { timeoutMs, signal, assertCurrent, disposition, overloadAttemptOrdinal } = options;
+			const { timeoutMs, signal, overloadAttemptOrdinal } = options;
 			let observe = options.attemptWaiterFinished;
 			return new Promise((resolve, reject) => {
 				if (!pending) {
@@ -300,7 +309,6 @@ function createCodexRequestAttempt(params) {
 				}
 				let timer;
 				let removeAbort;
-				const waiterOrdinal = diagnostics ? ++diagnostics.waiterOrdinal : 0;
 				const waiterAttachedAtMs = diagnostics && observe ? performance.now() : 0;
 				const cleanup = () => {
 					clearTimeout(timer);
@@ -309,16 +317,17 @@ function createCodexRequestAttempt(params) {
 					removeAbort = void 0;
 				};
 				const detach = (waiterOutcome) => {
-					if (!waiters.delete(waiter)) return false;
+					if (!waiter) return false;
+					waiter = void 0;
 					cleanup();
-					if (waiters.size === 0 && (!params.retainWritten || !mayHaveWritten)) finish(mayHaveWritten ? "correlation-closed" : "not-written");
+					if (!params.retainWritten || !mayHaveWritten) finish(mayHaveWritten ? "correlation-closed" : "not-written");
 					const callback = observe;
 					observe = void 0;
 					if (diagnostics && callback) try {
 						callback({
 							...diagnostics,
-							waiterOrdinal,
-							disposition,
+							waiterOrdinal: 1,
+							disposition: "new",
 							overloadAttemptOrdinal,
 							waiterAttachedAtMs,
 							waiterSettledAtMs: performance.now(),
@@ -327,7 +336,7 @@ function createCodexRequestAttempt(params) {
 					} catch {}
 					return true;
 				};
-				const waiter = {
+				const localWaiter = {
 					resolve: (value) => {
 						if (!detach("resolved")) return;
 						resolve(value);
@@ -335,25 +344,21 @@ function createCodexRequestAttempt(params) {
 					reject: (error, outcome) => {
 						if (detach(outcome)) reject(error);
 					},
-					cleanup,
 					signal,
-					...params.retainWritten ? {
-						deadline,
-						assertCurrent
-					} : {}
+					deadline
 				};
-				waiters.add(waiter);
+				waiter = localWaiter;
 				if (params.retainWritten && deadline !== void 0 && performance.now() >= deadline) {
-					waiter.reject(params.cancellationError("timed out", mayHaveWritten), "timed-out");
+					localWaiter.reject(params.cancellationError("timed out", mayHaveWritten), "timed-out");
 					return;
 				}
 				if (timeoutMs && Number.isFinite(timeoutMs) && timeoutMs > 0) {
 					const remaining = params.retainWritten && deadline !== void 0 ? deadline - performance.now() : timeoutMs;
-					timer = setTimeout(() => waiter.reject(params.cancellationError("timed out", mayHaveWritten), "timed-out"), Math.max(params.retainWritten ? 1 : 100, remaining));
+					timer = setTimeout(() => localWaiter.reject(params.cancellationError("timed out", mayHaveWritten), "timed-out"), Math.max(params.retainWritten ? 1 : 100, remaining));
 					timer.unref?.();
 				}
 				if (signal) {
-					const abort = () => waiter.reject(params.cancellationError("aborted", mayHaveWritten, signal.reason), "aborted");
+					const abort = () => localWaiter.reject(params.cancellationError("aborted", mayHaveWritten, signal.reason), "aborted");
 					signal.addEventListener("abort", abort, { once: true });
 					removeAbort = () => signal.removeEventListener("abort", abort);
 					if (signal.aborted) abort();
@@ -363,36 +368,29 @@ function createCodexRequestAttempt(params) {
 		resolve(value) {
 			if (!finish("native-ok")) return;
 			params.onResponse?.(mayHaveWritten);
-			for (const waiter of waiters) {
-				const error = currentWaiterError(waiter);
-				if (error) waiter.reject(error.error, error.outcome);
-				else waiter.resolve(value);
-			}
+			const error = currentWaiterError();
+			if (error) waiter?.reject(error.error, error.outcome);
+			else waiter?.resolve(value);
 		},
 		reject(error, definitelyNotEnqueued = false) {
 			if (finish(definitelyNotEnqueued ? "ingress-rejected" : "native-error")) {
 				if (definitelyNotEnqueued) mayHaveWritten = false;
 				params.onResponse?.(mayHaveWritten);
-				for (const waiter of waiters) {
-					const current = currentWaiterError(waiter);
-					waiter.reject(current?.error ?? params.localError(error, mayHaveWritten), current?.outcome ?? "native-error");
-				}
+				const current = currentWaiterError();
+				waiter?.reject(current?.error ?? params.localError(error, mayHaveWritten), current?.outcome ?? "native-error");
 			}
 		},
 		close(error) {
-			if (finish("correlation-closed")) rejectWaiters(params.localError(error, mayHaveWritten), "client-closed");
+			if (finish("correlation-closed")) waiter?.reject(params.localError(error, mayHaveWritten), "client-closed");
 		},
 		failLocal(error) {
 			if (!pending) return;
 			if (!params.retainWritten || !mayHaveWritten) finish(mayHaveWritten ? "correlation-closed" : "not-written");
-			rejectWaiters(params.localError(error, mayHaveWritten), "local-failed");
+			waiter?.reject(params.localError(error, mayHaveWritten), "local-failed");
 		},
 		markWritten() {
 			mayHaveWritten = true;
 			if (diagnostics && diagnostics.firstPossibleWriteAtMs === null) diagnostics.firstPossibleWriteAtMs = performance.now();
-		},
-		cleanup() {
-			for (const waiter of waiters) waiter.cleanup();
 		}
 	};
 }
@@ -452,21 +450,13 @@ function resolveCodexToolAbortTerminalReason(signal) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/dynamic-tool-execution.ts
-/**
-* Timeout, terminal-release, and diagnostic helpers for Codex dynamic tool
-* calls.
-*/
-/** Default timeout for Codex dynamic tool calls. */
 const CODEX_DYNAMIC_TOOL_TIMEOUT_MS = 9e4;
-/** Hard cap for ordinary per-call Codex dynamic tool timeout overrides. */
 const CODEX_DYNAMIC_TOOL_MAX_TIMEOUT_MS = 6e5;
 const CODEX_DYNAMIC_TOOL_TIMEOUT_SECONDS_GRACE_MS = 3e4;
 const CODEX_DYNAMIC_IMAGE_GENERATION_TOOL_TIMEOUT_MS = 12e4;
 const CODEX_DYNAMIC_COMPUTER_GATEWAY_TIMEOUT_MS = 3e4;
 const CODEX_DYNAMIC_COMPUTER_COMPLETION_GRACE_MS = 3e4;
-/** Timeout for image-understanding style dynamic tool calls. */
 const CODEX_DYNAMIC_IMAGE_TOOL_TIMEOUT_MS = 6e4;
-/** Timeout for message-delivery dynamic tool calls. */
 const CODEX_DYNAMIC_MESSAGE_TOOL_TIMEOUT_MS = 6e5;
 /** Outer default for collector waits: full swarm budget plus completion grace. */
 const CODEX_DYNAMIC_AGENTS_WAIT_TOOL_TIMEOUT_MS = 63e4;
@@ -576,16 +566,7 @@ async function executeDynamicToolCallWithTimeout(params, retainCleanup) {
 	const notifyFailedToolResult = (message, terminalReason = "failed") => {
 		notifyAgentToolResult({
 			toolName: params.call.tool,
-			result: {
-				content: [{
-					type: "text",
-					text: message
-				}],
-				details: {
-					status: terminalReason,
-					error: message
-				}
-			},
+			result: failedToolResult(message, terminalReason),
 			isError: true
 		});
 	};
@@ -688,38 +669,31 @@ function toCodexDynamicToolProtocolResponse(response) {
 function toCodexDynamicToolProgressResponse(response, protocolResponse) {
 	const transcriptDetails = isJsonObject(response.transcriptDetails) ? response.transcriptDetails : void 0;
 	const mcpAppPreview = isJsonObject(transcriptDetails?.mcpAppPreview) ? transcriptDetails.mcpAppPreview : void 0;
-	const progressDetails = mcpAppPreview ? { mcpAppPreview } : void 0;
-	if (response.asyncStarted !== true && progressDetails === void 0) return protocolResponse;
+	if (response.asyncStarted !== true && !mcpAppPreview) return protocolResponse;
 	return {
 		...protocolResponse,
-		...progressDetails ? { details: progressDetails } : {},
-		...response.asyncStarted === true ? { details: {
-			...progressDetails,
+		details: response.asyncStarted === true ? {
+			...mcpAppPreview ? { mcpAppPreview } : {},
 			async: true,
 			status: "started"
-		} } : {}
+		} : { mcpAppPreview }
 	};
 }
-/** Decides whether a terminal dynamic tool response can release the Codex turn. */
 function shouldReleaseTurnAfterTerminalDynamicTool(state) {
 	return !state.completed && !state.aborted && state.responseSuccess && !state.currentTurnHadNonTerminalDynamicToolResult && state.activeAppServerTurnRequests === 0 && state.activeTurnItemIdsCount === 0 && state.pendingOpenClawDynamicToolCompletionIdsCount === 0;
 }
-/** Returns true when a non-async result should block terminal-release shortcuts. */
 function shouldBlockTerminalReleaseForNonTerminalDynamicToolResult(response) {
 	return response.asyncStarted !== true;
 }
-/** Resolves whether terminal diagnostic state should release, wait, or stay idle. */
 function resolveTerminalDynamicToolBatchAction(state) {
 	if (state.activeAppServerTurnRequests > 0 || state.activeTurnItemIdsCount > 0 || state.pendingOpenClawDynamicToolCompletionIdsCount > 0) return "wait";
 	if (state.currentTurnHadNonTerminalDynamicToolResult) return "clear-nonterminal-batch";
 	if (state.hasPendingTerminalDynamicToolRelease) return "release-pending-terminal";
 	return "idle";
 }
-/** Returns true for diagnostic events that terminate a dynamic tool call. */
 function isDynamicToolTerminalDiagnosticEvent(event) {
 	return event.type === "tool.execution.completed" || event.type === "tool.execution.error" || event.type === "tool.execution.blocked";
 }
-/** Matches terminal diagnostics to a specific dynamic tool call id/name. */
 function isMatchingDynamicToolTerminalDiagnostic(params) {
 	if (params.event.toolCallId !== params.call.callId || params.event.toolName !== params.call.tool) return false;
 	if (params.runId !== void 0) return params.event.runId === params.runId;
@@ -727,7 +701,6 @@ function isMatchingDynamicToolTerminalDiagnostic(params) {
 	if (params.sessionKey !== void 0) return params.event.sessionKey === params.sessionKey;
 	return params.event.runId === void 0 && params.event.sessionId === void 0 && params.event.sessionKey === void 0;
 }
-/** Checks pending diagnostics for a terminal event matching a tool call. */
 function hasPendingDynamicToolTerminalDiagnostic(params) {
 	return hasPendingInternalDiagnosticEvent((event) => {
 		if (!isDynamicToolTerminalDiagnosticEvent(event)) return false;
@@ -740,7 +713,6 @@ function hasPendingDynamicToolTerminalDiagnostic(params) {
 		});
 	});
 }
-/** Resolves per-tool timeout, applying media/message defaults and hard caps. */
 function resolveDynamicToolCallTimeoutMs(params) {
 	const args = isJsonObject(params.call.arguments) ? params.call.arguments : void 0;
 	if (params.call.tool === "node_exec") {
@@ -755,11 +727,8 @@ function resolveDynamicToolCallTimeoutMs(params) {
 	}
 	if (params.call.tool === "computer") return clampDynamicToolTimeoutMs(readComputerToolTimeoutMs(params.call.arguments));
 	if (params.call.tool === "message") return CODEX_DYNAMIC_MESSAGE_TOOL_TIMEOUT_MS;
-	if (params.call.tool === "agents_wait") {
-		const requestedMs = readDynamicToolCallTimeoutMs(params.call.arguments) ?? readConfiguredDynamicToolTimeoutMs(params.call.tool, params.config) ?? CODEX_DYNAMIC_AGENTS_WAIT_TOOL_TIMEOUT_MS;
-		return Math.max(1, Math.min(63e4, Math.floor(requestedMs)));
-	}
-	return clampDynamicToolTimeoutMs(readDynamicToolCallTimeoutMs(params.call.arguments) ?? readConfiguredDynamicToolTimeoutMs(params.call.tool, params.config) ?? CODEX_DYNAMIC_TOOL_TIMEOUT_MS);
+	const isCollectorWait = params.call.tool === "agents_wait";
+	return clampDynamicToolTimeoutMs(readDynamicToolCallTimeoutMs(params.call.arguments) ?? readConfiguredDynamicToolTimeoutMs(params.call.tool, params.config) ?? (isCollectorWait ? CODEX_DYNAMIC_AGENTS_WAIT_TOOL_TIMEOUT_MS : CODEX_DYNAMIC_TOOL_TIMEOUT_MS), isCollectorWait ? CODEX_DYNAMIC_AGENTS_WAIT_TOOL_TIMEOUT_MS : CODEX_DYNAMIC_TOOL_MAX_TIMEOUT_MS);
 }
 /** Transport guard stays outside the handler's bounded tool wait and completion grace. */
 function resolveDynamicToolServerRequestTimeoutMs(call) {
@@ -805,8 +774,8 @@ function readDynamicToolTimeoutSecondsAsMs(value) {
 function readPositiveFiniteTimeoutMs(value) {
 	return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : void 0;
 }
-function clampDynamicToolTimeoutMs(timeoutMs) {
-	return Math.max(1, Math.min(CODEX_DYNAMIC_TOOL_MAX_TIMEOUT_MS, Math.floor(timeoutMs)));
+function clampDynamicToolTimeoutMs(timeoutMs, maximum = CODEX_DYNAMIC_TOOL_MAX_TIMEOUT_MS) {
+	return Math.max(1, Math.min(maximum, Math.floor(timeoutMs)));
 }
 //#endregion
 //#region extensions/codex/src/app-server/elicitation-response.ts
@@ -3088,10 +3057,15 @@ var TurnStartResponse_default = {
 };
 //#endregion
 //#region extensions/codex/src/app-server/protocol-validators.ts
-/**
-* Runtime validators for Codex app-server protocol payloads, including schema
-* normalization for generated JSON Schema before TypeBox compilation.
-*/
+function readSupervisionResponseThreadId(value) {
+	const thread = isRecord(value) ? value.thread : void 0;
+	return isRecord(thread) ? thread.id : void 0;
+}
+function resolveCodexThreadRolloutPath(thread) {
+	const rolloutPath = thread.path?.trim();
+	if (!rolloutPath || !path.isAbsolute(rolloutPath) || path.extname(rolloutPath) !== ".jsonl" || !path.basename(rolloutPath).includes(thread.id)) return;
+	return rolloutPath;
+}
 const externalDefinitionRefPrefix = "./CodexAppServerProtocolDefinitions.json#/definitions/";
 const rootExternalDefinitionRefPrefix = "./v2/CodexAppServerProtocolDefinitions.json#/definitions/";
 const localDefinitionRefPrefix = "#/definitions/";
@@ -3133,17 +3107,12 @@ function rewriteDefinitionRefs(value, externalRefPrefix) {
 	if (!isRecord(value)) return value;
 	return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, key === "$ref" && typeof entry === "string" && entry.startsWith(externalRefPrefix) ? `${localDefinitionRefPrefix}${entry.slice(externalRefPrefix.length)}` : rewriteDefinitionRefs(entry, externalRefPrefix)]));
 }
-const dynamicToolCallParamsSchema = materializeCodexSchema(DynamicToolCallParams_default, rootExternalDefinitionRefPrefix);
-const errorNotificationSchema = materializeCodexSchema(ErrorNotification_default);
-const modelListResponseSchema = materializeCodexSchema(ModelListResponse_default);
-const threadResumeResponseSchema = materializeCodexSchema(ThreadResumeResponse_default);
-const threadStartResponseSchema = materializeCodexSchema(ThreadStartResponse_default);
-const turnCompletedNotificationSchema = materializeCodexSchema(TurnCompletedNotification_default);
-const turnStartResponseSchema = materializeCodexSchema(TurnStartResponse_default);
-function compileCodexSchema(schema) {
+function compileCodexSchema(rawSchema, externalRefPrefix) {
+	const schema = materializeCodexSchema(rawSchema, externalRefPrefix);
 	if (typeof schema !== "boolean" && !isRecord(schema)) throw new TypeError("Generated Codex schema must be an object or boolean");
 	const validator = Compile(normalizeJsonSchemaForTypeBox(schema));
 	return {
+		schema,
 		check: (value) => validator.Check(value),
 		errors: (value) => [...validator.Errors(value)]
 	};
@@ -3183,10 +3152,7 @@ function applySchemaDefaults(schema, value, root = schema, resolvingRefs = /* @_
 			resolvingRefs.delete(schema.$ref);
 		}
 	}
-	for (const key of ["allOf"]) {
-		const branches = schema[key];
-		if (Array.isArray(branches)) for (const branch of branches) nextValue = applySchemaDefaults(branch, nextValue, root, resolvingRefs);
-	}
+	if (Array.isArray(schema.allOf)) for (const branch of schema.allOf) nextValue = applySchemaDefaults(branch, nextValue, root, resolvingRefs);
 	if (schemaTypeIncludes(schema, "object") && isRecord(nextValue) && isRecord(schema.properties)) {
 		for (const [key, propertySchema] of Object.entries(schema.properties)) {
 			const currentValue = nextValue[key];
@@ -3205,27 +3171,21 @@ function normalizeWithDefaults(schema, value) {
 	if (value === void 0 || value === null) return value;
 	return applySchemaDefaults(schema, structuredClone(value));
 }
-const validateDynamicToolCallParams = compileCodexSchema(dynamicToolCallParamsSchema);
-const validateErrorNotification = compileCodexSchema(errorNotificationSchema);
-const validateModelListResponse = compileCodexSchema(modelListResponseSchema);
-const validateThreadResumeResponse = compileCodexSchema(threadResumeResponseSchema);
-const validateThreadStartResponse = compileCodexSchema(threadStartResponseSchema);
-const validateTurnCompletedNotification = compileCodexSchema(turnCompletedNotificationSchema);
-const validateTurnStartResponse = compileCodexSchema(turnStartResponseSchema);
-/** Asserts and normalizes a Codex thread/start response. */
+const validateDynamicToolCallParams = compileCodexSchema(DynamicToolCallParams_default, rootExternalDefinitionRefPrefix);
+const validateErrorNotification = compileCodexSchema(ErrorNotification_default);
+const validateModelListResponse = compileCodexSchema(ModelListResponse_default);
+const validateThreadResumeResponse = compileCodexSchema(ThreadResumeResponse_default);
+const validateThreadStartResponse = compileCodexSchema(ThreadStartResponse_default);
+const validateTurnCompletedNotification = compileCodexSchema(TurnCompletedNotification_default);
+const validateTurnStartResponse = compileCodexSchema(TurnStartResponse_default);
 function assertCodexThreadStartResponse(value) {
-	const normalized = normalizeWithDefaults(threadStartResponseSchema, value);
-	return assertCodexShape(validateThreadStartResponse, normalized, "thread/start response");
+	return assertCodexShape(validateThreadStartResponse, value, "thread/start response");
 }
-/** Asserts and normalizes a Codex thread/fork response. */
 function assertCodexThreadForkResponse(value) {
-	const normalized = normalizeWithDefaults(threadStartResponseSchema, value);
-	return assertCodexShape(validateThreadStartResponse, normalized, "thread/fork response");
+	return assertCodexShape(validateThreadStartResponse, value, "thread/fork response");
 }
-/** Asserts and normalizes a Codex thread/resume response. */
 function assertCodexThreadResumeResponse(value) {
-	const normalized = normalizeWithDefaults(threadResumeResponseSchema, value);
-	return assertCodexShape(validateThreadResumeResponse, normalized, "thread/resume response");
+	return assertCodexShape(validateThreadResumeResponse, value, "thread/resume response");
 }
 var CodexThreadDirectInputError = class extends Error {
 	constructor(threadId) {
@@ -3237,10 +3197,8 @@ var CodexThreadDirectInputError = class extends Error {
 function assertCodexThreadAcceptsDirectInput(thread) {
 	if (thread.canAcceptDirectInput === false) throw new CodexThreadDirectInputError(thread.id);
 }
-/** Asserts and normalizes a Codex turn/start response. */
 function assertCodexTurnStartResponse(value) {
-	const normalized = normalizeWithDefaults(turnStartResponseSchema, value);
-	return assertCodexShape(validateTurnStartResponse, normalized, "turn/start response");
+	return assertCodexShape(validateTurnStartResponse, value, "turn/start response");
 }
 /** Prompt echoes and attested managed-hook continuations cannot admit native capabilities. */
 function assertCodexPassiveTurnItems(items, prompt, taskLabel, options = {}) {
@@ -3259,29 +3217,30 @@ function assertCodexPassiveTurnItems(items, prompt, taskLabel, options = {}) {
 		throw new Error(`Codex ${taskLabel} returned unexpected native item: ${item.type}`);
 	}
 }
-/** Reads Codex dynamic-tool call params, returning undefined for invalid payloads. */
 function readCodexDynamicToolCallParams(value) {
-	return readCodexShape(validateDynamicToolCallParams, normalizeWithDefaults(dynamicToolCallParamsSchema, value));
+	return readCodexShape(validateDynamicToolCallParams, value);
 }
-/** Reads a Codex error notification payload if it matches the protocol schema. */
 function readCodexErrorNotification(value) {
-	return readCodexShape(validateErrorNotification, normalizeWithDefaults(errorNotificationSchema, value));
+	return readCodexShape(validateErrorNotification, value);
 }
-/** Asserts and normalizes a Codex model/list response. */
 function assertCodexModelListResponse(value) {
-	return assertCodexShape(validateModelListResponse, normalizeWithDefaults(modelListResponseSchema, value), "model/list response");
+	return assertCodexShape(validateModelListResponse, value, "model/list response");
 }
-/** Reads a Codex turn/completed notification payload if it matches the protocol schema. */
 function readCodexTurnCompletedNotification(value) {
-	const notification = readCodexShape(validateTurnCompletedNotification, normalizeWithDefaults(turnCompletedNotificationSchema, value));
+	const notification = readCodexShape(validateTurnCompletedNotification, value);
 	return notification?.turn.status === "inProgress" ? void 0 : notification;
 }
+function assertExactSupervisionModelSelection(value, expected) {
+	if (value.model !== expected.model || value.modelProvider !== expected.modelProvider) throw new Error(`Codex supervision ${expected.operation} changed native model selection: ${value.modelProvider ?? "unknown"}/${value.model ?? "unknown"}`);
+}
 function assertCodexShape(validate, value, label) {
-	if (validate.check(value)) return value;
-	throw new Error(`Invalid Codex app-server ${label}: ${formatValidationErrors(validate, value)}`);
+	const normalized = normalizeWithDefaults(validate.schema, value);
+	if (validate.check(normalized)) return normalized;
+	throw new Error(`Invalid Codex app-server ${label}: ${formatValidationErrors(validate, normalized)}`);
 }
 function readCodexShape(validate, value) {
-	return validate.check(value) ? value : void 0;
+	const normalized = normalizeWithDefaults(validate.schema, value);
+	return validate.check(normalized) ? normalized : void 0;
 }
 function formatValidationErrors(validate, value) {
 	const errors = validate.errors(value);
@@ -3304,6 +3263,8 @@ var CodexServerRequests = class {
 	constructor(respond) {
 		this.respond = respond;
 		this.handlers = /* @__PURE__ */ new Set();
+		this.refreshWork = new AsyncWorkScope();
+		this.closed = false;
 		this.active = /* @__PURE__ */ new Map();
 	}
 	resolve(params) {
@@ -3317,11 +3278,15 @@ var CodexServerRequests = class {
 		}
 	}
 	close(error) {
+		this.closed = true;
+		this.closing ??= this.refreshWork.drain();
 		const requests = [...this.active.values()];
 		this.active.clear();
 		for (const request of requests) request.controller.abort(error);
+		return this.closing;
 	}
 	async handle(request) {
+		if (this.closed) return;
 		const controller = new AbortController();
 		const entry = {
 			threadId: isJsonObject(request.params) ? request.params.threadId : void 0,
@@ -3364,7 +3329,8 @@ var CodexServerRequests = class {
 			}
 		};
 		try {
-			const result = await Promise.race([run(), deadline.promise]);
+			const work = request.method === "account/chatgptAuthTokens/refresh" ? this.refreshWork.track(run) : run();
+			const result = await Promise.race([work, deadline.promise]);
 			if (this.active.get(request.id) === entry) this.respond({
 				id: request.id,
 				result: result === void 0 ? defaultServerRequestResponse(request) : result
@@ -3419,195 +3385,7 @@ function timeoutServerRequestResponse(timeoutMs) {
 	};
 }
 //#endregion
-//#region extensions/codex/src/app-server/transport-websocket.ts
-/**
-* 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");
-	const events = new EventEmitter();
-	const stdout = new PassThrough();
-	const stderr = new PassThrough();
-	const websocketOptions = {
-		headers: {
-			...options.headers,
-			...options.authToken ? { Authorization: `Bearer ${options.authToken}` } : {}
-		},
-		perMessageDeflate: false,
-		...options.transport === "websocket" ? { handshakeTimeout: WEBSOCKET_HANDSHAKE_TIMEOUT_MS } : {}
-	};
-	const unixSocketPath = resolveCodexAppServerUnixSocketPath(options);
-	const socket = unixSocketPath ? new WebSocket("ws://localhost/", {
-		...websocketOptions,
-		createConnection: () => connectCodexAppServerUnixSocket(unixSocketPath)
-	}) : new WebSocket(options.url, websocketOptions);
-	const pendingFrames = [];
-	const stdinDecoder = new StringDecoder("utf8");
-	let pendingLine = "";
-	let killed = false;
-	let exitCode = null;
-	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;
-		if (socket.readyState === WebSocket.OPEN) {
-			socket.send(trimmed);
-			return;
-		}
-		pendingFrames.push(trimmed);
-	};
-	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("close", (code, reason) => {
-		clearConnectionHealthTimers();
-		killed = true;
-		exitCode = code;
-		events.emit("exit", code, reason.toString("utf8"));
-	});
-	socket.on("message", (data) => {
-		if (options.transport === "websocket") recordConnectionActivity();
-		const frame = websocketFrameToBuffer(data);
-		const writable = stdout.write(frame);
-		const delimited = frame.at(-1) === 10 || stdout.write(Buffer.from("\n"));
-		if (!writable || !delimited) socket.pause();
-	});
-	stdout.on("drain", () => {
-		if (socket.readyState === WebSocket.OPEN) socket.resume();
-	});
-	const stdin = new Writable({
-		write(chunk, _encoding, callback) {
-			pendingLine += stdinDecoder.write(chunk);
-			const lines = pendingLine.split("\n");
-			pendingLine = lines.pop() ?? "";
-			for (const frame of lines) sendFrame(frame);
-			callback();
-		},
-		final(callback) {
-			pendingLine += stdinDecoder.end();
-			if (pendingLine) sendFrame(pendingLine);
-			pendingLine = "";
-			callback();
-		}
-	});
-	const closeSocket = () => {
-		if (socket.readyState === WebSocket.CLOSED || socket.readyState === WebSocket.CLOSING) return;
-		socket.close();
-	};
-	stdin.once("finish", closeSocket);
-	stdin.once("close", closeSocket);
-	return {
-		maxFrameBytes: 16777216,
-		stdin,
-		stdout,
-		stderr,
-		get killed() {
-			return killed;
-		},
-		get exitCode() {
-			return exitCode;
-		},
-		kill: (signal) => {
-			killed = true;
-			clearConnectionHealthTimers();
-			if (signal === "SIGKILL") socket.terminate();
-			else socket.close();
-		},
-		once: (event, listener) => events.once(event, listener),
-		off: (event, listener) => events.off(event, listener)
-	};
-}
-/** Opens the owner-scoped Codex control socket used by the WebSocket upgrade. */
-function connectCodexAppServerUnixSocket(socketPath) {
-	return net.createConnection(socketPath);
-}
-/** Resolves the canonical or explicitly configured Codex control socket. */
-function resolveCodexAppServerUnixSocketPath(options) {
-	if (options.transport !== "unix") {
-		if (options.url?.startsWith("unix://")) throw new Error("codex app-server unix URL requires unix transport");
-		return;
-	}
-	const url = options.url ?? "unix://";
-	if (!url.startsWith("unix://")) throw new Error("codex app-server unix transport requires a unix:// URL");
-	return url.slice(7) || path.join(resolveCodexAppServerUserHomeDir(options.env ?? process.env), "app-server-control", "app-server-control.sock");
-}
-function websocketFrameToBuffer(data) {
-	if (typeof data === "string") return Buffer.from(data);
-	if (Buffer.isBuffer(data)) return data;
-	if (Array.isArray(data)) return Buffer.concat(data);
-	return Buffer.from(data);
-}
-//#endregion
 //#region extensions/codex/src/app-server/client.ts
-/**
-* JSON-RPC client for Codex app-server transports, including request/response
-* routing, notification fanout, server request handlers, and version checks.
-*/
 var client_exports = /* @__PURE__ */ __exportAll({
 	CodexAppServerClient: () => CodexAppServerClient,
 	getCodexAppServerClientInstanceId: () => getCodexAppServerClientInstanceId,
@@ -3685,13 +3463,11 @@ 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;
 }
-/** Returns true for errors that mean the app-server transport is closed. */
 function isCodexAppServerConnectionClosedError(error) {
 	if (!(error instanceof Error)) return false;
 	if (isCodexAppServerIndeterminateTransportError(error)) return true;
 	return error.message === "codex app-server client is closed" || error.message.startsWith("codex app-server exited:");
 }
-/** Stateful app-server JSON-RPC client over stdio or websocket transport. */
 var CodexAppServerClient = class CodexAppServerClient {
 	constructor(child) {
 		this.instanceId = randomUUID();
@@ -3731,7 +3507,6 @@ var CodexAppServerClient = class CodexAppServerClient {
 		});
 		child.stdin.on?.("error", (error) => this.closeWithError(toStringifiedError(error)));
 	}
-	/** Starts a new app-server client using resolved runtime start options. */
 	static async start(options, assertCurrent) {
 		const defaults = resolveCodexAppServerRuntimeOptions().start;
 		const startOptions = {
@@ -3754,25 +3529,21 @@ var CodexAppServerClient = class CodexAppServerClient {
 			throw stderr ? new Error(`${coerceErrorMessage(error)}; stderr=${JSON.stringify(stderr)}`, { cause: error }) : error;
 		}
 	}
-	/** Builds a client around a fake transport for tests. */
 	static fromTransportForTests(child) {
 		return new CodexAppServerClient(child);
 	}
-	/** Performs the app-server initialize handshake and validates protocol version. */
 	async initialize() {
 		if (this.initialized) return;
 		const response = await this.request("initialize", buildCodexAppServerInitializeParams());
 		this.child.startupFailure?.complete();
-		this.serverVersion = assertSupportedCodexAppServerVersion(response);
-		this.runtimeIdentity = buildCodexAppServerRuntimeIdentity(response, this.serverVersion);
+		const serverVersion = assertSupportedCodexAppServerVersion(response);
+		this.runtimeIdentity = buildCodexAppServerRuntimeIdentity(response, serverVersion);
 		this.notify("initialized");
 		this.initialized = true;
 	}
-	/** Returns the version detected during initialize. */
 	getServerVersion() {
-		return this.serverVersion;
+		return this.runtimeIdentity?.serverVersion;
 	}
-	/** Returns runtime metadata detected during initialize. */
 	getRuntimeIdentity() {
 		return this.runtimeIdentity ? { ...this.runtimeIdentity } : void 0;
 	}
@@ -3942,8 +3713,6 @@ var CodexAppServerClient = class CodexAppServerClient {
 		});
 		const result = attempt.wait({
 			...options,
-			assertCurrent: void 0,
-			disposition: "new",
 			overloadAttemptOrdinal
 		}, deadline);
 		if (!attempt.pending) return result;
@@ -3958,25 +3727,21 @@ var CodexAppServerClient = class CodexAppServerClient {
 		}
 		return result;
 	}
-	/** Sends a fire-and-forget JSON-RPC notification to the app-server. */
 	notify(method, params) {
 		this.writeMessage({
 			method,
 			params
 		});
 	}
-	/** Registers a handler for app-server requests sent back to OpenClaw. */
 	addRequestHandler(handler) {
 		this.serverRequests.handlers.add(handler);
 		return () => this.serverRequests.handlers.delete(handler);
 	}
-	/** Registers a notification handler and returns its disposer. */
 	addNotificationHandler(handler) {
 		this.notificationHandlers.add(handler);
 		for (const notification of this.pendingStartupWarnings.splice(0)) this.handleNotification(notification);
 		return () => this.notificationHandlers.delete(handler);
 	}
-	/** Registers a close handler and returns its disposer. */
 	addCloseHandler(handler) {
 		this.closeHandlers.add(handler);
 		return () => this.closeHandlers.delete(handler);
@@ -3991,33 +3756,26 @@ var CodexAppServerClient = class CodexAppServerClient {
 		this.child.once("exit", onExit);
 		return () => this.child.off?.("exit", onExit);
 	}
-	/** Closes the transport without waiting for process/socket shutdown. */
 	close() {
-		if (!this.markClosed(/* @__PURE__ */ new Error("codex app-server client is closed"))) return;
-		closeCodexAppServerTransport(this.child);
+		this.closeWithError(/* @__PURE__ */ new Error("codex app-server client is closed"));
 	}
-	/** Closes the transport and waits for shutdown according to transport policy. */
 	async closeAndWait(options) {
 		this.markClosed(/* @__PURE__ */ new Error("codex app-server client is closed"));
-		const [result] = await Promise.all([closeCodexAppServerTransportAndWait(this.child, options), this.catalogWorkerClosed]);
+		const [result] = await Promise.all([closeCodexAppServerTransportAndWait(this.child, options), this.waitForCloseWork()]);
 		return this.nativeExecutionObserved ? {
 			...result,
 			cleanup: "uncertain"
 		} : result;
 	}
+	/** Joins local settlement already started by close without changing transport policy. */
+	async waitForCloseWork() {
+		await this.serverRequestsClosed;
+		await this.catalogWorkerClosed;
+	}
 	/** Closes this transport and runs cleanup only after physical process exit. */
 	async closeAndRunAfterExit(onExit, operation) {
-		let settled = false;
-		const runOnExit = () => {
-			if (settled) return;
-			settled = true;
-			onExit();
-		};
-		if (this.transportExited) {
-			runOnExit();
-			return;
-		}
-		this.child.once("exit", runOnExit);
+		this.addTransportExitHandler(onExit);
+		if (this.transportExited) return;
 		try {
 			await this.closeAndWait();
 		} catch (closeError) {
@@ -4128,15 +3886,12 @@ var CodexAppServerClient = class CodexAppServerClient {
 		this.catalogWorkerClosed?.catch((closeError) => {
 			embeddedAgentLog.warn("codex catalog worker shutdown failed", { error: closeError });
 		});
-		this.serverRequests.close(error);
+		this.serverRequestsClosed = this.serverRequests.close(error);
 		this.rejectPendingRequests(error);
 		return true;
 	}
 	rejectPendingRequests(error) {
-		for (const pending of this.pending.values()) {
-			pending.cleanup();
-			pending.close(error);
-		}
+		for (const pending of this.pending.values()) pending.close(error);
 		this.pending.clear();
 		for (const handler of this.closeHandlers) try {
 			handler(this);
@@ -4145,7 +3900,6 @@ var CodexAppServerClient = class CodexAppServerClient {
 		}
 	}
 };
-/** Raised when the initialize handshake detects an unsupported app-server version. */
 var CodexAppServerVersionError = class extends Error {
 	constructor(detectedVersion) {
 		const detected = detectedVersion ? `detected ${detectedVersion}` : "OpenClaw could not determine the running Codex version";
@@ -4159,7 +3913,7 @@ function assertSupportedCodexAppServerVersion(response) {
 	if (!detectedVersion) throw new CodexAppServerVersionError(detectedVersion);
 	const detected = parse(detectedVersion);
 	if (!detected || detected.compare("0.149.0") < 0) throw new CodexAppServerVersionError(detectedVersion);
-	if (detected.compare("0.155.1") > 0) embeddedAgentLog.warn("codex app-server is newer than OpenClaw's managed runtime; continuing with normal startup validation", {
+	if (detected.compare("0.158.0") > 0) embeddedAgentLog.warn("codex app-server is newer than OpenClaw's managed runtime; continuing with normal startup validation", {
 		detectedVersion,
 		validatedVersion: CODEX_APP_SERVER_VERSION
 	});
@@ -4168,20 +3922,6 @@ function assertSupportedCodexAppServerVersion(response) {
 function isUnsupportedCodexAppServerVersionError(error) {
 	return error instanceof CodexAppServerVersionError;
 }
-function buildCodexAppServerRuntimeIdentity(response, serverVersion) {
-	const userAgent = normalizeOptionalString(response.userAgent);
-	const codexHome = normalizeOptionalString(response.codexHome);
-	const platformFamily = normalizeOptionalString(response.platformFamily);
-	const platformOs = normalizeOptionalString(response.platformOs);
-	return {
-		serverVersion,
-		...userAgent ? { userAgent } : {},
-		...codexHome ? { codexHome } : {},
-		...platformFamily ? { platformFamily } : {},
-		...platformOs ? { platformOs } : {}
-	};
-}
-/** 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];
 }
@@ -4190,9 +3930,8 @@ const CODEX_APP_SERVER_APPROVAL_REQUEST_METHODS = /* @__PURE__ */ new Set([
 	"item/fileChange/requestApproval",
 	"item/permissions/requestApproval"
 ]);
-/** Returns true for app-server approval request methods OpenClaw can answer. */
 function isCodexAppServerApprovalRequest(method) {
 	return CODEX_APP_SERVER_APPROVAL_REQUEST_METHODS.has(method);
 }
 //#endregion
-export { isMatchingDynamicToolTerminalDiagnostic as A, CODEX_APP_SERVER_OPT_OUT_NOTIFICATION_METHODS as B, readCodexDynamicToolCallParams as C, handleDynamicToolCallWithTimeout as D, createCodexElicitationResponse as E, toCodexDynamicToolProgressResponse as F, toCodexDynamicToolProtocolResponse as I, resolveCodexToolAbortTerminalReason as L, resolveTerminalDynamicToolBatchAction as M, shouldBlockTerminalReleaseForNonTerminalDynamicToolResult as N, hasPendingDynamicToolTerminalDiagnostic as O, shouldReleaseTurnAfterTerminalDynamicTool as P, createFailedDynamicToolResponse as R, assertCodexTurnStartResponse as S, readCodexTurnCompletedNotification as T, assertCodexPassiveTurnItems as _, isCodexAppServerBrokenPipeError as a, assertCodexThreadResumeResponse as b, isCodexAppServerIndeterminateTransportError as c, isCodexAppServerRequestTimeoutError as d, isUnsupportedCodexAppServerVersionError as f, assertCodexModelListResponse as g, CodexThreadDirectInputError as h, isCodexAppServerApprovalRequest as i, resolveDynamicToolCallTimeoutMs as j, isDynamicToolTerminalDiagnosticEvent as k, isCodexAppServerOverloadError as l, CodexServerRequestResolvedError as m, client_exports as n, isCodexAppServerConnectionClosedError as o, resolveCodexAppServerClientInstanceId as p, getCodexAppServerClientInstanceId as r, isCodexAppServerIndeterminateRequestCancellationError as s, CodexAppServerClient as t, isCodexAppServerPrewriteRequestCancellationError as u, assertCodexThreadAcceptsDirectInput as v, readCodexErrorNotification as w, assertCodexThreadStartResponse as x, assertCodexThreadForkResponse as y, failedToolResult as z };
+export { handleDynamicToolCallWithTimeout as A, resolveCodexToolAbortTerminalReason as B, assertExactSupervisionModelSelection as C, readSupervisionResponseThreadId as D, readCodexTurnCompletedNotification as E, resolveTerminalDynamicToolBatchAction as F, failedToolResult as H, shouldBlockTerminalReleaseForNonTerminalDynamicToolResult as I, shouldReleaseTurnAfterTerminalDynamicTool as L, isDynamicToolTerminalDiagnosticEvent as M, isMatchingDynamicToolTerminalDiagnostic as N, resolveCodexThreadRolloutPath as O, resolveDynamicToolCallTimeoutMs as P, toCodexDynamicToolProgressResponse as R, assertCodexTurnStartResponse as S, readCodexErrorNotification as T, CODEX_APP_SERVER_OPT_OUT_NOTIFICATION_METHODS as U, createFailedDynamicToolResponse as V, assertCodexPassiveTurnItems as _, isCodexAppServerBrokenPipeError as a, assertCodexThreadResumeResponse as b, isCodexAppServerIndeterminateTransportError as c, isCodexAppServerRequestTimeoutError as d, isUnsupportedCodexAppServerVersionError as f, assertCodexModelListResponse as g, CodexThreadDirectInputError as h, isCodexAppServerApprovalRequest as i, hasPendingDynamicToolTerminalDiagnostic as j, createCodexElicitationResponse as k, isCodexAppServerOverloadError as l, CodexServerRequestResolvedError as m, client_exports as n, isCodexAppServerConnectionClosedError as o, resolveCodexAppServerClientInstanceId as p, getCodexAppServerClientInstanceId as r, isCodexAppServerIndeterminateRequestCancellationError as s, CodexAppServerClient as t, isCodexAppServerPrewriteRequestCancellationError as u, assertCodexThreadAcceptsDirectInput as v, readCodexDynamicToolCallParams as w, assertCodexThreadStartResponse as x, assertCodexThreadForkResponse as y, toCodexDynamicToolProtocolResponse as z };