@openclaw/codex 2026.9.5 → 2026.9.6

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

@@ -1,11 +1,14 @@
 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 { 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 { 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 { codexCatalogPageWorkerEntrypoint } from "../catalog-page-worker-entrypoint.js";
 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";
@@ -17,23 +20,188 @@ import { sliceUtf16Safe, truncateUtf16Safe } from "openclaw/plugin-sdk/text-util
 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 { 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;
+/** 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.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);
+			}
+		}
+		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;
+		return decoded;
+	}
+	close(error) {
+		this.closed = true;
+		this.continuationRoute = void 0;
+		return this.pool?.close(error) ?? Promise.resolve();
+	}
+};
+//#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"] }
+			}
+		}
+	};
 }
 //#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 +211,218 @@ 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 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();
+		}
+		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"
+			};
+		}
+		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, 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();
+				}
+			});
+		},
+		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();
 		},
-		executionStarted: {
-			configurable: true,
-			enumerable: false,
-			value: state.executionStarted
+		cleanup() {
+			for (const waiter of waiters) waiter.cleanup();
 		}
-	});
-	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
@@ -244,11 +518,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 +541,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, {
@@ -319,15 +602,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 +659,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 +669,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) {
@@ -2943,14 +3239,15 @@ function assertCodexThreadAcceptsDirectInput(thread) {
 }
 /** Asserts and normalizes a Codex turn/start response. */
 function assertCodexTurnStartResponse(value) {
-	const normalized = normalizeWithDefaults(turnStartResponseSchema, normalizeTurnEnvelope(value));
+	const normalized = normalizeWithDefaults(turnStartResponseSchema, value);
 	return assertCodexShape(validateTurnStartResponse, normalized, "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];
@@ -2974,13 +3271,10 @@ function readCodexErrorNotification(value) {
 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;
-}
 /** 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, normalizeWithDefaults(turnCompletedNotificationSchema, value));
+	return notification?.turn.status === "inProgress" ? void 0 : notification;
 }
 function assertCodexShape(validate, value, label) {
 	if (validate.check(value)) return value;
@@ -2989,54 +3283,6 @@ function assertCodexShape(validate, value, label) {
 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)
-	};
-}
 function formatValidationErrors(validate, value) {
 	const errors = validate.errors(value);
 	if (!errors || errors.length === 0) return "schema validation failed";
@@ -3046,169 +3292,130 @@ 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.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) {
+		const requests = [...this.active.values()];
+		this.active.clear();
+		for (const request of requests) request.controller.abort(error);
+	}
+	async handle(request) {
+		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 result = await Promise.race([run(), 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");
-				}
+		} 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)
+					}
+				});
 			}
-		},
-		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();
+		} finally {
+			settled = true;
+			clearTimeout(timeout);
+			controller.signal.removeEventListener("abort", onAbort);
+			if (this.active.get(request.id) === entry) this.active.delete(request.id);
 		}
+	}
+};
+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 timeoutServerRequestResponse(timeoutMs) {
+	return {
+		contentItems: [{
+			type: "inputText",
+			text: `OpenClaw dynamic tool call timed out after ${timeoutMs}ms before sending a response to Codex.`
+		}],
+		success: false
 	};
 }
 //#endregion
@@ -3325,8 +3532,13 @@ function createWebSocketTransport(options) {
 	});
 	socket.on("message", (data) => {
 		if (options.transport === "websocket") recordConnectionActivity();
-		const text = websocketFrameToText(data);
-		stdout.write(text.endsWith("\n") ? text : `${text}\n`);
+		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) {
@@ -3384,11 +3596,11 @@ function resolveCodexAppServerUnixSocketPath(options) {
 	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");
+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
@@ -3410,15 +3622,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);
@@ -3487,9 +3695,11 @@ function isCodexAppServerConnectionClosedError(error) {
 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,24 +3713,21 @@ 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)));
 	}
@@ -3542,7 +3749,7 @@ 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;
 		}
@@ -3554,21 +3761,8 @@ var CodexAppServerClient = class CodexAppServerClient {
 	/** 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"] }
-				}
-			}
-		});
+		const response = await this.request("initialize", buildCodexAppServerInitializeParams());
+		this.child.startupFailure?.complete();
 		this.serverVersion = assertSupportedCodexAppServerVersion(response);
 		this.runtimeIdentity = buildCodexAppServerRuntimeIdentity(response, this.serverVersion);
 		this.notify("initialized");
@@ -3717,7 +3911,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,7 +3936,7 @@ 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
 		});
@@ -3773,8 +3967,8 @@ var CodexAppServerClient = class CodexAppServerClient {
 	}
 	/** 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) {
@@ -3805,7 +3999,7 @@ var CodexAppServerClient = class CodexAppServerClient {
 	/** 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.catalogWorkerClosed]);
 		return this.nativeExecutionObserved ? {
 			...result,
 			cleanup: "uncertain"
@@ -3871,65 +4065,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 +4086,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,7 +4122,13 @@ 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.serverRequests.close(error);
 		this.rejectPendingRequests(error);
 		return true;
 	}
@@ -4058,35 +4145,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) {
@@ -4101,7 +4159,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.155.1") > 0) embeddedAgentLog.warn("codex app-server is newer than OpenClaw's managed runtime; continuing with normal startup validation", {
 		detectedVersion,
 		validatedVersion: CODEX_APP_SERVER_VERSION
 	});
@@ -4127,35 +4185,6 @@ function buildCodexAppServerRuntimeIdentity(response, serverVersion) {
 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",
@@ -4165,10 +4194,5 @@ const CODEX_APP_SERVER_APPROVAL_REQUEST_METHODS = /* @__PURE__ */ new Set([
 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 { 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 };