@openclaw/codex 2026.9.3 → 2026.9.5

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

@@ -1,31 +1,62 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { l as resolveCodexAppServerUserHomeDir, o as isJsonObject } from "./protocol-CAAcVIKF.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 { r as CodexAppServerRpcError } from "./session-catalog-provenance-DkJHo735.js";
-import "./config-JDfTI4VI.js";
-import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-BWf6JLWG.js";
+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 { 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 { sanitizeTerminalText } from "openclaw/plugin-sdk/text-chunking";
+import { copyInternalToolResultState } 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";
+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);
 }
 //#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) {
+	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;
+	}
+	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;
+		}
+	}
+	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) {
@@ -153,7 +184,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;
@@ -227,7 +258,10 @@ 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 } } : {},
@@ -413,6 +447,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 +497,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 +2845,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);
@@ -3053,6 +3046,172 @@ 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();
+		}
+		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/transport-websocket.ts
 /**
 * Adapts a remote Codex app-server WebSocket endpoint to the shared stdio-like
@@ -3085,6 +3244,7 @@ function createWebSocketTransport(options) {
 	const stdinDecoder = new StringDecoder("utf8");
 	let pendingLine = "";
 	let killed = false;
+	let exitCode = null;
 	let pingTimeout;
 	let pongTimeout;
 	let expectedPong;
@@ -3160,6 +3320,7 @@ function createWebSocketTransport(options) {
 	socket.once("close", (code, reason) => {
 		clearConnectionHealthTimers();
 		killed = true;
+		exitCode = code;
 		events.emit("exit", code, reason.toString("utf8"));
 	});
 	socket.on("message", (data) => {
@@ -3196,12 +3357,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. */
@@ -3248,7 +3414,6 @@ 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;
@@ -3267,11 +3432,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";
@@ -3322,6 +3488,7 @@ var CodexAppServerClient = class CodexAppServerClient {
 	constructor(child) {
 		this.instanceId = randomUUID();
 		this.pending = /* @__PURE__ */ new Map();
+		this.catalogResponses = /* @__PURE__ */ new WeakMap();
 		this.requestHandlers = /* @__PURE__ */ new Set();
 		this.notificationHandlers = /* @__PURE__ */ new Set();
 		this.pendingStartupWarnings = [];
@@ -3333,13 +3500,16 @@ var CodexAppServerClient = class CodexAppServerClient {
 		this.transportExited = false;
 		this.nativeExecutionObserved = false;
 		this.stderrTail = "";
+		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)));
 		child.stdout.on("error", (error) => this.closeWithError(toStringifiedError(error)));
 		child.stderr.setEncoding("utf8");
-		child.stderr.on("data", (text) => {
+		child.stderr.on("data", (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}`);
@@ -3428,9 +3598,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() {
@@ -3439,12 +3610,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;
@@ -3457,19 +3629,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, {
@@ -3477,11 +3652,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 {
@@ -3491,17 +3672,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);
@@ -3511,8 +3692,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) => {
@@ -3523,7 +3704,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);
@@ -3533,9 +3714,9 @@ 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));
+		if (options.signal?.aborted) return Promise.reject(new CodexAppServerLocalRequestCancellationError(method, "aborted", false, options.signal?.reason));
 		const id = this.nextId++;
 		if (method === "account/login/start" || method === "account/logout" || method === "config/value/write" || method === "config/batchWrite") this.modelCatalogRevision += 1;
 		const message = {
@@ -3543,59 +3724,45 @@ var CodexAppServerClient = class CodexAppServerClient {
 			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 && method === "thread/list") 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) {
@@ -3685,6 +3852,25 @@ var CodexAppServerClient = class CodexAppServerClient {
 			}
 		});
 	}
+	/** Protect private loopback route capabilities before native diagnostics can mention them. */
+	protectPrivateTransportSecret(secret) {
+		if (!/^[A-Za-z0-9_-]{43}$/.test(secret) || this.privateTransportSecrets.size >= 8) {
+			if (!this.privateTransportSecrets.has(secret)) throw new Error("Invalid private Codex transport capability");
+		}
+		this.privateTransportSecrets.add(secret);
+	}
+	redactPrivateText(text) {
+		let redacted = text;
+		for (const secret of this.privateTransportSecrets) redacted = redacted.replaceAll(secret, "[REDACTED]");
+		return redacted;
+	}
+	redactPrivateStderr(chunk) {
+		const text = this.redactPrivateText(this.privateStderrPending + chunk);
+		let held = 0;
+		for (const secret of this.privateTransportSecrets) for (let length = 1; length < secret.length; length++) if (text.endsWith(secret.slice(0, length))) held = Math.max(held, length);
+		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) {
@@ -3756,15 +3942,7 @@ var CodexAppServerClient = class CodexAppServerClient {
 		});
 	}
 	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);
+		this.nativeExecutionObserved = dispatchCodexAppServerResponse(response, this.pending, this.catalogResponses, codexCatalogSourceForClient(this)) || this.nativeExecutionObserved;
 	}
 	async handleServerRequest(request) {
 		try {
@@ -3799,30 +3977,42 @@ var CodexAppServerClient = class CodexAppServerClient {
 	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 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), 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?.();
-			})]);
+			return await Promise.race([this.runServerRequestHandlersWithoutTimeout(request, controller.signal, setExecutionTimeoutMs), deadline.promise]);
 		} finally {
-			if (timeout) clearTimeout(timeout);
+			settled = true;
+			clearTimeout(timeout);
 		}
 	}
-	async runServerRequestHandlersWithoutTimeout(request, signal) {
+	async runServerRequestHandlersWithoutTimeout(request, signal, setExecutionTimeoutMs) {
 		for (const handler of this.requestHandlers) {
 			if (signal.aborted) return;
-			const result = await handler(request, signal);
+			const result = await handler(request, signal, setExecutionTimeoutMs);
 			if (result !== void 0) return result;
 		}
 	}
@@ -3849,6 +4039,7 @@ var CodexAppServerClient = class CodexAppServerClient {
 	markClosed(error) {
 		if (this.closed) return false;
 		this.closed = true;
+		closeCodexCatalogClientSource(this);
 		this.closeError = error;
 		this.lines.close();
 		this.rejectPendingRequests(error);
@@ -3857,7 +4048,7 @@ var CodexAppServerClient = class CodexAppServerClient {
 	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 {
@@ -3910,7 +4101,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.154.0") > 0) embeddedAgentLog.warn("codex app-server is newer than OpenClaw's managed runtime; continuing with normal startup validation", {
 		detectedVersion,
 		validatedVersion: CODEX_APP_SERVER_VERSION
 	});