@openclaw/codex 2026.9.4 → 2026.9.6

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

@@ -1,123 +1,428 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { l as resolveCodexAppServerUserHomeDir, o as isJsonObject } from "./protocol-5bh1G-H7.js";
-import { r as MIN_SUPPORTED_CODEX_APP_SERVER_VERSION, t as CODEX_APP_SERVER_VERSION } from "./version-omm6IPI3.js";
-import { a as hasCodexAppServerNaturalExit, i as closeCodexAppServerTransportAndWait, r as closeCodexAppServerTransport, t as createStdioTransport } from "./transport-stdio-BGjHoYLr.js";
-import { t as CodexAppServerRpcError } from "./rpc-error-ttN_QjEm.js";
-import "./config-oIORaQ5T.js";
-import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-D0zGNIHu.js";
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
+import { p as resolveCodexAppServerUserHomeDir } from "./config-security-BEReZ6go.mjs";
+import { d as recordCodexCatalogResponseSource, i as reuseCodexCatalogPreview, o as closeCodexCatalogClientSource, s as codexCatalogSourceForClient } from "./session-catalog-native-projection-DowriLid.mjs";
+import { a as stringifyCodexAppServerMessage, c as isRpcResponse, i as readCodexCatalogDecodeRoute, n as projectCodexCatalogMessage, o as CodexAppServerMessageDecoder, r as listenCodexAppServerLines, s as redactCodexAppServerLinePreview } from "./client-catalog-response-BMgt_4q4.mjs";
+import { 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 { addTimerTimeoutGraceMs, parseStrictNonNegativeInteger } from "openclaw/plugin-sdk/number-runtime";
+import { addSafeTimeoutDelayGraceMs, addTimerTimeoutGraceMs, parseStrictNonNegativeInteger } from "openclaw/plugin-sdk/number-runtime";
+import { normalizeJsonSchemaForTypeBox } from "openclaw/plugin-sdk/json-schema-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 { 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 { hasPendingInternalDiagnosticEvent } from "openclaw/plugin-sdk/diagnostic-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 "ws";
-//#region extensions/codex/src/app-server/protocol-json.ts
-function isRpcResponse(message) {
-	return "id" in message && !("method" in message);
+import { WebSocket } from "openclaw/plugin-sdk/websocket-runtime";
+//#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;
 }
-//#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
-			} } : {}
+/** 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]
 		});
-		withDynamicToolSideEffectEvidence(response, terminalResolution.sideEffectEvidence);
+		if (this.closed) return;
+		this.continuationRoute = decoded.pending ? route : void 0;
+		return decoded;
 	}
-	return response;
+	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 withDynamicToolExecutionState(response, state) {
-	Object.defineProperties(response, {
-		executedArguments: {
-			configurable: true,
-			enumerable: false,
-			value: state.executedArguments
+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
 		},
-		executionStarted: {
-			configurable: true,
-			enumerable: false,
-			value: state.executionStarted
+		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"] }
+			}
 		}
-	});
-	return withDynamicToolSideEffectEvidence(response, state.sideEffectEvidence === true);
+	};
 }
-function withDynamicToolSideEffectEvidence(response, sideEffectEvidence) {
-	if (!sideEffectEvidence) {
-		delete response.sideEffectEvidence;
-		return response;
+//#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, previewStates) {
+	const pending = attempts.get(response.id);
+	if (!pending) return false;
+	attempts.delete(response.id);
+	if (response.error) {
+		const error = new CodexAppServerRpcError(response.error, pending.method);
+		pending.reject(error, error.code === CODEX_APP_SERVER_OVERLOADED_ERROR_CODE);
+		return false;
 	}
-	Object.defineProperty(response, "sideEffectEvidence", {
-		configurable: true,
-		enumerable: false,
-		value: true
-	});
-	return response;
+	const nativeExecution = pending.method === "thread/backgroundTerminals/list" && isJsonObject(response.result) && Array.isArray(response.result.data) && response.result.data.length > 0;
+	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/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();
+		},
+		cleanup() {
+			for (const waiter of waiters) waiter.cleanup();
+		}
+	};
+}
+//#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
@@ -153,7 +458,7 @@ function resolveCodexToolAbortTerminalReason(signal) {
 */
 /** Default timeout for Codex dynamic tool calls. */
 const CODEX_DYNAMIC_TOOL_TIMEOUT_MS = 9e4;
-/** Hard cap for per-call Codex dynamic tool timeout overrides. */
+/** 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;
@@ -213,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) => {
@@ -227,15 +534,25 @@ async function handleDynamicToolCallWithTimeout(params) {
 		const terminalResolution = params.observeToolTerminal?.({
 			toolCallId: params.call.callId,
 			toolName: params.call.tool,
-			result: response,
+			result: copyInternalToolResultState(response, {
+				...response,
+				details: response.transcriptDetails
+			}),
 			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, {
@@ -285,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;
 	});
@@ -331,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.");
@@ -339,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) {
@@ -413,6 +743,10 @@ 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") {
+		const executionTimeoutMs = params.toolBridge?.availableTools.find((tool) => tool.name === params.call.tool)?.getExecutionTimeoutMs?.(params.call.arguments);
+		if (executionTimeoutMs !== void 0) return addSafeTimeoutDelayGraceMs(executionTimeoutMs, CODEX_DYNAMIC_TOOL_TIMEOUT_SECONDS_GRACE_MS);
+	}
 	if (params.call.tool === "openclaw" || params.call.tool === "ask_user" || params.call.tool === "secrets" && args?.action === "request") try {
 		const timeoutSeconds = params.call.tool === "openclaw" ? void 0 : args?.timeoutSeconds;
 		return normalizeQuestionTimeoutSeconds(timeoutSeconds) * 1e3 + CODEX_DYNAMIC_TOOL_TIMEOUT_SECONDS_GRACE_MS;
@@ -459,7 +793,6 @@ function readConfiguredDynamicToolTimeoutMs(toolName, config) {
 		const capabilityTimeoutMs = readTimeoutSecondsAsMs(config?.tools?.media?.image?.timeoutSeconds);
 		return Math.max(capabilityTimeoutMs ?? CODEX_DYNAMIC_IMAGE_TOOL_TIMEOUT_MS, ...candidates.map((entry) => readTimeoutSecondsAsMs(entry.timeoutSeconds) ?? capabilityTimeoutMs ?? CODEX_DYNAMIC_IMAGE_TOOL_TIMEOUT_MS));
 	}
-	if (toolName === "message") return CODEX_DYNAMIC_MESSAGE_TOOL_TIMEOUT_MS;
 }
 function readTimeoutSecondsAsMs(value) {
 	const seconds = readPositiveFiniteTimeoutMs(value);
@@ -2808,60 +3141,16 @@ const threadStartResponseSchema = materializeCodexSchema(ThreadStartResponse_def
 const turnCompletedNotificationSchema = materializeCodexSchema(TurnCompletedNotification_default);
 const turnStartResponseSchema = materializeCodexSchema(TurnStartResponse_default);
 function compileCodexSchema(schema) {
-	const validator = Compile(normalizeJsonSchemaNode(schema));
+	if (typeof schema !== "boolean" && !isRecord(schema)) throw new TypeError("Generated Codex schema must be an object or boolean");
+	const validator = Compile(normalizeJsonSchemaForTypeBox(schema));
 	return {
 		check: (value) => validator.Check(value),
 		errors: (value) => [...validator.Errors(value)]
 	};
 }
-const schemaMapKeywords = /* @__PURE__ */ new Set([
-	"$defs",
-	"definitions",
-	"dependentSchemas",
-	"patternProperties",
-	"properties"
-]);
-const schemaValueKeywords = /* @__PURE__ */ new Set([
-	"additionalItems",
-	"additionalProperties",
-	"contains",
-	"else",
-	"if",
-	"items",
-	"not",
-	"propertyNames",
-	"then",
-	"unevaluatedItems",
-	"unevaluatedProperties"
-]);
-const schemaArrayKeywords = /* @__PURE__ */ new Set([
-	"allOf",
-	"anyOf",
-	"oneOf",
-	"prefixItems"
-]);
 function schemaTypeIncludes(schema, type) {
 	return schema.type === type || Array.isArray(schema.type) && schema.type.includes(type);
 }
-function normalizeSchemaMap(value) {
-	if (!isRecord(value)) return value;
-	return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, normalizeJsonSchemaNode(entry)]));
-}
-function expandJsonSchemaTypeArray(schema) {
-	const { type, ...rest } = schema;
-	if (!Array.isArray(type)) return schema;
-	return { anyOf: type.map((entry) => Object.assign({}, rest, { type: entry })) };
-}
-function normalizeJsonSchemaNode(schema) {
-	if (Array.isArray(schema)) return schema.map((entry) => normalizeJsonSchemaNode(entry));
-	if (!isRecord(schema)) return schema;
-	const normalizedSchema = expandJsonSchemaTypeArray(schema);
-	return Object.fromEntries(Object.entries(normalizedSchema).map(([key, value]) => {
-		if (schemaMapKeywords.has(key)) return [key, normalizeSchemaMap(value)];
-		if (schemaValueKeywords.has(key) || schemaArrayKeywords.has(key)) return [key, normalizeJsonSchemaNode(value)];
-		return [key, value];
-	}));
-}
 function readDefault(schema) {
 	if (!isRecord(schema) || !Object.hasOwn(schema, "default")) return;
 	return structuredClone(schema.default);
@@ -2950,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];
@@ -2981,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;
@@ -2996,62 +3283,141 @@ 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 formatValidationErrors(validate, value) {
+	const errors = validate.errors(value);
+	if (!errors || errors.length === 0) return "schema validation failed";
+	return errors.map((error) => {
+		const message = error.message?.trim() || "schema validation failed";
+		return error.instancePath ? `${error.instancePath} ${message}` : message;
+	}).join("; ");
 }
-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
+//#endregion
+//#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());
+		}
+	}
+	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
 		};
-		case "plan": return {
-			text: "",
-			...value
+		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?.();
 		};
-		case "reasoning": return {
-			summary: [],
-			content: [],
-			...value
+		const setExecutionTimeoutMs = (executionTimeoutMs) => {
+			if (settled || controller.signal.aborted || executionTimeoutResolved || !Number.isFinite(executionTimeoutMs) || executionTimeoutMs <= 0) return;
+			executionTimeoutResolved = true;
+			timeoutMs = addSafeTimeoutDelayGraceMs(executionTimeoutMs, 3e4);
+			armTimeout();
 		};
-		case "dynamicToolCall": return {
-			namespace: null,
-			arguments: null,
-			status: "completed",
-			contentItems: null,
-			success: null,
-			durationMs: null,
-			...value
+		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;
+			}
 		};
-		default: return value;
+		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
+			});
+		} 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)
+					}
+				});
+			}
+		} 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 normalizeTurnEnvelope(value) {
-	if (!value || typeof value !== "object" || Array.isArray(value) || !("turn" in value)) return value;
+function timeoutServerRequestResponse(timeoutMs) {
 	return {
-		...value,
-		turn: normalizeTurn(value.turn)
+		contentItems: [{
+			type: "inputText",
+			text: `OpenClaw dynamic tool call timed out after ${timeoutMs}ms before sending a response to Codex.`
+		}],
+		success: false
 	};
 }
-function formatValidationErrors(validate, value) {
-	const errors = validate.errors(value);
-	if (!errors || errors.length === 0) return "schema validation failed";
-	return errors.map((error) => {
-		const message = error.message?.trim() || "schema validation failed";
-		return error.instancePath ? `${error.instancePath} ${message}` : message;
-	}).join("; ");
-}
 //#endregion
 //#region extensions/codex/src/app-server/transport-websocket.ts
 /**
@@ -3085,6 +3451,7 @@ function createWebSocketTransport(options) {
 	const stdinDecoder = new StringDecoder("utf8");
 	let pendingLine = "";
 	let killed = false;
+	let exitCode = null;
 	let pingTimeout;
 	let pongTimeout;
 	let expectedPong;
@@ -3160,12 +3527,18 @@ function createWebSocketTransport(options) {
 	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 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) {
@@ -3196,12 +3569,17 @@ function createWebSocketTransport(options) {
 		get killed() {
 			return killed;
 		},
-		kill: () => {
+		get exitCode() {
+			return exitCode;
+		},
+		kill: (signal) => {
 			killed = true;
 			clearConnectionHealthTimers();
-			socket.close();
+			if (signal === "SIGKILL") socket.terminate();
+			else socket.close();
 		},
-		once: (event, listener) => events.once(event, listener)
+		once: (event, listener) => events.once(event, listener),
+		off: (event, listener) => events.off(event, listener)
 	};
 }
 /** Opens the owner-scoped Codex control socket used by the WebSocket upgrade. */
@@ -3218,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
@@ -3244,16 +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_OVERLOADED_ERROR_CODE = -32001;
 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);
@@ -3267,11 +3640,12 @@ function resolveCodexAppServerClientInstanceId(client) {
 }
 /** Codex rejects this exact code before enqueueing, including mutating requests. */
 function isCodexAppServerOverloadError(error) {
-	return error instanceof CodexAppServerRpcError && error.code === CODEX_APP_SERVER_OVERLOADED_ERROR_CODE;
+	return error instanceof CodexAppServerRpcError && error.code === -32001;
 }
 var CodexAppServerLocalRequestCancellationError = class extends Error {
-	constructor(method, reason, mayHaveWritten) {
-		super(`${method} ${reason}`);
+	constructor(method, reason, mayHaveWritten, cause) {
+		const detail = cause instanceof Error || typeof cause === "string" ? coerceErrorMessage(cause) : void 0;
+		super(`${method} ${reason}${detail ? `: ${detail}` : ""}`, { cause });
 		this.reason = reason;
 		this.mayHaveWritten = mayHaveWritten;
 		this.code = "CODEX_APP_SERVER_LOCAL_REQUEST_CANCELLED";
@@ -3321,8 +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.requestHandlers = /* @__PURE__ */ new Set();
+		this.catalogResponses = /* @__PURE__ */ new WeakMap();
+		this.serverRequests = new CodexServerRequests((response) => this.writeMessage(response));
 		this.notificationHandlers = /* @__PURE__ */ new Set();
 		this.pendingStartupWarnings = [];
 		this.closeHandlers = /* @__PURE__ */ new Set();
@@ -3336,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)));
 	}
@@ -3375,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;
 		}
@@ -3387,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");
@@ -3431,9 +3792,10 @@ var CodexAppServerClient = class CodexAppServerClient {
 	getModelCatalogRevision() {
 		return this.modelCatalogRevision;
 	}
-	/** Installs the spawn-owner check run before config-loading thread requests. */
-	setThreadSessionRequestGuard(guard) {
+	/** Installs the spawn-owner guard and retirement for config-loading thread requests. */
+	setThreadSessionRequestGuard(guard, retireAfterIndeterminateRequest) {
 		this.threadSessionRequestGuard = guard;
+		this.retireAfterIndeterminateThreadRequest = retireAfterIndeterminateRequest;
 	}
 	/** Returns the local transport PID for scoped child-process cleanup, when available. */
 	getTransportPid() {
@@ -3442,12 +3804,13 @@ var CodexAppServerClient = class CodexAppServerClient {
 	request(method, params, optionsInput) {
 		const options = optionsInput ?? {};
 		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));
+		if (options.signal?.aborted) return Promise.reject(new CodexAppServerLocalRequestCancellationError(method, "aborted", false, options.signal?.reason));
 		const guard = method === "thread/start" || method === "thread/resume" || method === "thread/fork" ? this.threadSessionRequestGuard : void 0;
 		if (guard) {
+			const retire = this.retireAfterIndeterminateThreadRequest;
 			if (!options.signal && !(options.timeoutMs !== void 0 && Number.isFinite(options.timeoutMs) && options.timeoutMs > 0)) return Promise.reject(/* @__PURE__ */ new TypeError(`${method} requires a positive finite timeout or abort signal`));
 			return (async () => {
-				const guardStartedAt = Date.now();
+				const guardStartedAt = performance.now();
 				const timeoutMessage = `${method} timed out`;
 				const abortMessage = `${method} aborted`;
 				let releaseGuard;
@@ -3460,19 +3823,22 @@ var CodexAppServerClient = class CodexAppServerClient {
 					});
 				} catch (error) {
 					if (error instanceof Error && error.message === timeoutMessage) throw new CodexAppServerLocalRequestCancellationError(method, "timed out", false);
-					if (error instanceof Error && error.message === abortMessage) throw new CodexAppServerLocalRequestCancellationError(method, "aborted", false);
+					if (error instanceof Error && error.message === abortMessage) throw new CodexAppServerLocalRequestCancellationError(method, "aborted", false, options.signal?.reason);
 					throw error;
 				}
 				let released = false;
+				let removeExitHandler;
 				const release = () => {
 					if (released) return;
 					released = true;
+					removeExitHandler?.();
 					releaseGuard();
 				};
 				let releaseWhenRequestSettles = true;
 				let requestMayHaveWritten = false;
+				let nativeResponded = false;
 				try {
-					const elapsedMs = Date.now() - guardStartedAt;
+					const elapsedMs = performance.now() - guardStartedAt;
 					const remainingTimeoutMs = options.timeoutMs === void 0 ? void 0 : options.timeoutMs - elapsedMs;
 					if (remainingTimeoutMs !== void 0 && remainingTimeoutMs <= 0) throw new CodexAppServerLocalRequestCancellationError(method, "timed out", false);
 					return await this.requestWithOverloadRetry(method, params, {
@@ -3480,11 +3846,17 @@ var CodexAppServerClient = class CodexAppServerClient {
 						...remainingTimeoutMs !== void 0 ? { timeoutMs: remainingTimeoutMs } : {}
 					}, (mayHaveWritten) => {
 						requestMayHaveWritten = mayHaveWritten;
+						nativeResponded = !mayHaveWritten;
+					}, () => {
+						nativeResponded = true;
+						if (!releaseWhenRequestSettles) release();
 					});
 				} catch (error) {
 					if (requestMayHaveWritten && !(error instanceof CodexAppServerRpcError)) {
 						releaseWhenRequestSettles = false;
-						await this.closeAndRunAfterExit(release, method);
+						if (nativeResponded) release();
+						else removeExitHandler = this.addTransportExitHandler(release);
+						if (!retire?.()) await this.closeAndRunAfterExit(release, method);
 					}
 					throw error;
 				} finally {
@@ -3494,17 +3866,17 @@ var CodexAppServerClient = class CodexAppServerClient {
 		}
 		return this.requestWithOverloadRetry(method, params, options);
 	}
-	async requestWithOverloadRetry(method, params, options, onWriteStateChange) {
-		const deadline = options.timeoutMs !== void 0 && Number.isFinite(options.timeoutMs) ? Date.now() + options.timeoutMs : void 0;
+	async requestWithOverloadRetry(method, params, options, onWriteStateChange, onResponse) {
+		const deadline = options.timeoutMs !== void 0 && Number.isFinite(options.timeoutMs) ? performance.now() + options.timeoutMs : void 0;
 		for (let retry = 0;; retry += 1) {
-			if (options.signal?.aborted) throw new CodexAppServerLocalRequestCancellationError(method, "aborted", false);
-			const remainingTimeoutMs = deadline === void 0 ? void 0 : deadline - Date.now();
+			if (options.signal?.aborted) throw new CodexAppServerLocalRequestCancellationError(method, "aborted", false, options.signal?.reason);
+			const remainingTimeoutMs = deadline === void 0 ? void 0 : deadline - performance.now();
 			if (remainingTimeoutMs !== void 0 && remainingTimeoutMs <= 0) throw new CodexAppServerLocalRequestCancellationError(method, "timed out", false);
 			try {
 				return await this.requestOnce(method, params, {
 					...options,
 					...remainingTimeoutMs !== void 0 ? { timeoutMs: remainingTimeoutMs } : {}
-				}, onWriteStateChange);
+				}, retry + 1, onWriteStateChange, deadline, onResponse);
 			} catch (error) {
 				if (!isCodexAppServerOverloadError(error) || retry >= CODEX_APP_SERVER_OVERLOAD_MAX_RETRIES) throw error;
 				onWriteStateChange?.(false);
@@ -3514,8 +3886,8 @@ var CodexAppServerClient = class CodexAppServerClient {
 		}
 	}
 	async waitForOverloadRetry(method, backoffMs, deadline, signal) {
-		if (signal?.aborted) throw new CodexAppServerLocalRequestCancellationError(method, "aborted", false);
-		const remainingMs = deadline === void 0 ? void 0 : deadline - Date.now();
+		if (signal?.aborted) throw new CodexAppServerLocalRequestCancellationError(method, "aborted", false, signal?.reason);
+		const remainingMs = deadline === void 0 ? void 0 : deadline - performance.now();
 		if (remainingMs !== void 0 && remainingMs <= 0) throw new CodexAppServerLocalRequestCancellationError(method, "timed out", false);
 		const delayMs = remainingMs === void 0 ? backoffMs : Math.min(backoffMs, remainingMs);
 		await new Promise((resolve, reject) => {
@@ -3526,7 +3898,7 @@ var CodexAppServerClient = class CodexAppServerClient {
 			timer.unref?.();
 			const abortListener = () => {
 				cleanup();
-				reject(new CodexAppServerLocalRequestCancellationError(method, "aborted", false));
+				reject(new CodexAppServerLocalRequestCancellationError(method, "aborted", false, signal?.reason));
 			};
 			const cleanup = () => {
 				clearTimeout(timer);
@@ -3536,69 +3908,55 @@ var CodexAppServerClient = class CodexAppServerClient {
 			if (signal?.aborted) abortListener();
 		});
 	}
-	requestOnce(method, params, options, onWriteStateChange) {
+	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));
-		const id = this.nextId++;
+		if (options.signal?.aborted) return Promise.reject(new CodexAppServerLocalRequestCancellationError(method, "aborted", false, options.signal?.reason));
+		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,
 			method,
 			params
 		};
-		return new Promise((resolve, reject) => {
-			let timeout;
-			let cleanupAbort;
-			let mayHaveWritten = false;
-			const cleanup = () => {
-				if (timeout) {
-					clearTimeout(timeout);
-					timeout = void 0;
-				}
-				cleanupAbort?.();
-				cleanupAbort = void 0;
-			};
-			const rejectPending = (error) => {
-				if (!this.pending.has(id)) return;
-				this.pending.delete(id);
-				cleanup();
-				reject(mayHaveWritten && !(error instanceof CodexAppServerRpcError) && !isCodexAppServerIndeterminateRequestCancellationError(error) && !isCodexAppServerIndeterminateTransportError(error) ? new CodexAppServerIndeterminateTransportError(method, error) : error);
-			};
-			if (options.timeoutMs && Number.isFinite(options.timeoutMs) && options.timeoutMs > 0) {
-				timeout = setTimeout(() => rejectPending(new CodexAppServerLocalRequestCancellationError(method, "timed out", mayHaveWritten)), Math.max(100, options.timeoutMs));
-				timeout.unref?.();
-			}
-			if (options.signal) {
-				const abortListener = () => rejectPending(new CodexAppServerLocalRequestCancellationError(method, "aborted", mayHaveWritten));
-				options.signal.addEventListener("abort", abortListener, { once: true });
-				cleanupAbort = () => options.signal?.removeEventListener("abort", abortListener);
-			}
-			this.pending.set(id, {
-				method,
-				resolve: (value) => {
-					cleanup();
-					resolve(value);
-				},
-				reject: (error) => {
-					cleanup();
-					reject(mayHaveWritten && !(error instanceof CodexAppServerRpcError) && !isCodexAppServerIndeterminateRequestCancellationError(error) && !isCodexAppServerIndeterminateTransportError(error) ? new CodexAppServerIndeterminateTransportError(method, error) : error);
-				},
-				cleanup
-			});
-			if (options.signal?.aborted) {
-				rejectPending(new CodexAppServerLocalRequestCancellationError(method, "aborted", false));
-				return;
-			}
-			try {
-				options.assertCurrent?.();
-				this.writeMessage(message, (error) => rejectPending(error), () => {
-					mayHaveWritten = true;
-					onWriteStateChange?.(true);
-				});
-			} catch (error) {
-				rejectPending(toStringifiedError(error));
-			}
+		const attempt = createCodexRequestAttempt({
+			method,
+			retainWritten: onResponse !== void 0,
+			...method === "thread/list" ? { diagnosticIdentity: {
+				clientInstanceId: this.instanceId,
+				rpcId: id
+			} } : {},
+			onResponse: onResponse ? (mayHaveWritten) => {
+				onWriteStateChange?.(mayHaveWritten);
+				onResponse();
+			} : void 0,
+			onSettled: () => {
+				if (this.pending.get(id) === attempt) this.pending.delete(id);
+			},
+			cancellationError: (reason, written, cause) => new CodexAppServerLocalRequestCancellationError(method, reason, written, cause),
+			localError: (error, written) => written && !(error instanceof CodexAppServerRpcError) && !isCodexAppServerIndeterminateRequestCancellationError(error) && !isCodexAppServerIndeterminateTransportError(error) ? new CodexAppServerIndeterminateTransportError(method, error) : error
+		});
+		this.pending.set(id, 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;
+		try {
+			options.assertCurrent?.();
+			if (attempt.pending) this.writeMessage(message, (error) => attempt.failLocal(error), () => {
+				attempt.markWritten();
+				onWriteStateChange?.(true);
+			});
+		} catch (error) {
+			attempt.failLocal(toStringifiedError(error));
+		}
+		return result;
 	}
 	/** Sends a fire-and-forget JSON-RPC notification to the app-server. */
 	notify(method, params) {
@@ -3609,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) {
@@ -3641,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"
@@ -3707,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
@@ -3777,79 +4086,19 @@ var CodexAppServerClient = class CodexAppServerClient {
 			params: message.params
 		});
 	}
-	handleResponse(response) {
-		const pending = this.pending.get(response.id);
-		if (!pending) return;
-		this.pending.delete(response.id);
-		if (response.error) {
-			pending.reject(new CodexAppServerRpcError(response.error, pending.method));
-			return;
-		}
-		if (pending.method === "thread/backgroundTerminals/list" && isJsonObject(response.result) && Array.isArray(response.result.data) && response.result.data.length > 0) this.nativeExecutionObserved = true;
-		pending.resolve(response.result);
+	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);
-		const timeoutMs = resolveDynamicToolServerRequestTimeoutMs(readCodexDynamicToolCallParams(request.params));
-		const timeoutResponse = timeoutServerRequestResponse(timeoutMs);
-		let timeout;
-		try {
-			return await Promise.race([this.runServerRequestHandlersWithoutTimeout(request, controller.signal), new Promise((resolve) => {
-				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"));
-					resolve(timeoutResponse);
-				}, timeoutMs);
-				timeout.unref?.();
-			})]);
-		} finally {
-			if (timeout) clearTimeout(timeout);
-		}
-	}
-	async runServerRequestHandlersWithoutTimeout(request, signal) {
-		for (const handler of this.requestHandlers) {
-			if (signal.aborted) return;
-			const result = await handler(request, signal);
-			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") {
@@ -3871,15 +4120,22 @@ var CodexAppServerClient = class CodexAppServerClient {
 	markClosed(error) {
 		if (this.closed) return false;
 		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;
 	}
 	rejectPendingRequests(error) {
 		for (const pending of this.pending.values()) {
 			pending.cleanup();
-			pending.reject(error);
+			pending.close(error);
 		}
 		this.pending.clear();
 		for (const handler of this.closeHandlers) try {
@@ -3889,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) {
@@ -3932,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.153.4") > 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
 	});
@@ -3958,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",
@@ -3996,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 };