@openclaw/codex 2026.9.5 → 2026.9.7

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

@@ -1,39 +1,236 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
-import { _ as resolveCodexAppServerUserHomeDir, m as isJsonObject } from "./config-security-BRQ2mgW9.mjs";
-import { a as closeCodexCatalogClientSource, l as recordCodexCatalogResponseSource, n as projectCodexCatalogNativeResponse, o as codexCatalogSourceForClient } from "./session-catalog-native-projection-ChV3cCtm.mjs";
-import { r as MIN_SUPPORTED_CODEX_APP_SERVER_VERSION, t as CODEX_APP_SERVER_VERSION } from "./version-CoqzXPgK.mjs";
-import { a as hasCodexAppServerNaturalExit, i as closeCodexAppServerTransportAndWait, r as closeCodexAppServerTransport, t as createStdioTransport } from "./transport-stdio-Cmx94Oiy.mjs";
-import { i as CodexAppServerRpcError, r as CODEX_APP_SERVER_OVERLOADED_ERROR_CODE } from "./timeout-DZF05XrR.mjs";
-import "./config-CedDWjM-.mjs";
-import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-CeAhl_h4.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-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 { createInterface } from "node:readline";
 import { parse } from "semver";
-import { sanitizeTerminalText } from "openclaw/plugin-sdk/text-chunking";
-import { copyInternalToolResultState } from "openclaw/plugin-sdk/agent-harness-tool-runtime";
+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/protocol-json.ts
-function isRpcResponse(message) {
-	return "id" in message && !("method" in message);
+//#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;
+	return kind ? Number.MAX_SAFE_INTEGER - 2 * sequence - (kind === "thread" ? 1 : 0) : sequence;
+}
+/** 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() {
+		return this.continuationRoute;
+	}
+	async decode(line, route, attempts, projections) {
+		if (this.closed) return;
+		if (!this.continuationRoute && route !== "unresolved" && line.byteLength <= INLINE_CATALOG_MAX_BYTES) {
+			let parsed;
+			try {
+				parsed = JSON.parse(line.toString("utf8"));
+			} catch {}
+			if (parsed !== void 0) {
+				await Promise.resolve();
+				if (this.closed) return;
+				const attempt = attempts.get(route.id);
+				const projection = attempt ? projections.get(attempt) : void 0;
+				return projectCodexCatalogMessage(parsed, {
+					route,
+					remainingRows: attempt ? projection?.remainingRows : 0
+				}, 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;
+			this.pool = new WorkerTaskPool({
+				workerUrl: resolveRuntimeWorkerUrl(codexCatalogPageWorkerEntrypoint),
+				maxWorkers: 1,
+				maxPendingTasks: 1,
+				maxPendingBytes: Number.MAX_SAFE_INTEGER,
+				idleTimeoutMs: 0,
+				restartOnError: false
+			});
+		}
+		const attempt = route === "unresolved" ? void 0 : attempts.get(route.id);
+		const remainingRows = attempt ? projections.get(attempt)?.remainingRows : 0;
+		let catalogRows;
+		if (route === "unresolved") {
+			catalogRows = /* @__PURE__ */ new Map();
+			for (const [id, pending] of attempts) {
+				const projection = projections.get(pending);
+				if (typeof id === "number" && projection) catalogRows.set(id, projection.remainingRows);
+			}
+		}
+		const bytes = line.byteOffset === 0 && line.byteLength === line.buffer.byteLength && line.buffer instanceof ArrayBuffer ? new Uint8Array(line.buffer) : Uint8Array.from(line);
+		const decoded = await this.pool.run({
+			bytes,
+			route,
+			remainingRows,
+			catalogRows
+		}, {
+			inputBytes: bytes.byteLength,
+			transferList: (input) => [input.bytes.buffer]
+		});
+		if (this.closed) return;
+		this.continuationRoute = decoded.pending ? route : void 0;
+		if (!decoded.pending) this.armIdleRetirement();
+		return decoded;
+	}
+	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;
+		await this.retirement?.catch(() => void 0);
+		await this.pool?.close(error);
+	}
+};
+//#endregion
+//#region extensions/codex/src/app-server/client-diagnostics.ts
+function observeCodexAppServerStderr(stderr, consume) {
+	stderr.setEncoding("utf8");
+	stderr.on("data", (chunk) => {
+		const text = consume(chunk).trim();
+		if (text) embeddedAgentLog.debug(`codex app-server stderr: ${text}`);
+	});
+	stderr.on("error", (error) => embeddedAgentLog.warn("codex app-server stderr stream failed", { error }));
+}
+function appendBoundedTail(current, next, maxLength) {
+	const combined = `${current}${next}`;
+	return combined.length > maxLength ? sliceUtf16Safe(combined, -maxLength) : combined;
+}
+function buildCodexAppServerExitError(code, signal, stderrTail) {
+	const stderrPreview = redactCodexAppServerLinePreview(stderrTail);
+	const suffix = stderrPreview ? ` stderr=${JSON.stringify(stderrPreview)}` : "";
+	return /* @__PURE__ */ new Error(`codex app-server exited: code=${formatExitValue(code)} signal=${formatExitValue(signal)}${suffix}`);
+}
+function logCodexAppServerParseFailure(value, error, fragmentCount) {
+	const linePreview = redactCodexAppServerLinePreview(value);
+	const suffix = fragmentCount > 1 ? ` fragments=${fragmentCount}` : "";
+	embeddedAgentLog.warn("failed to parse codex app-server message", {
+		error,
+		errorMessage: coerceErrorMessage(error),
+		fragmentCount,
+		linePreview,
+		consoleMessage: `failed to parse codex app-server message${suffix}: preview=${JSON.stringify(linePreview)}`
+	});
+}
+function formatExitValue(value) {
+	if (value === null || value === void 0) return "null";
+	if (typeof value === "string" || typeof value === "number") return String(value);
+	return "unknown";
+}
+//#endregion
+//#region extensions/codex/src/app-server/notification-policy.ts
+const CODEX_APP_SERVER_OPT_OUT_NOTIFICATION_METHODS = [
+	"account/login/completed",
+	"app/list/updated",
+	"command/exec/outputDelta",
+	"deprecationNotice",
+	"externalAgentConfig/import/completed",
+	"externalAgentConfig/import/progress",
+	"fs/changed",
+	"fuzzyFileSearch/sessionCompleted",
+	"fuzzyFileSearch/sessionUpdated",
+	"mcpServer/event/stream/notification",
+	"mcpServer/oauthLogin/completed",
+	"mcpServer/startupStatus/updated",
+	"process/exited",
+	"process/outputDelta",
+	"project/changed",
+	"remoteControl/status/changed",
+	"thread/environment/connected",
+	"thread/environment/disconnected",
+	"thread/goal/cleared",
+	"thread/project/updated",
+	"thread/queue/changed",
+	"thread/realtime/closed",
+	"thread/realtime/error",
+	"thread/realtime/item/completed",
+	"thread/realtime/item/started",
+	"thread/realtime/item/transcript/delta",
+	"thread/realtime/itemAdded",
+	"thread/realtime/outputAudio/delta",
+	"thread/realtime/sdp",
+	"thread/realtime/started",
+	"thread/realtime/transcript/delta",
+	"thread/realtime/transcript/done",
+	"windows/worldWritableWarning",
+	"windowsSandbox/setupCompleted",
+	"turn/diff/updated",
+	"item/fileChange/outputDelta",
+	"thread/compacted"
+];
+//#endregion
+//#region extensions/codex/src/app-server/client-initialize.ts
+function buildCodexAppServerInitializeParams() {
+	return {
+		clientInfo: {
+			name: "openclaw",
+			title: "OpenClaw",
+			version: OPENCLAW_VERSION
+		},
+		capabilities: {
+			experimentalApi: true,
+			optOutNotificationMethods: [...CODEX_APP_SERVER_OPT_OUT_NOTIFICATION_METHODS],
+			extensions: {
+				"openai/standard-form-input": {},
+				"openai/form": {},
+				"io.modelcontextprotocol/ui": { mimeTypes: ["text/html;profile=mcp-app"] }
+			}
+		}
+	};
+}
+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. */
-function dispatchCodexAppServerResponse(response, attempts, catalogResponses, source) {
+function dispatchCodexAppServerResponse(response, attempts, catalogResponses, source, previewStates) {
 	const pending = attempts.get(response.id);
 	if (!pending) return false;
 	attempts.delete(response.id);
@@ -43,112 +240,187 @@ function dispatchCodexAppServerResponse(response, attempts, catalogResponses, so
 		return false;
 	}
 	const nativeExecution = pending.method === "thread/backgroundTerminals/list" && isJsonObject(response.result) && Array.isArray(response.result.data) && response.result.data.length > 0;
-	if (catalogResponses.has(pending) && isJsonObject(response.result) && Array.isArray(response.result.data)) {
-		const projection = catalogResponses.get(pending);
-		try {
-			response.result = projectCodexCatalogNativeResponse(response.result, sanitizeTerminalText, projection?.preview, projection?.remainingRows);
-		} catch (error) {
-			pending.reject(error instanceof Error ? error : new Error("Codex catalog projection failed", { cause: error }), false);
-			return false;
+	const cache = catalogResponses.get(pending)?.preview;
+	if (cache && previewStates && isJsonObject(response.result) && Array.isArray(response.result.data)) try {
+		for (const [index, row] of response.result.data.entries()) if (isJsonObject(row) && typeof row.id === "string" && row.ephemeral !== true) {
+			const preview = reuseCodexCatalogPreview({
+				id: row.id,
+				path: typeof row.path === "string" ? row.path : null,
+				updatedAt: typeof row.updatedAt === "number" ? row.updatedAt : null,
+				recencyAt: typeof row.recencyAt === "number" ? row.recencyAt : null
+			}, previewStates[index], cache);
+			if (preview !== void 0) row.preview = preview;
 		}
+	} catch (error) {
+		pending.reject(error instanceof Error ? error : new Error("Codex catalog projection failed", { cause: error }), false);
+		return false;
 	}
 	recordCodexCatalogResponseSource(pending.method, response.result, source);
 	pending.resolve(response.result);
 	return nativeExecution;
 }
 //#endregion
-//#region extensions/codex/src/app-server/dynamic-tool-response-state.ts
-/** Retains the host-owned app preview without adding it to Codex's response payload. */
-function withDynamicToolTranscriptDetails(response, details) {
-	if (details === void 0) return response;
-	Object.defineProperty(response, "transcriptDetails", {
-		configurable: true,
-		enumerable: false,
-		value: details
-	});
-	return response;
-}
-function withDynamicToolTerminalResolution(response, terminalResolution) {
-	if (terminalResolution) {
-		Object.defineProperties(response, {
-			terminalResolution: {
-				configurable: true,
-				enumerable: false,
-				value: terminalResolution
-			},
-			executionStarted: {
-				configurable: true,
-				enumerable: false,
-				value: terminalResolution.executionStarted
-			},
-			...terminalResolution.executedArguments ? { executedArguments: {
-				configurable: true,
-				enumerable: false,
-				value: terminalResolution.executedArguments
-			} } : {}
-		});
-		withDynamicToolSideEffectEvidence(response, terminalResolution.sideEffectEvidence);
-	}
-	return response;
-}
-function withDynamicToolExecutionState(response, state) {
-	Object.defineProperties(response, {
-		executedArguments: {
-			configurable: true,
-			enumerable: false,
-			value: state.executedArguments
+//#region extensions/codex/src/app-server/request-attempt.ts
+/** One caller per wire attempt; local waiter expiry need not imply a native response. */
+function createCodexRequestAttempt(params) {
+	let pending = true;
+	let mayHaveWritten = false;
+	let waiter;
+	const diagnostics = params.diagnosticIdentity ? {
+		...params.diagnosticIdentity,
+		attemptCreatedAtMs: performance.now(),
+		firstPossibleWriteAtMs: null,
+		wireOutcomeAtWaiterSettlement: "retained-pending",
+		wireObservedAtMs: null
+	} : void 0;
+	const finish = (outcome) => {
+		if (!pending) return false;
+		pending = false;
+		if (diagnostics) {
+			diagnostics.wireOutcomeAtWaiterSettlement = outcome;
+			diagnostics.wireObservedAtMs = performance.now();
+		}
+		params.onSettled();
+		return true;
+	};
+	const currentWaiterError = () => {
+		if (!params.retainWritten || !waiter) 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"
+		};
+	};
+	return {
+		method: params.method,
+		get pending() {
+			return pending;
+		},
+		wait(options, deadline) {
+			const { timeoutMs, signal, overloadAttemptOrdinal } = options;
+			let observe = options.attemptWaiterFinished;
+			return new Promise((resolve, reject) => {
+				if (!pending) {
+					reject(/* @__PURE__ */ new Error("Codex request attempt is already settled"));
+					return;
+				}
+				let timer;
+				let removeAbort;
+				const waiterAttachedAtMs = diagnostics && observe ? performance.now() : 0;
+				const cleanup = () => {
+					clearTimeout(timer);
+					timer = void 0;
+					removeAbort?.();
+					removeAbort = void 0;
+				};
+				const detach = (waiterOutcome) => {
+					if (!waiter) return false;
+					waiter = void 0;
+					cleanup();
+					if (!params.retainWritten || !mayHaveWritten) finish(mayHaveWritten ? "correlation-closed" : "not-written");
+					const callback = observe;
+					observe = void 0;
+					if (diagnostics && callback) try {
+						callback({
+							...diagnostics,
+							waiterOrdinal: 1,
+							disposition: "new",
+							overloadAttemptOrdinal,
+							waiterAttachedAtMs,
+							waiterSettledAtMs: performance.now(),
+							waiterOutcome
+						});
+					} catch {}
+					return true;
+				};
+				const localWaiter = {
+					resolve: (value) => {
+						if (!detach("resolved")) return;
+						resolve(value);
+					},
+					reject: (error, outcome) => {
+						if (detach(outcome)) reject(error);
+					},
+					signal,
+					deadline
+				};
+				waiter = localWaiter;
+				if (params.retainWritten && deadline !== void 0 && performance.now() >= deadline) {
+					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(() => localWaiter.reject(params.cancellationError("timed out", mayHaveWritten), "timed-out"), Math.max(params.retainWritten ? 1 : 100, remaining));
+					timer.unref?.();
+				}
+				if (signal) {
+					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();
+				}
+			});
+		},
+		resolve(value) {
+			if (!finish("native-ok")) return;
+			params.onResponse?.(mayHaveWritten);
+			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);
+				const current = currentWaiterError();
+				waiter?.reject(current?.error ?? params.localError(error, mayHaveWritten), current?.outcome ?? "native-error");
+			}
+		},
+		close(error) {
+			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");
+			waiter?.reject(params.localError(error, mayHaveWritten), "local-failed");
 		},
-		executionStarted: {
-			configurable: true,
-			enumerable: false,
-			value: state.executionStarted
+		markWritten() {
+			mayHaveWritten = true;
+			if (diagnostics && diagnostics.firstPossibleWriteAtMs === null) diagnostics.firstPossibleWriteAtMs = performance.now();
 		}
-	});
-	return withDynamicToolSideEffectEvidence(response, state.sideEffectEvidence === true);
-}
-function withDynamicToolSideEffectEvidence(response, sideEffectEvidence) {
-	if (!sideEffectEvidence) {
-		delete response.sideEffectEvidence;
-		return response;
-	}
-	Object.defineProperty(response, "sideEffectEvidence", {
-		configurable: true,
-		enumerable: false,
-		value: true
-	});
-	return response;
+	};
 }
+//#endregion
+//#region extensions/codex/src/app-server/dynamic-tool-response-state.ts
 function createFailedDynamicToolResponse(message, options) {
-	const response = {
+	return {
 		contentItems: [{
 			type: "inputText",
 			text: message
 		}],
-		success: false
+		success: false,
+		diagnosticTerminalReason: options?.terminalReason ?? "failed",
+		diagnosticTerminalType: "error",
+		executionStarted: options?.executionStarted,
+		executedArguments: options?.executedArguments,
+		sideEffectEvidence: options?.sideEffectEvidence === true || void 0
 	};
-	Object.defineProperties(response, {
-		diagnosticTerminalReason: {
-			configurable: true,
-			enumerable: false,
-			value: options?.terminalReason ?? "failed"
-		},
-		diagnosticTerminalType: {
-			configurable: true,
-			enumerable: false,
-			value: "error"
+}
+function failedToolResult(message, status = "failed") {
+	return {
+		content: [{
+			type: "text",
+			text: message
+		}],
+		details: {
+			status,
+			error: message
 		}
-	});
-	if (options?.executionStarted !== void 0) Object.defineProperty(response, "executionStarted", {
-		configurable: true,
-		enumerable: false,
-		value: options.executionStarted
-	});
-	if (options?.executedArguments !== void 0) Object.defineProperty(response, "executedArguments", {
-		configurable: true,
-		enumerable: false,
-		value: options.executedArguments
-	});
-	return withDynamicToolSideEffectEvidence(response, options?.sideEffectEvidence === true);
+	};
 }
 //#endregion
 //#region extensions/codex/src/app-server/tool-abort-terminal-reason.ts
@@ -178,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;
@@ -244,11 +508,13 @@ function formatDynamicToolTimeoutDetails(params) {
 		}
 	};
 }
-/**
-* Runs a dynamic tool call with run-abort and the budget prepared by
-* resolveDynamicToolCallTimeoutMs, preserving tool-specific completion grace.
-*/
 async function handleDynamicToolCallWithTimeout(params) {
+	return await runWithAsyncWorkResources((onAcquired) => executeDynamicToolCallWithTimeout(params, (release) => onAcquired({
+		release,
+		releaseBeforeResultWhenIdle: true
+	})));
+}
+async function executeDynamicToolCallWithTimeout(params, retainCleanup) {
 	let didNotifyAgentToolResult = false;
 	const conservativeRaceResponses = /* @__PURE__ */ new WeakSet();
 	const finalizeTerminal = (response) => {
@@ -265,11 +531,18 @@ async function handleDynamicToolCallWithTimeout(params) {
 			arguments: response.executedArguments ?? executionSnapshot?.executedArguments ?? params.call.arguments,
 			...params.toolMeta ? { meta: params.toolMeta } : {},
 			...ownerKey ? { ownerMutation: { ownerKey } } : {},
+			replaySafe: ownerKey ? false : response.replaySafe,
 			...observedExecutionStarted !== void 0 ? { executionStarted: observedExecutionStarted } : {},
 			outcome: response.success ? "success" : "failure",
 			...!response.success ? { failure: { error: readDynamicToolResponseText(response) } } : {}
 		});
-		return withDynamicToolTerminalResolution(response, terminalResolution);
+		if (terminalResolution) {
+			response.terminalResolution = terminalResolution;
+			response.executionStarted = terminalResolution.executionStarted;
+			response.executedArguments = terminalResolution.executedArguments ?? response.executedArguments;
+			response.sideEffectEvidence = terminalResolution.sideEffectEvidence || void 0;
+		}
+		return response;
 	};
 	const createFailedAfterPossibleDispatch = (message, terminalReason) => {
 		const response = createFailedDynamicToolResponse(message, {
@@ -293,16 +566,7 @@ async function handleDynamicToolCallWithTimeout(params) {
 	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
 		});
 	};
@@ -319,15 +583,26 @@ async function handleDynamicToolCallWithTimeout(params) {
 	const controller = new AbortController();
 	let timeout;
 	let timedOut = false;
+	let toolCallSettled = false;
+	let completedSuccessfully = false;
+	let operationReleased = false;
 	let resolveAbort;
 	const abortFromRun = () => {
 		const message = "OpenClaw dynamic tool call aborted.";
 		const terminalReason = resolveCodexToolAbortTerminalReason(params.signal);
-		params.onFallbackSelected?.();
 		controller.abort(params.signal.reason ?? /* @__PURE__ */ new Error(message));
+		if (toolCallSettled) return;
+		params.onFallbackSelected?.();
 		notifyFailedToolResult(message, terminalReason);
 		resolveAbort?.(createFailedAfterPossibleDispatch(message, terminalReason));
 	};
+	const releaseOperation = () => {
+		if (operationReleased) return;
+		operationReleased = true;
+		params.signal.removeEventListener("abort", abortFromRun);
+		if (!controller.signal.aborted) controller.abort(/* @__PURE__ */ new Error("OpenClaw dynamic tool call finished."));
+	};
+	retainCleanup(releaseOperation);
 	const abortPromise = new Promise((resolve) => {
 		resolveAbort = resolve;
 	});
@@ -365,7 +640,9 @@ async function handleDynamicToolCallWithTimeout(params) {
 			timeoutPromise
 		]);
 		if (!response.success && !didNotifyAgentToolResult) notifyFailedToolResult(readDynamicToolResponseText(response), response.diagnosticTerminalReason ?? "failed");
-		return finalizeTerminal(response);
+		const terminal = finalizeTerminal(response);
+		completedSuccessfully = terminal.success;
+		return terminal;
 	} catch (error) {
 		const terminalReason = params.signal.aborted ? resolveCodexToolAbortTerminalReason(params.signal) : resolveToolExecutionErrorKind(error);
 		const message = formatToolExecutionErrorMessage(error, "OpenClaw dynamic tool call failed.");
@@ -373,9 +650,9 @@ async function handleDynamicToolCallWithTimeout(params) {
 		return finalizeTerminal(createFailedAfterPossibleDispatch(message, terminalReason));
 	} finally {
 		if (timeout) clearTimeout(timeout);
-		params.signal.removeEventListener("abort", abortFromRun);
+		toolCallSettled = true;
 		resolveAbort = void 0;
-		if (!timedOut && !controller.signal.aborted) controller.abort(/* @__PURE__ */ new Error("OpenClaw dynamic tool call finished."));
+		if (!completedSuccessfully || timedOut || controller.signal.aborted) releaseOperation();
 	}
 }
 function readDynamicToolResponseText(response) {
@@ -392,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;
@@ -431,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;
@@ -444,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") {
@@ -459,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) {
@@ -509,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
@@ -2792,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/";
@@ -2837,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)]
 	};
@@ -2887,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];
@@ -2909,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) {
@@ -2941,16 +3197,15 @@ 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, normalizeTurnEnvelope(value));
-	return assertCodexShape(validateTurnStartResponse, normalized, "turn/start response");
+	return assertCodexShape(validateTurnStartResponse, value, "turn/start response");
 }
-/** Only the current text prompt may be echoed; capabilities and historical items are not passive. */
-function assertCodexPassiveTurnItems(items, prompt, taskLabel) {
+/** Prompt echoes and attested managed-hook continuations cannot admit native capabilities. */
+function assertCodexPassiveTurnItems(items, prompt, taskLabel, options = {}) {
 	let promptEchoSeen = false;
 	for (const item of items) {
 		if (item.type === "agentMessage" || item.type === "reasoning") continue;
+		if (item.type === "hookPrompt" && options.allowManagedHookPrompts === true && Array.isArray(item.fragments) && item.fragments.length > 0 && item.fragments.every((fragment) => isJsonObject(fragment) && typeof fragment.text === "string" && typeof fragment.hookRunId === "string" && fragment.hookRunId.trim().length > 0)) continue;
 		if (item.type === "userMessage" && !promptEchoSeen) {
 			const content = Array.isArray(item.content) ? item.content : [];
 			const input = content[0];
@@ -2962,80 +3217,30 @@ function assertCodexPassiveTurnItems(items, prompt, taskLabel) {
 		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");
-}
-/** Reads and normalizes a Codex turn object. */
-function readCodexTurn(value) {
-	return readCodexShape(validateTurnStartResponse, normalizeWithDefaults(turnStartResponseSchema, { turn: normalizeTurn(value) }))?.turn;
+	return assertCodexShape(validateModelListResponse, value, "model/list response");
 }
-/** Reads a Codex turn/completed notification payload if it matches the protocol schema. */
 function readCodexTurnCompletedNotification(value) {
-	return readCodexShape(validateTurnCompletedNotification, normalizeWithDefaults(turnCompletedNotificationSchema, normalizeTurnEnvelope(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;
-}
-function normalizeTurn(value) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return value;
-	return {
-		error: null,
-		startedAt: null,
-		completedAt: null,
-		durationMs: null,
-		...value,
-		items: Array.isArray(value.items) ? value.items.map(normalizeThreadItem) : []
-	};
-}
-function normalizeThreadItem(value) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return value;
-	switch (value.type) {
-		case "agentMessage": return {
-			phase: null,
-			delivery: null,
-			memoryCitation: null,
-			...value
-		};
-		case "plan": return {
-			text: "",
-			...value
-		};
-		case "reasoning": return {
-			summary: [],
-			content: [],
-			...value
-		};
-		case "dynamicToolCall": return {
-			namespace: null,
-			arguments: null,
-			status: "completed",
-			contentItems: null,
-			success: null,
-			durationMs: null,
-			...value
-		};
-		default: return value;
-	}
-}
-function normalizeTurnEnvelope(value) {
-	if (!value || typeof value !== "object" || Array.isArray(value) || !("turn" in value)) return value;
-	return {
-		...value,
-		turn: normalizeTurn(value.turn)
-	};
+	const normalized = normalizeWithDefaults(validate.schema, value);
+	return validate.check(normalized) ? normalized : void 0;
 }
 function formatValidationErrors(validate, value) {
 	const errors = validate.errors(value);
@@ -3046,356 +3251,141 @@ function formatValidationErrors(validate, value) {
 	}).join("; ");
 }
 //#endregion
-//#region extensions/codex/src/app-server/request-attempt.ts
-/** One 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();
-	const diagnostics = params.diagnosticIdentity ? {
-		...params.diagnosticIdentity,
-		waiterOrdinal: 0,
-		attemptCreatedAtMs: performance.now(),
-		firstPossibleWriteAtMs: null,
-		wireOutcomeAtWaiterSettlement: "retained-pending",
-		wireObservedAtMs: null
-	} : void 0;
-	const finish = (outcome) => {
-		if (!pending) return false;
-		pending = false;
-		if (diagnostics) {
-			diagnostics.wireOutcomeAtWaiterSettlement = outcome;
-			diagnostics.wireObservedAtMs = performance.now();
+//#region extensions/codex/src/app-server/server-requests.ts
+var CodexServerRequestResolvedError = class extends Error {
+	constructor() {
+		super("Codex server request resolved by another client");
+		this.name = "CodexServerRequestResolvedError";
+	}
+};
+/** Physical-client owner for inbound requests, cancellation, and response deadlines. */
+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) {
+		if (!isJsonObject(params) || typeof params.threadId !== "string") return;
+		const id = params.requestId;
+		if (typeof id !== "string" && typeof id !== "number") return;
+		const request = this.active.get(id);
+		if (request?.threadId === params.threadId) {
+			this.active.delete(id);
+			request.controller.abort(new CodexServerRequestResolvedError());
 		}
-		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"
+	}
+	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,
+			controller
 		};
-		if (waiter.deadline !== void 0 && performance.now() >= waiter.deadline) return {
-			error: params.cancellationError("timed out", mayHaveWritten),
-			outcome: "timed-out"
+		this.active.set(request.id, entry);
+		const deadline = createDeferred();
+		const onAbort = () => deadline.resolve(void 0);
+		controller.signal.addEventListener("abort", onAbort, { once: true });
+		let timeout;
+		let timeoutMs = resolveDynamicToolServerRequestTimeoutMs(readCodexDynamicToolCallParams(request.params));
+		let settled = false;
+		let executionTimeoutResolved = false;
+		const armTimeout = () => {
+			clearTimeout(timeout);
+			timeout = setTimeout(() => {
+				embeddedAgentLog.warn("codex app-server server request timed out", {
+					id: request.id,
+					method: request.method,
+					timeoutMs
+				});
+				deadline.resolve(timeoutServerRequestResponse(timeoutMs));
+				controller.abort(/* @__PURE__ */ new Error("codex app-server server request timed out"));
+			}, timeoutMs);
+			timeout.unref?.();
 		};
-		try {
-			waiter.assertCurrent?.();
-		} catch (error) {
-			return {
-				error: toStringifiedError(error),
-				outcome: "authority-rejected"
-			};
-		}
-		if (waiter.signal?.aborted) return {
-			error: params.cancellationError("aborted", mayHaveWritten, waiter.signal.reason),
-			outcome: "aborted"
+		const setExecutionTimeoutMs = (executionTimeoutMs) => {
+			if (settled || controller.signal.aborted || executionTimeoutResolved || !Number.isFinite(executionTimeoutMs) || executionTimeoutMs <= 0) return;
+			executionTimeoutResolved = true;
+			timeoutMs = addSafeTimeoutDelayGraceMs(executionTimeoutMs, 3e4);
+			armTimeout();
 		};
-		if (waiter.deadline !== void 0 && performance.now() >= waiter.deadline) return {
-			error: params.cancellationError("timed out", mayHaveWritten),
-			outcome: "timed-out"
+		const dynamicTool = request.method === "item/tool/call";
+		if (dynamicTool) armTimeout();
+		const run = async () => {
+			for (const handler of this.handlers) {
+				if (controller.signal.aborted) return;
+				const result = await handler(request, controller.signal, dynamicTool ? setExecutionTimeoutMs : void 0);
+				if (result !== void 0) return result;
+			}
 		};
-	};
-	return {
-		method: params.method,
-		get pending() {
-			return pending;
-		},
-		wait(options, deadline) {
-			const { timeoutMs, signal, assertCurrent, disposition, overloadAttemptOrdinal } = options;
-			let observe = options.attemptWaiterFinished;
-			return new Promise((resolve, reject) => {
-				if (!pending) {
-					reject(/* @__PURE__ */ new Error("Codex request attempt is already settled"));
-					return;
-				}
-				let timer;
-				let removeAbort;
-				const waiterOrdinal = diagnostics ? ++diagnostics.waiterOrdinal : 0;
-				const waiterAttachedAtMs = diagnostics && observe ? performance.now() : 0;
-				const cleanup = () => {
-					clearTimeout(timer);
-					timer = void 0;
-					removeAbort?.();
-					removeAbort = void 0;
-				};
-				const detach = (waiterOutcome) => {
-					if (!waiters.delete(waiter)) return false;
-					cleanup();
-					if (waiters.size === 0 && (!params.retainWritten || !mayHaveWritten)) finish(mayHaveWritten ? "correlation-closed" : "not-written");
-					const callback = observe;
-					observe = void 0;
-					if (diagnostics && callback) try {
-						callback({
-							...diagnostics,
-							waiterOrdinal,
-							disposition,
-							overloadAttemptOrdinal,
-							waiterAttachedAtMs,
-							waiterSettledAtMs: performance.now(),
-							waiterOutcome
-						});
-					} catch {}
-					return true;
-				};
-				const waiter = {
-					resolve: (value) => {
-						if (!detach("resolved")) return;
-						resolve(value);
-					},
-					reject: (error, outcome) => {
-						if (detach(outcome)) reject(error);
-					},
-					cleanup,
-					signal,
-					...params.retainWritten ? {
-						deadline,
-						assertCurrent
-					} : {}
-				};
-				waiters.add(waiter);
-				if (params.retainWritten && deadline !== void 0 && performance.now() >= deadline) {
-					waiter.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.unref?.();
-				}
-				if (signal) {
-					const abort = () => waiter.reject(params.cancellationError("aborted", mayHaveWritten, signal.reason), "aborted");
-					signal.addEventListener("abort", abort, { once: true });
-					removeAbort = () => signal.removeEventListener("abort", abort);
-					if (signal.aborted) abort();
-				}
+		try {
+			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
 			});
-		},
-		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);
-			}
-		},
-		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");
-				}
-			}
-		},
-		close(error) {
-			if (finish("correlation-closed")) rejectWaiters(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");
-		},
-		markWritten() {
-			mayHaveWritten = true;
-			if (diagnostics && diagnostics.firstPossibleWriteAtMs === null) diagnostics.firstPossibleWriteAtMs = performance.now();
-		},
-		cleanup() {
-			for (const waiter of waiters) waiter.cleanup();
-		}
-	};
-}
-//#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;
+		} catch (error) {
+			if (this.active.get(request.id) === entry) {
+				embeddedAgentLog.warn("codex app-server server request handler failed", {
+					id: request.id,
+					method: request.method,
+					error
+				});
+				this.respond({
+					id: request.id,
+					error: {
+						code: -32603,
+						message: coerceErrorMessage(error)
+					}
+				});
 			}
-			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;
+		} finally {
+			settled = true;
+			clearTimeout(timeout);
+			controller.signal.removeEventListener("abort", onAbort);
+			if (this.active.get(request.id) === entry) this.active.delete(request.id);
 		}
-		pendingFrames.push(trimmed);
+	}
+};
+function defaultServerRequestResponse(request) {
+	if (request.method === "item/tool/call") return {
+		contentItems: [{
+			type: "inputText",
+			text: "OpenClaw did not register a handler for this app-server tool call."
+		}],
+		success: false
 	};
-	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 text = websocketFrameToText(data);
-		stdout.write(text.endsWith("\n") ? text : `${text}\n`);
-	});
-	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();
+	if (request.method === "item/commandExecution/requestApproval" || request.method === "item/fileChange/requestApproval") return { decision: "decline" };
+	if (request.method === "item/permissions/requestApproval") return {
+		permissions: {},
+		scope: "turn"
 	};
-	stdin.once("finish", closeSocket);
-	stdin.once("close", closeSocket);
+	if (request.method === "item/tool/requestUserInput") return { answers: {} };
+	if (request.method === "mcpServer/elicitation/request") return createCodexElicitationResponse("decline", null, { message: "OpenClaw has no interactive handler for this elicitation." });
+	return {};
+}
+function timeoutServerRequestResponse(timeoutMs) {
 	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)
+		contentItems: [{
+			type: "inputText",
+			text: `OpenClaw dynamic tool call timed out after ${timeoutMs}ms before sending a response to Codex.`
+		}],
+		success: false
 	};
 }
-/** 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 websocketFrameToText(data) {
-	if (typeof data === "string") return data;
-	if (Buffer.isBuffer(data)) return data.toString("utf8");
-	if (Array.isArray(data)) return Buffer.concat(data).toString("utf8");
-	return Buffer.from(data).toString("utf8");
-}
 //#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,
@@ -3410,15 +3400,11 @@ var client_exports = /* @__PURE__ */ __exportAll({
 	isUnsupportedCodexAppServerVersionError: () => isUnsupportedCodexAppServerVersionError,
 	resolveCodexAppServerClientInstanceId: () => resolveCodexAppServerClientInstanceId
 });
-const CODEX_APP_SERVER_PARSE_LOG_MAX = 500;
-const CODEX_APP_SERVER_PARSE_BUFFER_MAX = 8388608;
-const CODEX_APP_SERVER_PARSE_BUFFER_MAX_LINES = 1e3;
 const CODEX_APP_SERVER_STDERR_TAIL_MAX = 2e3;
 const CODEX_APP_SERVER_OVERLOAD_MAX_RETRIES = 3;
 const CODEX_APP_SERVER_OVERLOAD_RETRY_BASE_MS = 50;
 const CODEX_APP_SERVER_PENDING_STARTUP_WARNINGS_MAX = 32;
 const CODEX_APP_SERVER_CLIENT_INSTANCE_IDS = /* @__PURE__ */ new WeakMap();
-const UNPAIRED_SURROGATE_RE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g;
 /** Process-local generation fence for bindings tied to one app-server client instance. */
 function getCodexAppServerClientInstanceId(client) {
 	const current = CODEX_APP_SERVER_CLIENT_INSTANCE_IDS.get(client);
@@ -3477,19 +3463,19 @@ 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();
+		this.decoder = new CodexAppServerMessageDecoder(logCodexAppServerParseFailure);
+		this.catalogWorker = new CodexCatalogWorker();
 		this.pending = /* @__PURE__ */ new Map();
 		this.catalogResponses = /* @__PURE__ */ new WeakMap();
-		this.requestHandlers = /* @__PURE__ */ new Set();
+		this.serverRequests = new CodexServerRequests((response) => this.writeMessage(response));
 		this.notificationHandlers = /* @__PURE__ */ new Set();
 		this.pendingStartupWarnings = [];
 		this.closeHandlers = /* @__PURE__ */ new Set();
@@ -3503,28 +3489,24 @@ var CodexAppServerClient = class CodexAppServerClient {
 		this.privateTransportSecrets = /* @__PURE__ */ new Set();
 		this.privateStderrPending = "";
 		this.child = child;
-		this.lines = createInterface({ input: child.stdout });
-		this.lines.on("line", (line) => this.handleLine(line));
-		this.lines.on("error", (error) => this.closeWithError(toStringifiedError(error)));
+		this.closeMessageReader = listenCodexAppServerLines(child.stdout, (line) => {
+			const route = this.catalogWorker.continuation ?? (this.decoder.hasPending ? void 0 : readCodexCatalogDecodeRoute(line));
+			if (route) return this.decodeCatalogLine(line, route);
+			return this.handleParsedMessage(this.decoder.parse(line.toString("utf8")));
+		}, (error) => this.closeWithError(toStringifiedError(error)));
 		child.stdout.on("error", (error) => this.closeWithError(toStringifiedError(error)));
-		child.stderr.setEncoding("utf8");
-		child.stderr.on("data", (chunk) => {
+		observeCodexAppServerStderr(child.stderr, (chunk) => {
 			const text = this.redactPrivateStderr(chunk);
 			this.stderrTail = appendBoundedTail(this.stderrTail, text, CODEX_APP_SERVER_STDERR_TAIL_MAX);
-			const trimmed = text.trim();
-			if (trimmed) embeddedAgentLog.debug(`codex app-server stderr: ${trimmed}`);
-		});
-		child.stderr.on("error", (error) => {
-			embeddedAgentLog.warn("codex app-server stderr stream failed", { error });
+			return text;
 		});
 		child.once("error", (error) => this.closeWithError(toStringifiedError(error)));
 		child.once("exit", (code, signal) => {
 			this.transportExited = true;
-			this.closeWithError(buildCodexAppServerExitError(code, signal, this.stderrTail));
+			this.closeWithError(child.startupFailure?.error ?? buildCodexAppServerExitError(code, signal, this.stderrTail));
 		});
 		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 = {
@@ -3542,43 +3524,26 @@ var CodexAppServerClient = class CodexAppServerClient {
 			return client;
 		} catch (error) {
 			assertCurrent?.();
-			if (client?.transportExited && hasCodexAppServerNaturalExit(client.child)) throw buildCodexAppServerExitError(client.child.exitCode, client.child.signalCode, client.stderrTail);
+			if (client?.transportExited && hasCodexAppServerNaturalExit(client.child)) throw client.child.startupFailure?.error ?? buildCodexAppServerExitError(client.child.exitCode, client.child.signalCode, client.stderrTail);
 			const stderr = client?.getStderrDiagnostic();
 			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", {
-			clientInfo: {
-				name: "openclaw",
-				title: "OpenClaw",
-				version: OPENCLAW_VERSION
-			},
-			capabilities: {
-				experimentalApi: true,
-				extensions: {
-					"openai/standard-form-input": {},
-					"openai/form": {},
-					"io.modelcontextprotocol/ui": { mimeTypes: ["text/html;profile=mcp-app"] }
-				}
-			}
-		});
-		this.serverVersion = assertSupportedCodexAppServerVersion(response);
-		this.runtimeIdentity = buildCodexAppServerRuntimeIdentity(response, this.serverVersion);
+		const response = await this.request("initialize", buildCodexAppServerInitializeParams());
+		this.child.startupFailure?.complete();
+		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;
 	}
@@ -3717,7 +3682,7 @@ var CodexAppServerClient = class CodexAppServerClient {
 	requestOnce(method, params, options, overloadAttemptOrdinal, onWriteStateChange, deadline, onResponse) {
 		if (this.closed) return Promise.reject(this.closeError ?? /* @__PURE__ */ new Error("codex app-server client is closed"));
 		if (options.signal?.aborted) return Promise.reject(new CodexAppServerLocalRequestCancellationError(method, "aborted", false, options.signal?.reason));
-		const id = this.nextId++;
+		const id = codexCatalogRequestId(method, params, this.nextId++, options.catalogPreview);
 		if (method === "account/login/start" || method === "account/logout" || method === "config/value/write" || method === "config/batchWrite") this.modelCatalogRevision += 1;
 		const message = {
 			id,
@@ -3742,14 +3707,12 @@ var CodexAppServerClient = class CodexAppServerClient {
 			localError: (error, written) => written && !(error instanceof CodexAppServerRpcError) && !isCodexAppServerIndeterminateRequestCancellationError(error) && !isCodexAppServerIndeterminateTransportError(error) ? new CodexAppServerIndeterminateTransportError(method, error) : error
 		});
 		this.pending.set(id, attempt);
-		if (options.catalogPreview && method === "thread/list") this.catalogResponses.set(attempt, {
+		if (options.catalogPreview) this.catalogResponses.set(attempt, {
 			preview: options.catalogPreviewCache,
 			remainingRows: options.catalogRows
 		});
 		const result = attempt.wait({
 			...options,
-			assertCurrent: void 0,
-			disposition: "new",
 			overloadAttemptOrdinal
 		}, deadline);
 		if (!attempt.pending) return result;
@@ -3764,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.requestHandlers.add(handler);
-		return () => this.requestHandlers.delete(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);
@@ -3797,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 closeCodexAppServerTransportAndWait(this.child, options);
+		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) {
@@ -3871,65 +3823,16 @@ var CodexAppServerClient = class CodexAppServerClient {
 		this.privateStderrPending = held ? text.slice(-held) : "";
 		return held ? text.slice(0, -held) : text;
 	}
-	handleLine(line) {
-		const rawLine = line.endsWith("\r") ? line.slice(0, -1) : line;
-		if (this.pendingParse) {
-			this.handlePendingParseLine(rawLine);
-			return;
-		}
-		const trimmed = rawLine.trim();
-		if (!trimmed) return;
-		let parsed;
-		try {
-			parsed = JSON.parse(trimmed);
-		} catch (error) {
-			if (shouldBufferCodexAppServerParseFailure(trimmed, error)) {
-				this.pendingParse = {
-					text: trimmed,
-					lineCount: 1,
-					firstError: error
-				};
-				return;
-			}
-			logCodexAppServerParseFailure(trimmed, error, 1);
-			return;
-		}
-		this.handleParsedMessage(parsed);
-	}
-	handlePendingParseLine(line) {
-		const pending = this.pendingParse;
-		if (!pending) return;
-		const candidate = `${pending.text}\\n${line}`;
-		let parsed;
-		try {
-			parsed = JSON.parse(candidate);
-		} catch (error) {
-			const lineCount = pending.lineCount + 1;
-			if (shouldBufferCodexAppServerParseFailure(candidate.trim(), error) && candidate.length <= CODEX_APP_SERVER_PARSE_BUFFER_MAX && lineCount <= CODEX_APP_SERVER_PARSE_BUFFER_MAX_LINES) {
-				this.pendingParse = {
-					text: candidate,
-					lineCount,
-					firstError: pending.firstError
-				};
-				return;
-			}
-			this.pendingParse = void 0;
-			logCodexAppServerParseFailure(candidate, error, lineCount);
-			return;
-		}
-		this.pendingParse = void 0;
-		this.handleParsedMessage(parsed);
-	}
-	handleParsedMessage(parsed) {
-		if (!parsed || typeof parsed !== "object") return;
+	handleParsedMessage(parsed, previewStates) {
+		if (this.closed || !parsed || typeof parsed !== "object") return;
 		const message = parsed;
 		if (isRpcResponse(message)) {
-			this.handleResponse(message);
+			this.handleResponse(message, previewStates);
 			return;
 		}
 		if (!("method" in message)) return;
 		if ("id" in message && message.id !== void 0) {
-			this.handleServerRequest({
+			this.serverRequests.handle({
 				id: message.id,
 				method: message.method,
 				params: message.params
@@ -3941,83 +3844,19 @@ var CodexAppServerClient = class CodexAppServerClient {
 			params: message.params
 		});
 	}
-	handleResponse(response) {
-		this.nativeExecutionObserved = dispatchCodexAppServerResponse(response, this.pending, this.catalogResponses, codexCatalogSourceForClient(this)) || this.nativeExecutionObserved;
+	async decodeCatalogLine(line, route) {
+		const decoded = await this.catalogWorker.decode(line, route, this.pending, this.catalogResponses);
+		if (!decoded || this.closed) return;
+		for (const failure of decoded.failures) logCodexAppServerParseFailure(failure.value, failure.error, failure.fragmentCount);
+		if (decoded.projectionError) this.pending.get(decoded.projectionError.id)?.reject(decoded.projectionError.error, false);
+		else if (decoded.message) this.handleParsedMessage(decoded.message, decoded.previewStates);
 	}
-	async handleServerRequest(request) {
-		try {
-			const result = await this.runServerRequestHandlers(request);
-			if (result !== void 0) {
-				this.writeMessage({
-					id: request.id,
-					result
-				});
-				return;
-			}
-			this.writeMessage({
-				id: request.id,
-				result: defaultServerRequestResponse(request)
-			});
-		} catch (error) {
-			const message = coerceErrorMessage(error);
-			embeddedAgentLog.warn("codex app-server server request handler failed", {
-				id: request.id,
-				method: request.method,
-				error
-			});
-			this.writeMessage({
-				id: request.id,
-				error: {
-					code: -32603,
-					message
-				}
-			});
-		}
-	}
-	async runServerRequestHandlers(request) {
-		const controller = new AbortController();
-		if (request.method !== "item/tool/call") return await this.runServerRequestHandlersWithoutTimeout(request, controller.signal);
-		let timeoutMs = resolveDynamicToolServerRequestTimeoutMs(readCodexDynamicToolCallParams(request.params));
-		const deadline = createDeferred();
-		let timeout;
-		let settled = false;
-		let executionTimeoutResolved = false;
-		const armTimeout = () => {
-			clearTimeout(timeout);
-			timeout = setTimeout(() => {
-				embeddedAgentLog.warn("codex app-server server request timed out", {
-					id: request.id,
-					method: request.method,
-					timeoutMs
-				});
-				controller.abort(/* @__PURE__ */ new Error("codex app-server server request timed out"));
-				deadline.resolve(timeoutServerRequestResponse(timeoutMs));
-			}, timeoutMs);
-			timeout.unref?.();
-		};
-		const setExecutionTimeoutMs = (executionTimeoutMs) => {
-			if (settled || controller.signal.aborted || executionTimeoutResolved || !Number.isFinite(executionTimeoutMs) || executionTimeoutMs <= 0) return;
-			executionTimeoutResolved = true;
-			timeoutMs = addSafeTimeoutDelayGraceMs(executionTimeoutMs, 3e4);
-			armTimeout();
-		};
-		armTimeout();
-		try {
-			return await Promise.race([this.runServerRequestHandlersWithoutTimeout(request, controller.signal, setExecutionTimeoutMs), deadline.promise]);
-		} finally {
-			settled = true;
-			clearTimeout(timeout);
-		}
-	}
-	async runServerRequestHandlersWithoutTimeout(request, signal, setExecutionTimeoutMs) {
-		for (const handler of this.requestHandlers) {
-			if (signal.aborted) return;
-			const result = await handler(request, signal, setExecutionTimeoutMs);
-			if (result !== void 0) return result;
-		}
+	handleResponse(response, previewStates) {
+		this.nativeExecutionObserved = dispatchCodexAppServerResponse(response, this.pending, this.catalogResponses, codexCatalogSourceForClient(this), previewStates) || this.nativeExecutionObserved;
 	}
 	handleNotification(notification) {
 		const params = notification.params;
+		if (notification.method === "serverRequest/resolved") this.serverRequests.resolve(params);
 		if (notification.method === "item/commandExecution/outputDelta" || notification.method === "item/commandExecution/terminalInteraction" || isJsonObject(params) && (isJsonObject(params.item) && params.item.type === "commandExecution" || isJsonObject(params.turn) && Array.isArray(params.turn.items) && params.turn.items.some((item) => isJsonObject(item) && item.type === "commandExecution"))) this.nativeExecutionObserved = true;
 		if (notification.method === "account/updated") this.modelCatalogRevision += 1;
 		if (this.notificationHandlers.size === 0 && notification.method === "configWarning") {
@@ -4041,15 +3880,18 @@ var CodexAppServerClient = class CodexAppServerClient {
 		this.closed = true;
 		closeCodexCatalogClientSource(this);
 		this.closeError = error;
-		this.lines.close();
+		this.closeMessageReader();
+		this.decoder.clear();
+		this.catalogWorkerClosed = this.catalogWorker.close(error);
+		this.catalogWorkerClosed?.catch((closeError) => {
+			embeddedAgentLog.warn("codex catalog worker shutdown failed", { error: closeError });
+		});
+		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);
@@ -4058,36 +3900,6 @@ var CodexAppServerClient = class CodexAppServerClient {
 		}
 	}
 };
-function defaultServerRequestResponse(request) {
-	if (request.method === "item/tool/call") return {
-		contentItems: [{
-			type: "inputText",
-			text: "OpenClaw did not register a handler for this app-server tool call."
-		}],
-		success: false
-	};
-	if (request.method === "item/commandExecution/requestApproval" || request.method === "item/fileChange/requestApproval") return { decision: "decline" };
-	if (request.method === "item/permissions/requestApproval") return {
-		permissions: {},
-		scope: "turn"
-	};
-	if (request.method === "item/tool/requestUserInput") return { answers: {} };
-	if (request.method === "mcpServer/elicitation/request") return createCodexElicitationResponse("decline", null, { message: "OpenClaw has no interactive handler for this elicitation." });
-	return {};
-}
-function stringifyCodexAppServerMessage(message) {
-	return JSON.stringify(message, (_key, value) => typeof value === "string" ? value.replace(UNPAIRED_SURROGATE_RE, "") : value) ?? "null";
-}
-function timeoutServerRequestResponse(timeoutMs) {
-	return {
-		contentItems: [{
-			type: "inputText",
-			text: `OpenClaw dynamic tool call timed out after ${timeoutMs}ms before sending a response to Codex.`
-		}],
-		success: false
-	};
-}
-/** 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";
@@ -4101,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.154.0") > 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
 	});
@@ -4110,65 +3922,16 @@ 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];
 }
-function redactCodexAppServerLinePreview(value) {
-	const redacted = value.replace(/\s+/g, " ").trim().replace(/(Bearer\s+)[A-Za-z0-9._~+/-]+/gi, "$1<redacted>").replace(/("(?:api_?key|authorization|token|access_token|refresh_token)"\s*:\s*")([^"]+)(")/gi, "$1<redacted>$3").replace(/\b([a-z0-9_]*(?:api_?key|authorization|access_token|refresh_token|token))(\s*=\s*)(["']?)[^\s"']+(\3)/gi, "$1$2$3<redacted>$4");
-	return redacted.length > CODEX_APP_SERVER_PARSE_LOG_MAX ? `${truncateUtf16Safe(redacted, CODEX_APP_SERVER_PARSE_LOG_MAX)}...` : redacted;
-}
-function appendBoundedTail(current, next, maxLength) {
-	const combined = `${current}${next}`;
-	return combined.length > maxLength ? sliceUtf16Safe(combined, -maxLength) : combined;
-}
-function buildCodexAppServerExitError(code, signal, stderrTail) {
-	const stderrPreview = redactCodexAppServerLinePreview(stderrTail);
-	const suffix = stderrPreview ? ` stderr=${JSON.stringify(stderrPreview)}` : "";
-	return /* @__PURE__ */ new Error(`codex app-server exited: code=${formatExitValue(code)} signal=${formatExitValue(signal)}${suffix}`);
-}
-function shouldBufferCodexAppServerParseFailure(value, error) {
-	if (!value.startsWith("{") && !value.startsWith("[")) return false;
-	const message = coerceErrorMessage(error);
-	return message.includes("Unterminated string") || message.includes("Unexpected end of JSON input");
-}
-function logCodexAppServerParseFailure(value, error, fragmentCount) {
-	const linePreview = redactCodexAppServerLinePreview(value);
-	const suffix = fragmentCount > 1 ? ` fragments=${fragmentCount}` : "";
-	embeddedAgentLog.warn("failed to parse codex app-server message", {
-		error,
-		errorMessage: coerceErrorMessage(error),
-		fragmentCount,
-		linePreview,
-		consoleMessage: `failed to parse codex app-server message${suffix}: preview=${JSON.stringify(linePreview)}`
-	});
-}
 const CODEX_APP_SERVER_APPROVAL_REQUEST_METHODS = /* @__PURE__ */ new Set([
 	"item/commandExecution/requestApproval",
 	"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);
 }
-function formatExitValue(value) {
-	if (value === null || value === void 0) return "null";
-	if (typeof value === "string" || typeof value === "number") return String(value);
-	return "unknown";
-}
 //#endregion
-export { isMatchingDynamicToolTerminalDiagnostic as A, withDynamicToolTranscriptDetails as B, readCodexErrorNotification 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, readCodexDynamicToolCallParams as S, readCodexTurnCompletedNotification as T, assertCodexThreadAcceptsDirectInput as _, isCodexAppServerBrokenPipeError as a, assertCodexThreadStartResponse as b, isCodexAppServerIndeterminateTransportError as c, isCodexAppServerRequestTimeoutError as d, isUnsupportedCodexAppServerVersionError as f, assertCodexPassiveTurnItems as g, assertCodexModelListResponse as h, isCodexAppServerApprovalRequest as i, resolveDynamicToolCallTimeoutMs as j, isDynamicToolTerminalDiagnosticEvent as k, isCodexAppServerOverloadError as l, CodexThreadDirectInputError as m, client_exports as n, isCodexAppServerConnectionClosedError as o, resolveCodexAppServerClientInstanceId as p, getCodexAppServerClientInstanceId as r, isCodexAppServerIndeterminateRequestCancellationError as s, CodexAppServerClient as t, isCodexAppServerPrewriteRequestCancellationError as u, assertCodexThreadForkResponse as v, readCodexTurn as w, assertCodexTurnStartResponse as x, assertCodexThreadResumeResponse as y, withDynamicToolExecutionState 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 };