@openclaw/codex 2026.9.4 → 2026.9.5

package/dist/{rate-limits-CBMmWBr9.js → .setup/rate-limits-DOEGYRNs.mjs}

@@ -1,5 +1,6 @@
-import { o as isJsonObject } from "./protocol-5bh1G-H7.js";
-import { asBoolean, asFiniteNumber, normalizeOptionalString, parseStrictFiniteNumber } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { m as isJsonObject } from "./config-security-BRQ2mgW9.mjs";
+import { normalizeOptionalString, parseStrictFiniteNumber } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { z } from "zod";
 import { MAX_DATE_TIMESTAMP_MS, resolveExpiresAtMsFromEpochSeconds } from "openclaw/plugin-sdk/number-runtime";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
 import { PROVIDER_LABELS, clampPercent } from "openclaw/plugin-sdk/provider-usage";
@@ -19,6 +20,49 @@ const WEEKLY_WINDOW_MINUTES = 7 * DAY_WINDOW_MINUTES;
 const WEEKLY_RESET_GAP_MS = 3 * ONE_DAY_MS;
 const CODEX_USAGE_LIMIT_MESSAGE_PREFIX = "You've reached your Codex subscription usage limit.";
 const CODEX_USAGE_LIMIT_STATE_MISMATCH_MESSAGE = "Codex rejected the request with a usage-limit error, but its current account usage does not report an exhausted limit.";
+const optionalNumber = z.number().optional().catch(void 0);
+const optionalBoolean = z.boolean().optional().catch(void 0);
+const rateLimitWindowSchema = z.object({
+	usedPercent: optionalNumber,
+	used_percent: optionalNumber,
+	resetsAt: optionalNumber,
+	resets_at: optionalNumber,
+	windowDurationMins: optionalNumber,
+	window_duration_mins: optionalNumber,
+	windowMinutes: optionalNumber,
+	window_minutes: optionalNumber
+}).transform((window) => {
+	const resetsAt = window.resetsAt ?? window.resets_at;
+	return {
+		usedPercent: window.usedPercent ?? window.used_percent,
+		resetsAt,
+		resetsAtMs: resolveExpiresAtMsFromEpochSeconds(resetsAt, { maxMs: MAX_DATE_TIMESTAMP_MS }) ?? 0,
+		windowDurationMins: window.windowDurationMins ?? window.window_duration_mins ?? window.windowMinutes ?? window.window_minutes
+	};
+}).optional().catch(void 0);
+const creditsSchema = z.object({
+	hasCredits: optionalBoolean,
+	has_credits: optionalBoolean,
+	unlimited: optionalBoolean,
+	balance: z.preprocess(parseStrictFiniteNumber, optionalNumber)
+}).transform((credits) => ({
+	hasCredits: credits.hasCredits ?? credits.has_credits,
+	unlimited: credits.unlimited,
+	balance: credits.balance
+})).optional().catch(void 0);
+const rateLimitSnapshotSchema = z.looseObject({
+	primary: rateLimitWindowSchema,
+	secondary: rateLimitWindowSchema,
+	credits: creditsSchema
+}).transform((snapshot) => ({
+	primary: snapshot.primary,
+	secondary: snapshot.secondary,
+	credits: snapshot.credits,
+	limitId: normalizeOptionalString(snapshot.limitId) ?? normalizeOptionalString(snapshot.limit_id),
+	limitName: normalizeOptionalString(snapshot.limitName) ?? normalizeOptionalString(snapshot.limit_name),
+	planType: normalizeOptionalString(snapshot.planType) ?? normalizeOptionalString(snapshot.plan_type),
+	rateLimitReachedType: normalizeOptionalString(snapshot.rateLimitReachedType) ?? normalizeOptionalString(snapshot.rate_limit_reached_type)
+}));
 /** Enriches Codex usage-limit failures with reset timing and recovery guidance. */
 function formatCodexUsageLimitErrorMessage(params) {
 	const message = normalizeOptionalString(params.message);
@@ -98,16 +142,39 @@ function summarizeCodexAccountUsage(value, nowMs = Date.now()) {
 	};
 }
 /** Converts Codex app-server rate-limit payloads into OpenAI/Codex usage windows. */
-function buildCodexAppServerUsageSnapshot(value) {
-	const snapshot = selectCodexProviderUsageSnapshot(value);
+function buildCodexAppServerUsageSnapshot(value, options = {}) {
+	const snapshots = collectCodexRateLimitSnapshots(value);
+	const snapshot = snapshots.find(isCodexLimitSnapshot) ?? snapshots[0];
 	const entries = snapshot ? readWindowEntries(snapshot) : [];
 	const windows = entries.map((entry) => readProviderUsageWindow(entry, entries)).filter((window) => Boolean(window));
-	return {
+	const result = {
 		provider: "openai",
 		displayName: PROVIDER_LABELS.openai,
 		windows,
 		...snapshot ? { plan: resolveCodexProviderUsagePlan(snapshot) } : {}
 	};
+	if (options.accountDetails && snapshot) {
+		result.plan = snapshot.planType;
+		for (const extra of snapshots) {
+			if (extra === snapshot) continue;
+			const extraEntries = readWindowEntries(extra);
+			for (const entry of extraEntries) {
+				const window = readProviderUsageWindow(entry, extraEntries);
+				if (window) windows.push({
+					...window,
+					groupLabel: formatLimitLabel(extra)
+				});
+			}
+		}
+		const credits = snapshot.credits;
+		const balance = credits?.balance;
+		if (balance !== void 0 && balance >= 0 && credits?.unlimited !== true) result.billing = [{
+			type: "balance",
+			amount: balance,
+			unit: "credits"
+		}];
+	}
+	return result;
 }
 function isCodexUsageLimitError(codexErrorInfo) {
 	if (codexErrorInfo === "usageLimitExceeded") return true;
@@ -117,7 +184,7 @@ function isCodexUsageLimitError(codexErrorInfo) {
 	return false;
 }
 function selectNextRateLimitReset(value, nowMs) {
-	const futureWindows = collectCodexRateLimitSnapshots(value).flatMap((snapshot) => LIMIT_WINDOW_KEYS.flatMap((key) => readRateLimitWindow(snapshot, key) ?? [])).filter((window) => window.resetsAtMs > nowMs);
+	const futureWindows = collectCodexRateLimitSnapshots(value).flatMap((snapshot) => LIMIT_WINDOW_KEYS.flatMap((key) => snapshot[key] ?? [])).filter((window) => window.resetsAtMs > nowMs);
 	if (futureWindows.length === 0) return;
 	const exhaustedWindows = futureWindows.filter((window) => window.usedPercent !== void 0 && window.usedPercent >= 100);
 	return (exhaustedWindows.length > 0 ? exhaustedWindows : futureWindows).toSorted((left, right) => left.resetsAtMs - right.resetsAtMs)[0];
@@ -130,10 +197,10 @@ function selectBlockingRateLimitReset(value, nowMs) {
 function summarizeRateLimitSnapshot(snapshot, nowMs) {
 	const label = formatLimitLabel(snapshot);
 	const windows = LIMIT_WINDOW_KEYS.flatMap((key) => {
-		const window = readRateLimitWindow(snapshot, key);
+		const window = snapshot[key];
 		return window ? [formatRateLimitWindow(key, window, nowMs)] : [];
 	});
-	const reachedType = normalizeOptionalString(snapshot.rateLimitReachedType) ?? normalizeOptionalString(snapshot.rate_limit_reached_type);
+	const reachedType = snapshot.rateLimitReachedType;
 	const suffix = reachedType ? ` (${formatReachedType(reachedType)})` : "";
 	if (windows.length > 0) return `${label}: ${windows.join(" · ")}${suffix}`;
 	if (reachedType) return `${label}: ${formatReachedType(reachedType)}`;
@@ -150,7 +217,7 @@ function collectRateLimitSnapshots(value, snapshots, seen) {
 	}
 	if (!isJsonObject(value)) return;
 	if (isRateLimitSnapshot(value)) {
-		addRateLimitSnapshot(value, snapshots, seen);
+		addRateLimitSnapshot(rateLimitSnapshotSchema.parse(value), snapshots, seen);
 		return;
 	}
 	const byLimitId = value.rateLimitsByLimitId;
@@ -171,8 +238,8 @@ function sortedRateLimitKeys(keys) {
 }
 function addRateLimitSnapshot(snapshot, snapshots, seen) {
 	const signature = [
-		normalizeOptionalString(snapshot.limitId) ?? normalizeOptionalString(snapshot.limit_id) ?? "",
-		normalizeOptionalString(snapshot.limitName) ?? normalizeOptionalString(snapshot.limit_name) ?? "",
+		snapshot.limitId ?? "",
+		snapshot.limitName ?? "",
 		formatWindowSignature(snapshot.primary),
 		formatWindowSignature(snapshot.secondary)
 	].join("|");
@@ -183,24 +250,8 @@ function addRateLimitSnapshot(snapshot, snapshots, seen) {
 function isRateLimitSnapshot(value) {
 	return isJsonObject(value.primary) || isJsonObject(value.secondary) || value.rateLimitReachedType !== void 0 || value.rate_limit_reached_type !== void 0 || value.limitId !== void 0 || value.limit_id !== void 0 || value.limitName !== void 0 || value.limit_name !== void 0;
 }
-function readRateLimitWindow(snapshot, key) {
-	const window = snapshot[key];
-	if (!isJsonObject(window)) return;
-	const resetsAt = asFiniteNumber(window.resetsAt) ?? asFiniteNumber(window.resets_at);
-	return {
-		resetsAtMs: resolveExpiresAtMsFromEpochSeconds(resetsAt, { maxMs: MAX_DATE_TIMESTAMP_MS }) ?? 0,
-		...readOptionalNumberField(window, "usedPercent", "used_percent"),
-		...readOptionalNumberField(window, "windowDurationMins", "window_duration_mins", "windowMinutes", "window_minutes")
-	};
-}
 function snapshotHasDisplayableData(snapshot) {
-	if (normalizeOptionalString(snapshot.rateLimitReachedType) ?? normalizeOptionalString(snapshot.rate_limit_reached_type)) return true;
-	return readWindowEntries(snapshot).some((entry) => entry.window.usedPercent !== void 0 || entry.window.resetsAtMs > 0);
-}
-function readOptionalNumberField(record, ...keys) {
-	const value = keys.map((key) => asFiniteNumber(record[key])).find((entry) => entry !== void 0);
-	if (value === void 0) return {};
-	return keys.some((key) => key.toLowerCase().includes("window")) ? { windowDurationMins: value } : { usedPercent: value };
+	return Boolean(snapshot.rateLimitReachedType) || readWindowEntries(snapshot).some((entry) => entry.window.usedPercent !== void 0 || entry.window.resetsAtMs > 0);
 }
 function formatRateLimitWindow(key, window, nowMs) {
 	return `${key} ${formatRateLimitWindowDetails(window, nowMs)}`;
@@ -209,7 +260,7 @@ function formatRateLimitWindowDetails(window, nowMs) {
 	return `${window.usedPercent === void 0 ? "usage unknown" : `${Math.max(0, 100 - Math.round(window.usedPercent))}% left`}${window.resetsAtMs > nowMs ? ` ⏱${formatResetDuration(window.resetsAtMs, nowMs)}` : ""}`;
 }
 function formatLimitLabel(snapshot) {
-	const label = normalizeOptionalString(snapshot.limitName) ?? normalizeOptionalString(snapshot.limit_name) ?? normalizeOptionalString(snapshot.limitId) ?? normalizeOptionalString(snapshot.limit_id);
+	const label = snapshot.limitName ?? snapshot.limitId;
 	if (!label || label === CODEX_LIMIT_ID) return "Codex";
 	return label.replace(/[_-]+/gu, " ").replace(/\s+/gu, " ").trim();
 }
@@ -223,15 +274,10 @@ function formatAccountResetTime(resetsAtMs, nowMs) {
 	return `${formatCalendarResetTime(resetsAtMs, nowMs)} (in ${formatRelativeDuration(resetsAtMs - nowMs)})`;
 }
 function snapshotHasLimitBlock(snapshot) {
-	return Boolean(normalizeOptionalString(snapshot.rateLimitReachedType) ?? normalizeOptionalString(snapshot.rate_limit_reached_type) ?? readWindowEntries(snapshot).some((entry) => entry.window.usedPercent !== void 0 && entry.window.usedPercent >= 100));
+	return Boolean(snapshot.rateLimitReachedType ?? readWindowEntries(snapshot).some((entry) => entry.window.usedPercent !== void 0 && entry.window.usedPercent >= 100));
 }
 function isCodexLimitSnapshot(snapshot) {
-	const id = normalizeOptionalString(snapshot.limitId) ?? normalizeOptionalString(snapshot.limit_id);
-	return !id || id === CODEX_LIMIT_ID;
-}
-function selectCodexProviderUsageSnapshot(value) {
-	const snapshots = collectCodexRateLimitSnapshots(value);
-	return snapshots.find(isCodexLimitSnapshot) ?? snapshots[0];
+	return !snapshot.limitId || snapshot.limitId === CODEX_LIMIT_ID;
 }
 function readProviderUsageWindow(entry, entries) {
 	const { window } = entry;
@@ -252,16 +298,15 @@ function formatProviderUsageWindowLabel(entry, entries) {
 	return entry.key === "primary" ? "Short" : "Long";
 }
 function resolveCodexProviderUsagePlan(snapshot) {
-	const plan = normalizeOptionalString(snapshot.planType) ?? normalizeOptionalString(snapshot.plan_type);
-	const creditSummary = formatCodexCreditSummary(isJsonObject(snapshot.credits) ? snapshot.credits : void 0);
+	const plan = snapshot.planType;
+	const creditSummary = formatCodexCreditSummary(snapshot.credits);
 	if (!creditSummary) return plan;
 	return plan ? `${plan} (${creditSummary})` : creditSummary;
 }
 function formatCodexCreditSummary(credits) {
-	if (!credits) return;
-	if ((asBoolean(credits.hasCredits) ?? asBoolean(credits.has_credits)) === false) return;
-	if (asBoolean(credits.unlimited)) return "Unlimited credits";
-	const balance = typeof credits.balance === "string" ? parseStrictFiniteNumber(credits.balance) : asFiniteNumber(credits.balance);
+	if (!credits || credits.hasCredits === false) return;
+	if (credits.unlimited) return "Unlimited credits";
+	const balance = credits.balance;
 	if (balance === void 0 || balance <= 0) return;
 	const roundedBalance = Math.round(balance);
 	return roundedBalance > 0 ? `${roundedBalance} credits` : void 0;
@@ -285,7 +330,7 @@ function selectBlockingWindowEntry(entries, nowMs) {
 }
 function readWindowEntries(snapshot) {
 	return LIMIT_WINDOW_KEYS.flatMap((key) => {
-		const window = readRateLimitWindow(snapshot, key);
+		const window = snapshot[key];
 		return window ? [{
 			key,
 			window
@@ -370,9 +415,8 @@ function formatResetDuration(resetsAtMs, nowMs) {
 	if (minutes > 0) return seconds > 0 ? `${minutes}m ${seconds}s` : `${minutes}m`;
 	return `${seconds}s`;
 }
-function formatWindowSignature(value) {
-	if (!isJsonObject(value)) return "";
-	return `${asFiniteNumber(value.usedPercent) ?? asFiniteNumber(value.used_percent) ?? ""}:${asFiniteNumber(value.resetsAt) ?? asFiniteNumber(value.resets_at) ?? ""}`;
+function formatWindowSignature(window) {
+	return window ? `${window.usedPercent ?? ""}:${window.resetsAt ?? ""}` : "";
 }
 function extractCodexRetryHint(message) {
 	if (!message) return;

package/dist/{request-B7hEkBGq.js → .setup/request-BioXJLYa.mjs}

@@ -1,5 +1,5 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { n as withTimeout, t as withAbortableTimeout } from "./timeout-BVw8aaM1.js";
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
+import { i as CodexAppServerRpcError, n as withTimeout, t as withAbortableTimeout } from "./timeout-DZF05XrR.mjs";
 //#region extensions/codex/src/app-server/request.ts
 var request_exports = /* @__PURE__ */ __exportAll({
 	CodexAppServerScopedRequestRejectedError: () => CodexAppServerScopedRequestRejectedError,
@@ -8,26 +8,56 @@ var request_exports = /* @__PURE__ */ __exportAll({
 	requestCodexAppServerJson: () => requestCodexAppServerJson,
 	withCodexAppServerJsonClient: () => withCodexAppServerJsonClient
 });
+function observeControlPhase(observation, phase) {
+	try {
+		observation?.phase(phase);
+	} catch {}
+}
+function observeControlFailure(observation, phase, error, deadlineObserved = false) {
+	if (!observation) return;
+	try {
+		const category = deadlineObserved ? "deadline-observed" : error instanceof CodexAppServerScopedRequestRejectedError ? "scoped-rejection" : error instanceof CodexAppServerRpcError ? error.code === -32601 ? "rpc-method-unavailable" : "rpc-error" : "other";
+		observation.failed({
+			phase,
+			category
+		});
+	} catch {}
+}
 /** Sends one guarded request over a client lease owned by the caller. */
 async function requestCodexAppServerClientJson(params) {
-	const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-BxgyoM8M.js").then((n) => n.r);
-	const sandboxBlock = resolveCodexAppServerDirectSandboxBypassBlock({
-		method: params.method,
-		requestParams: params.requestParams,
-		config: params.config,
-		sessionKey: params.sessionKey,
-		sessionId: params.sessionId
-	});
-	if (sandboxBlock) throw new Error(sandboxBlock);
-	const timeoutMs = params.timeoutMs ?? 6e4;
-	return await withTimeout(params.client.request(params.method, params.requestParams, {
-		timeoutMs,
-		signal: params.signal,
-		...params.assertCurrent ? { assertCurrent: () => assertRequestOwnerCurrent(params.assertCurrent) } : {}
-	}), timeoutMs, `codex app-server ${params.method} timed out`);
+	let phase = "prepare";
+	observeControlPhase(params.controlObservation, phase);
+	try {
+		const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-BBP-RbTf.mjs").then((n) => n.r);
+		const sandboxBlock = resolveCodexAppServerDirectSandboxBypassBlock({
+			method: params.method,
+			requestParams: params.requestParams,
+			config: params.config,
+			sessionKey: params.sessionKey,
+			sessionId: params.sessionId
+		});
+		if (sandboxBlock) throw new Error(sandboxBlock);
+		const timeoutMs = params.timeoutMs ?? 6e4;
+		const method = params.method;
+		const requestParams = params.requestParams;
+		const attemptWaiterFinished = method === "thread/list" ? params.controlObservation?.attemptWaiterFinished : void 0;
+		const options = {
+			timeoutMs,
+			signal: params.signal,
+			...attemptWaiterFinished ? { attemptWaiterFinished } : {},
+			...params.assertCurrent ? { assertCurrent: () => assertRequestOwnerCurrent(params.assertCurrent) } : {}
+		};
+		phase = "client-request";
+		observeControlPhase(params.controlObservation, phase);
+		return await withTimeout(params.client.request(method, requestParams, options), timeoutMs, `codex app-server ${params.method} timed out`);
+	} catch (error) {
+		observeControlFailure(params.controlObservation, phase, error);
+		throw error;
+	}
 }
 async function requestCodexAppServerJson(params) {
-	const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-BxgyoM8M.js").then((n) => n.r);
+	observeControlPhase(params.controlObservation, "prepare");
+	const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-BBP-RbTf.mjs").then((n) => n.r);
 	const sandboxBlock = resolveCodexAppServerDirectSandboxBypassBlock({
 		method: params.method,
 		requestParams: params.requestParams,
@@ -66,7 +96,7 @@ const CODEX_ACCOUNT_READ_MAX_TIMEOUT_MS = 4e3;
 const CODEX_USAGE_DEADLINE_RESERVE_MS = CODEX_USAGE_ISOLATED_SHUTDOWN.forceKillDelayMs + CODEX_USAGE_ISOLATED_SHUTDOWN.exitTimeoutMs + 250;
 /** Reads rate limits and best-effort account identity from one isolated app-server session. */
 async function readCodexAppServerUsage(options) {
-	const deadline = Date.now() + options.timeoutMs;
+	const deadline = performance.now() + options.timeoutMs;
 	return await withCodexAppServerJsonClient({
 		timeoutMs: options.timeoutMs,
 		timeoutMessage: "codex app-server usage read timed out",
@@ -74,6 +104,9 @@ async function readCodexAppServerUsage(options) {
 		...options.authProfileId ? { authProfileId: options.authProfileId } : {},
 		config: options.config,
 		startOptions: options.startOptions,
+		preparedAuth: options.preparedAuth,
+		authRequirement: options.authRequirement,
+		assertCurrent: options.assertCurrent,
 		isolated: true,
 		isolatedShutdown: CODEX_USAGE_ISOLATED_SHUTDOWN
 	}, async (request) => {
@@ -93,7 +126,7 @@ function extractCodexAccountEmail(value) {
 	return typeof email === "string" && email.trim() ? email.trim() : void 0;
 }
 async function readCodexAccountEmailBestEffort(request, deadline) {
-	const boundMs = Math.min(CODEX_ACCOUNT_READ_MAX_TIMEOUT_MS, deadline - Date.now() - CODEX_USAGE_DEADLINE_RESERVE_MS);
+	const boundMs = Math.min(CODEX_ACCOUNT_READ_MAX_TIMEOUT_MS, deadline - performance.now() - CODEX_USAGE_DEADLINE_RESERVE_MS);
 	if (boundMs <= 0) return;
 	const read = request({
 		method: "account/read",
@@ -118,16 +151,19 @@ async function readCodexAccountEmailBestEffort(request, deadline) {
 async function withCodexAppServerJsonClient(params, run) {
 	const timeoutMs = params.timeoutMs ?? 6e4;
 	const timeoutMessage = params.timeoutMessage ?? "codex app-server request timed out";
+	let activePhase = "prepare";
+	let errorPhase;
+	observeControlPhase(params.controlObservation, activePhase);
 	const timeoutController = new AbortController();
-	const deadline = Number.isFinite(timeoutMs) && timeoutMs > 0 ? Date.now() + timeoutMs : void 0;
-	const isPastDeadline = () => deadline !== void 0 && Date.now() >= deadline;
+	const deadline = Number.isFinite(timeoutMs) && timeoutMs > 0 ? performance.now() + timeoutMs : void 0;
+	const isPastDeadline = () => deadline !== void 0 && performance.now() >= deadline;
 	const throwIfAbandoned = () => {
 		if (timeoutController.signal.aborted && timeoutController.signal.reason instanceof Error) throw timeoutController.signal.reason;
 		if (timeoutController.signal.aborted || isPastDeadline()) throw new CodexAppServerScopedRequestRejectedError(timeoutMessage);
 	};
 	const remainingTimeoutMs = () => {
 		throwIfAbandoned();
-		return deadline === void 0 ? timeoutMs : Math.max(1, deadline - Date.now());
+		return deadline === void 0 ? timeoutMs : Math.max(1, deadline - performance.now());
 	};
 	try {
 		return await withAbortableTimeout({
@@ -135,11 +171,15 @@ async function withCodexAppServerJsonClient(params, run) {
 			timeoutMs,
 			timeoutMessage,
 			promise: (async () => {
-				const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-BxgyoM8M.js").then((n) => n.r);
-				const { createIsolatedCodexAppServerClient, getLeasedSharedCodexAppServerClient, isCodexAppServerStartSelectionChangedError, releaseLeasedSharedCodexAppServerClient, retireSharedCodexAppServerClientIfCurrent } = await import("./shared-client-CscigXXL.js").then((n) => n.y);
+				const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-BBP-RbTf.mjs").then((n) => n.r);
+				const { createIsolatedCodexAppServerClient, getLeasedSharedCodexAppServerClient, isCodexAppServerStartSelectionChangedError, releaseLeasedSharedCodexAppServerClient, retireSharedCodexAppServerClientIfCurrent } = await import("./shared-client-BpTtuLQ5.mjs").then((n) => n.y);
 				for (let attempt = 0; attempt < 2; attempt += 1) {
+					errorPhase = void 0;
+					activePhase = "prepare";
+					observeControlPhase(params.controlObservation, activePhase);
 					throwIfAbandoned();
-					const client = await (params.isolated ? createIsolatedCodexAppServerClient : getLeasedSharedCodexAppServerClient)({
+					const acquireClient = params.isolated ? createIsolatedCodexAppServerClient : getLeasedSharedCodexAppServerClient;
+					const acquireOptions = {
 						startOptions: params.startOptions,
 						pluginConfig: params.pluginConfig,
 						timeoutMs: remainingTimeoutMs(),
@@ -150,8 +190,12 @@ async function withCodexAppServerJsonClient(params, run) {
 						authRequirement: params.authRequirement,
 						agentDir: params.agentDir,
 						config: params.config,
-						abandonSignal: timeoutController.signal
-					});
+						abandonSignal: timeoutController.signal,
+						assertCurrent: params.assertCurrent
+					};
+					activePhase = "acquire-client";
+					observeControlPhase(params.controlObservation, activePhase);
+					const client = await acquireClient(acquireOptions);
 					let scopeActive = true;
 					const assertCurrent = () => {
 						throwIfAbandoned();
@@ -159,8 +203,12 @@ async function withCodexAppServerJsonClient(params, run) {
 						assertRequestOwnerCurrent(params.assertCurrent);
 					};
 					try {
+						activePhase = "prepare";
+						observeControlPhase(params.controlObservation, activePhase);
 						assertCurrent();
 						const scopedRequest = async (request) => {
+							activePhase = "prepare";
+							observeControlPhase(params.controlObservation, activePhase);
 							const sandboxBlock = resolveCodexAppServerDirectSandboxBypassBlock({
 								method: request.method,
 								requestParams: request.requestParams,
@@ -170,14 +218,26 @@ async function withCodexAppServerJsonClient(params, run) {
 							});
 							if (sandboxBlock) throw new CodexAppServerScopedRequestRejectedError(sandboxBlock);
 							assertCurrent();
-							return await client.request(request.method, request.requestParams, {
+							const method = request.method;
+							const requestParams = request.requestParams;
+							const attemptWaiterFinished = method === "thread/list" ? params.controlObservation?.attemptWaiterFinished : void 0;
+							const requestOptions = {
 								timeoutMs: remainingTimeoutMs(),
 								signal: timeoutController.signal,
+								...attemptWaiterFinished ? { attemptWaiterFinished } : {},
+								...params.catalogPreview && method === "thread/list" ? {
+									catalogPreview: true,
+									catalogPreviewCache: params.catalogPreviewCache,
+									catalogRows: params.catalogRows
+								} : {},
 								assertCurrent: () => {
 									assertCurrent();
 									request.assertCurrent?.();
 								}
-							});
+							};
+							activePhase = "client-request";
+							observeControlPhase(params.controlObservation, activePhase);
+							return await client.request(method, requestParams, requestOptions);
 						};
 						return await run(scopedRequest, client, {
 							assertCurrent,
@@ -186,23 +246,43 @@ async function withCodexAppServerJsonClient(params, run) {
 							}
 						});
 					} catch (error) {
+						errorPhase = activePhase;
 						if (!isCodexAppServerStartSelectionChangedError(error) || attempt > 0) throw error;
-						if (!params.isolated) retireSharedCodexAppServerClientIfCurrent(client);
-						throwIfAbandoned();
+						errorPhase = void 0;
+						try {
+							if (!params.isolated) {
+								activePhase = "release-client";
+								observeControlPhase(params.controlObservation, activePhase);
+								retireSharedCodexAppServerClientIfCurrent(client);
+							}
+							activePhase = "prepare";
+							observeControlPhase(params.controlObservation, activePhase);
+							throwIfAbandoned();
+						} catch (retryError) {
+							errorPhase = activePhase;
+							throw retryError;
+						}
 					} finally {
 						scopeActive = false;
+						activePhase = "release-client";
+						observeControlPhase(params.controlObservation, activePhase);
+						const requestErrorPhase = errorPhase;
+						errorPhase = activePhase;
 						if (params.isolated) await client.closeAndWait({
 							exitTimeoutMs: params.isolatedShutdown?.exitTimeoutMs ?? 2e3,
 							forceKillDelayMs: params.isolatedShutdown?.forceKillDelayMs ?? 250
 						});
 						else releaseLeasedSharedCodexAppServerClient(client);
+						errorPhase = requestErrorPhase;
 					}
 				}
 				throw new Error("Codex app-server selection retry loop exited unexpectedly");
 			})()
 		});
 	} catch (error) {
-		if (isPastDeadline()) throw new Error(timeoutMessage, { cause: error });
+		const deadlineObserved = isPastDeadline();
+		observeControlFailure(params.controlObservation, deadlineObserved ? activePhase : errorPhase ?? activePhase, error, deadlineObserved);
+		if (deadlineObserved) throw new Error(timeoutMessage, { cause: error });
 		throw error;
 	} finally {
 		timeoutController.abort(new CodexAppServerScopedRequestRejectedError(timeoutMessage));

package/dist/.setup/run-attempt-lifecycle-B7JbY4-F.mjs

@@ -0,0 +1,71 @@
+import { t as attemptTerminal } from "./attempt-terminal-gZrxQ35N.mjs";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { awaitAgentEndSideEffects, embeddedAgentLog, emitAgentEvent, runAgentEndSideEffects } from "openclaw/plugin-sdk/agent-harness-runtime";
+//#region extensions/codex/src/app-server/workspace-dir-cache.ts
+/** Process-local cache of Codex workspaces already created by the run loop. */
+const codexWorkspaceDirCache = /* @__PURE__ */ new Set();
+//#endregion
+//#region extensions/codex/src/app-server/run-attempt-lifecycle.ts
+const CODEX_APP_SERVER_PROJECTED_CHARS_PER_TOKEN = 4;
+function shouldKeepCodexSharedAbortOpen(params) {
+	const terminal = attemptTerminal.project(params.result.terminal);
+	if (params.explicitCancellationObserved || terminal.aborted || terminal.externalAbort) return false;
+	return params.trigger === "memory" || !params.attemptSucceeded;
+}
+function withCodexAppServerFastModeServiceTier(appServer, params) {
+	const fastMode = typeof params.fastMode === "function" ? params.fastMode() : params.fastMode;
+	const serviceTier = fastMode === void 0 ? appServer.serviceTier : fastMode ? "priority" : void 0;
+	if (serviceTier === appServer.serviceTier) return appServer;
+	if (serviceTier) return {
+		...appServer,
+		serviceTier
+	};
+	return {
+		...appServer,
+		serviceTier: null
+	};
+}
+function estimateCodexAppServerProjectedTurnTokens(params) {
+	const inputChars = params.prompt.length + (params.developerInstructions?.length ?? 0);
+	return Math.max(1, Math.ceil(inputChars / CODEX_APP_SERVER_PROJECTED_CHARS_PER_TOKEN));
+}
+async function ensureCodexWorkspaceDirOnce(workspaceDir) {
+	const normalized = path.resolve(workspaceDir);
+	if (codexWorkspaceDirCache.has(normalized)) return;
+	await fs.mkdir(normalized, { recursive: true });
+	codexWorkspaceDirCache.add(normalized);
+}
+async function emitCodexAppServerEvent(params, event) {
+	try {
+		emitAgentEvent({
+			runId: params.runId,
+			stream: event.stream,
+			data: event.data,
+			...params.sessionKey ? { sessionKey: params.sessionKey } : {}
+		});
+	} catch (error) {
+		embeddedAgentLog.debug("codex app-server global agent event emit failed", { error });
+	}
+	try {
+		await params.onAgentEvent?.(event);
+	} catch (error) {
+		embeddedAgentLog.debug("codex app-server agent event handler threw", { error });
+	}
+}
+async function runCodexAgentEndHook(params, hookParams) {
+	const sideEffectParams = {
+		...hookParams,
+		ctx: {
+			...hookParams.ctx,
+			config: params.config
+		}
+	};
+	if (!params.messageChannel && !params.messageProvider) {
+		await awaitAgentEndSideEffects(sideEffectParams);
+		return;
+	}
+	runAgentEndSideEffects(sideEffectParams);
+}
+//#endregion
+export { shouldKeepCodexSharedAbortOpen as a, runCodexAgentEndHook as i, ensureCodexWorkspaceDirOnce as n, withCodexAppServerFastModeServiceTier as o, estimateCodexAppServerProjectedTurnTokens as r, emitCodexAppServerEvent as t };