@openclaw/codex 2026.7.2-beta.7 → 2026.8.1-beta.3

package/dist/binding-connection-DAvZwp96.js

@@ -0,0 +1,45 @@
+import { h as readCodexPluginConfig, i as resolveCodexAppServerRuntimeOptions, s as resolveCodexSupervisionAppServerRuntimeOptions } from "./config-CpNeo5AE.js";
+import { a as resolveCodexCatalogConnectionHome, t as buildCodexAppServerConnectionFingerprint } from "./plugin-app-cache-key-DMNQ8Zi8.js";
+//#region extensions/codex/src/app-server/binding-connection.ts
+/** Requires the native model pair after a supervised pending branch has materialized. */
+function requireCodexSupervisionModelSelection(binding) {
+	const model = binding.model?.trim();
+	const modelProvider = binding.modelProvider?.trim();
+	if (binding.connectionScope !== "supervision" || !model || !modelProvider) throw new Error("Codex supervised binding is missing its native model and provider; refusing request selection");
+	return {
+		model,
+		modelProvider
+	};
+}
+/** Resolves connection and auth ownership exclusively from the private thread binding. */
+function resolveCodexBindingAppServerConnection(params) {
+	const { binding, authProfileId, ...runtimeParams } = params;
+	const usesSupervisionConnection = binding?.connectionScope === "supervision";
+	if (usesSupervisionConnection && readCodexPluginConfig(runtimeParams.pluginConfig).supervision?.enabled !== true) throw new Error("Codex supervision is disabled; refusing to open a native user-home supervised session");
+	let appServer = (usesSupervisionConnection ? resolveCodexSupervisionAppServerRuntimeOptions : resolveCodexAppServerRuntimeOptions)(runtimeParams);
+	if (usesSupervisionConnection) {
+		const persistedFingerprint = binding.pendingSupervisionBranch?.connectionFingerprint ?? binding.appServerRuntimeFingerprint;
+		const catalogHome = persistedFingerprint ? resolveCodexCatalogConnectionHome(persistedFingerprint, runtimeParams.agentDir) : void 0;
+		if (catalogHome) appServer = {
+			...appServer,
+			start: {
+				...appServer.start,
+				homeScope: "user",
+				env: {
+					...appServer.start.env,
+					CODEX_HOME: catalogHome
+				}
+			}
+		};
+		const currentFingerprint = buildCodexAppServerConnectionFingerprint(appServer, runtimeParams.agentDir);
+		if (!persistedFingerprint || persistedFingerprint !== currentFingerprint) throw new Error("Codex supervision connection changed; refusing to operate on its bound native thread");
+	}
+	return {
+		appServer,
+		usesSupervisionConnection,
+		requestAuthProfileId: usesSupervisionConnection ? void 0 : authProfileId,
+		clientAuthProfileId: usesSupervisionConnection ? null : authProfileId
+	};
+}
+//#endregion
+export { resolveCodexBindingAppServerConnection as n, requireCodexSupervisionModelSelection as t };

package/dist/{bounded-turn-D2ZAgZVz.js → bounded-turn-4BjrZEwW.js}

@@ -1,23 +1,22 @@
-import { W as isJsonObject, s as isCodexAppServerStartSelectionChangedError } from "./shared-client-DTbvH-XV.js";
-import { g as resolveCodexAppServerRuntimeOptions } from "./session-binding-BXpo9ymA.js";
-import { G as mergeCodexThreadConfigs, d as attestCodexRingZeroThreadHasNoMcpServers, f as buildCodexRingZeroThreadConfigPatch, m as readCodexInheritedMcpServerNames, mt as interruptCodexTurnAndWaitBestEffort, p as buildCodexRuntimeThreadConfig, u as assertCodexRingZeroHasNoManagedHooks, ut as CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS } from "./thread-lifecycle-DF53ogiA.js";
-import { _ as readCodexNotificationItem, h as isRetryableErrorNotification } from "./attempt-notifications-AP-a-Q5k.js";
-import { n as normalizeCodexResponseTokenUsage } from "./event-projector-usage-Xp4AlR2k.js";
-import { C as readCodexTurnCompletedNotification, _ as assertCodexThreadStartResponse, b as readCodexErrorNotification, v as assertCodexTurnStartResponse } from "./transcript-mirror-DzsdNCf5.js";
-import { r as readModelListResult } from "./models-BBMKU4jA.js";
+import { i as resolveCodexAppServerRuntimeOptions } from "./config-CpNeo5AE.js";
+import { V as createCodexElicitationResponse, s as isCodexAppServerStartSelectionChangedError, ut as isJsonObject } from "./shared-client-Dw-rzii0.js";
+import { _ as readCodexNotificationTurnId, a as closeCodexStartupClientBestEffort, o as interruptCodexTurnAndWaitBestEffort, t as CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS } from "./attempt-client-cleanup-URjUlCHg.js";
+import { b as isTerminalTurnStatus, n as normalizeCodexResponseTokenUsage, x as readCodexNotificationItem, y as isRetryableErrorNotification } from "./event-projector-usage-CLwNEJqW.js";
+import { a as assertCodexThreadStartResponse, c as readCodexErrorNotification, o as assertCodexTurnStartResponse, u as readCodexTurnCompletedNotification } from "./protocol-validators-VAVyEnDp.js";
+import { r as readModelListResult } from "./models-CZw1wClT.js";
+import { Z as mergeCodexThreadConfigs, c as buildCodexRingZeroThreadConfigPatch, l as buildCodexRuntimeThreadConfig, o as assertCodexManagedRequirementsDoNotOverrideToolPolicy, s as attestCodexRestrictedToolSurfaceMcpServersDisabled, u as readCodexInheritedMcpServerNames } from "./thread-lifecycle-DKdrnTMX.js";
+import { readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
 import fs from "node:fs/promises";
 import path from "node:path";
+import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
 import { resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
 import { resolvePreferredOpenClawTmpDir, withTempWorkspace } from "openclaw/plugin-sdk/temp-path";
 //#region extensions/codex/src/app-server/bounded-turn.ts
-const CODEX_PRIVATE_STDIO_ARGS = [
-	"app-server",
-	"--listen",
-	"stdio://"
-];
 const CODEX_APP_SERVER_ARGS_ENV_KEY = "OPENCLAW_CODEX_APP_SERVER_ARGS";
 const CODEX_BOUNDED_THREAD_CONFIG = {
+	"agents.enabled": false,
 	"features.multi_agent": false,
+	"features.multi_agent_v2": false,
 	"features.apps": false,
 	"features.plugins": false,
 	"features.image_generation": false,
@@ -66,19 +65,26 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 	const timeoutMs = deadline - Date.now();
 	if (timeoutMs <= 0) throw timeoutError;
 	const agentDir = params.agentDir?.trim() || void 0;
-	const startOptions = workspace.codexHome ? buildPrivateCodexAppServerStartOptions(appServer.start, workspace.codexHome) : appServer.start;
+	const isolatedStartOptions = workspace.codexHome ? buildPrivateCodexAppServerStartOptions(appServer.start, workspace.codexHome) : appServer.start;
+	const startOptions = workspace.codexHome && params.preparedAuth ? {
+		...isolatedStartOptions,
+		homeScope: "agent"
+	} : isolatedStartOptions;
 	const ownsClient = !params.options.clientFactory;
+	const authSelection = params.preparedAuth ? { preparedAuth: params.preparedAuth } : { authProfileId: params.profile };
 	const client = params.options.clientFactory ? await params.options.clientFactory({
 		startOptions,
-		authProfileId: params.profile,
+		...authSelection,
+		authRequirement: params.authRequirement,
 		agentDir,
 		config: params.config,
 		timeoutMs,
 		...params.signal ? { abandonSignal: params.signal } : {}
-	}) : await import("./shared-client-DTbvH-XV.js").then((n) => n.m).then(({ createIsolatedCodexAppServerClient }) => createIsolatedCodexAppServerClient({
+	}) : await import("./shared-client-Dw-rzii0.js").then((n) => n.m).then(({ createIsolatedCodexAppServerClient }) => createIsolatedCodexAppServerClient({
 		startOptions,
 		timeoutMs,
-		authProfileId: params.profile,
+		...authSelection,
+		authRequirement: params.authRequirement,
 		agentDir,
 		authProfileStore: params.authProfileStore,
 		config: params.config,
@@ -109,7 +115,7 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 	timeout.unref?.();
 	let retrySelection = false;
 	try {
-		const model = await resolveCodexBoundedTurnModel({
+		const modelSelection = await resolveCodexBoundedTurnModel({
 			client,
 			selection: params.model,
 			requiredModalities: params.requiredModalities,
@@ -117,17 +123,18 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 			signal: abortController.signal
 		});
 		const inheritedMcpServerNames = params.requireNoExternalCapabilities ? await readCodexInheritedMcpServerNames(client, workspace.cwd, abortController.signal) : [];
-		if (params.requireNoExternalCapabilities) await assertCodexRingZeroHasNoManagedHooks(client, abortController.signal);
+		if (params.requireNoExternalCapabilities) await assertCodexManagedRequirementsDoNotOverrideToolPolicy(client, { restrictedToolSurface: true }, abortController.signal);
+		const threadConfig = buildCodexRuntimeThreadConfig(resolveBoundedThreadConfig(params, workspace, inheritedMcpServerNames), { nativeCodeModeEnabled: false });
 		const thread = assertCodexThreadStartResponse(await client.request("thread/start", {
-			model,
-			modelProvider: "openai",
+			model: modelSelection.runtimeModelId,
+			...params.modelProvider ? { modelProvider: params.modelProvider } : {},
 			cwd: workspace.cwd,
 			approvalPolicy: "on-request",
 			sandbox: "read-only",
 			serviceName: "OpenClaw",
 			...params.requireNoExternalCapabilities ? { baseInstructions: "" } : {},
 			developerInstructions: params.developerInstructions,
-			config: buildCodexRuntimeThreadConfig(resolveBoundedThreadConfig(params, workspace, inheritedMcpServerNames), { nativeCodeModeEnabled: false }),
+			config: threadConfig,
 			environments: [],
 			dynamicTools: [],
 			experimentalRawEvents: true,
@@ -138,7 +145,7 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 		}));
 		activeThreadId = thread.thread.id;
 		if (abortController.signal.aborted) requestInterrupt();
-		if (params.requireNoExternalCapabilities) await attestCodexRingZeroThreadHasNoMcpServers(client, thread.thread.id, abortController.signal);
+		if (params.requireNoExternalCapabilities) await attestCodexRestrictedToolSurfaceMcpServersDisabled(client, thread.thread.id, threadConfig, abortController.signal);
 		if (params.historyItems?.length) await client.request("thread/inject_items", {
 			threadId: thread.thread.id,
 			items: params.historyItems
@@ -146,16 +153,15 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 			timeoutMs,
 			signal: abortController.signal
 		});
-		const collector = createCodexBoundedTurnCollector(thread.thread.id, params.taskLabel);
+		const collector = createCodexBoundedTurnCollector(thread.thread.id, params.taskLabel, params.allowEmptyText === true);
 		const cleanup = client.addNotificationHandler(collector.handleNotification);
 		const requestCleanup = client.addRequestHandler(createCodexBoundedApprovalHandler(params.taskLabel));
 		try {
 			const turn = assertCodexTurnStartResponse(await client.request("turn/start", {
 				threadId: thread.thread.id,
 				input: params.input,
-				cwd: workspace.cwd,
 				approvalPolicy: "on-request",
-				model,
+				model: modelSelection.runtimeModelId,
 				effort: "low"
 			}, {
 				timeoutMs,
@@ -168,9 +174,10 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 					signal: abortController.signal,
 					timeoutError
 				}),
-				model
+				model: modelSelection.catalogId
 			};
 		} finally {
+			await interruptPromise;
 			requestCleanup();
 			cleanup();
 		}
@@ -182,7 +189,7 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 		clearTimeout(timeout);
 		params.signal?.removeEventListener("abort", abortFromCaller);
 		await interruptPromise;
-		if (ownsClient) client.close();
+		if (ownsClient) await closeCodexStartupClientBestEffort(client);
 	}
 	if (retrySelection) return await runBoundedCodexAppServerTurnInWorkspace(params, appServer, workspace, selectionAttempt + 1, {
 		deadline,
@@ -197,6 +204,10 @@ function resolveBoundedThreadConfig(params, workspace, inheritedMcpServerNames)
 	return mergeCodexThreadConfigs(privateConfig, CODEX_SETTLED_FINALIZER_THREAD_CONFIG, buildCodexRingZeroThreadConfigPatch({ toolsAllow: ["openclaw"] }, true, inheritedMcpServerNames)) ?? privateConfig;
 }
 function buildPrivateCodexAppServerStartOptions(start, codexHome) {
+	const providerArgs = start.args.flatMap((arg, index) => {
+		const override = arg === "-c" || arg === "--config" ? start.args[index + 1] : arg.startsWith("--config=") ? arg.slice(9) : void 0;
+		return override && /^\s*(?:openai_base_url|model_catalog_json)\s*=/u.test(override) ? ["-c", override] : [];
+	});
 	const privateEnv = Object.fromEntries(Object.entries(start.env ?? {}).filter(([name]) => name.trim().toUpperCase() !== CODEX_APP_SERVER_ARGS_ENV_KEY));
 	const clearEnv = (start.clearEnv ?? []).filter((name) => {
 		const normalized = name.trim().toUpperCase();
@@ -204,7 +215,12 @@ function buildPrivateCodexAppServerStartOptions(start, codexHome) {
 	});
 	return {
 		...start,
-		args: [...CODEX_PRIVATE_STDIO_ARGS],
+		args: [
+			"app-server",
+			...providerArgs,
+			"--listen",
+			"stdio://"
+		],
 		env: {
 			...privateEnv,
 			CODEX_HOME: codexHome
@@ -226,7 +242,7 @@ function createCodexBoundedApprovalHandler(taskLabel) {
 			decision: "decline",
 			reason: `OpenClaw Codex ${taskLabel} does not grant native approvals.`
 		};
-		if (request.method === "mcpServer/elicitation/request") return { action: "decline" };
+		if (request.method === "mcpServer/elicitation/request") return createCodexElicitationResponse("decline", null, { message: `OpenClaw Codex ${taskLabel} does not support interactive input.` });
 	};
 }
 async function resolveCodexBoundedTurnModel(params) {
@@ -242,16 +258,22 @@ async function resolveCodexBoundedTurnModel(params) {
 		const supported = listed.filter((entry) => params.requiredModalities.every((modality) => entry.inputModalities.includes(modality)));
 		const selected = supported.find((entry) => entry.isDefault) ?? supported[0];
 		if (!selected) throw new Error(`Codex app-server has no model supporting ${params.requiredModalities.join(" and ")} input.`);
-		return selected.model;
+		return {
+			catalogId: selected.id,
+			runtimeModelId: selected.model
+		};
 	}
 	const model = params.selection.id;
 	const match = listed.find((entry) => entry.model === model || entry.id === model);
 	if (!match) throw new Error(`Codex app-server model not found: ${model}`);
 	if (params.requiredModalities.includes("image") && !match.inputModalities.includes("image")) throw new Error(`Codex app-server model does not support images: ${model}`);
 	if (params.requiredModalities.includes("text") && !match.inputModalities.includes("text")) throw new Error(`Codex app-server model does not support text: ${model}`);
-	return model;
+	return {
+		catalogId: match.id,
+		runtimeModelId: match.model
+	};
 }
-function createCodexBoundedTurnCollector(threadId, taskLabel) {
+function createCodexBoundedTurnCollector(threadId, taskLabel, allowEmptyText) {
 	let turnId;
 	let completedTurn;
 	let promptError;
@@ -260,10 +282,7 @@ function createCodexBoundedTurnCollector(threadId, taskLabel) {
 	const completedItems = /* @__PURE__ */ new Map();
 	const assistantTextByItem = /* @__PURE__ */ new Map();
 	const assistantItemOrder = [];
-	let resolveCompletion;
-	const completion = new Promise((resolve) => {
-		resolveCompletion = resolve;
-	});
+	const { promise: completion, resolve: resolveCompletion } = createDeferred();
 	const rememberAssistantText = (itemId, text) => {
 		if (!text) return;
 		if (!assistantTextByItem.has(itemId)) assistantItemOrder.push(itemId);
@@ -271,12 +290,12 @@ function createCodexBoundedTurnCollector(threadId, taskLabel) {
 	};
 	const handleNotification = (notification) => {
 		const params = isJsonObject(notification.params) ? notification.params : void 0;
-		if (!params || readString(params, "threadId") !== threadId) return;
+		if (!params || readStringField(params, "threadId") !== threadId) return;
 		if (!turnId) {
 			pending.push(notification);
 			return;
 		}
-		if (readNotificationTurnId(params) !== turnId) return;
+		if (readCodexNotificationTurnId(params) !== turnId) return;
 		if (notification.method === "item/completed") {
 			const item = readCodexNotificationItem(notification.params);
 			if (item) {
@@ -286,8 +305,8 @@ function createCodexBoundedTurnCollector(threadId, taskLabel) {
 			return;
 		}
 		if (notification.method === "item/agentMessage/delta") {
-			const itemId = readString(params, "itemId") ?? readString(params, "id") ?? "assistant";
-			const delta = readString(params, "delta") ?? "";
+			const itemId = readStringField(params, "itemId") ?? readStringField(params, "id") ?? "assistant";
+			const delta = readStringField(params, "delta") ?? "";
 			rememberAssistantText(itemId, `${assistantTextByItem.get(itemId) ?? ""}${delta}`);
 			return;
 		}
@@ -298,20 +317,20 @@ function createCodexBoundedTurnCollector(threadId, taskLabel) {
 		}
 		if (notification.method === "turn/completed") {
 			completedTurn = readCodexTurnCompletedNotification(notification.params)?.turn ?? completedTurn;
-			resolveCompletion?.();
+			resolveCompletion();
 			return;
 		}
 		if (notification.method === "error") {
 			if (isRetryableErrorNotification(notification.params)) return;
 			promptError = readCodexErrorNotification(notification.params)?.error.message ?? `codex app-server ${taskLabel} turn failed`;
-			resolveCompletion?.();
+			resolveCompletion();
 		}
 	};
 	return {
 		handleNotification,
 		async collect(startedTurn, options) {
 			turnId = startedTurn.id;
-			if (isTerminalTurn(startedTurn)) completedTurn = startedTurn;
+			if (isTerminalTurnStatus(startedTurn.status)) completedTurn = startedTurn;
 			for (const notification of pending.splice(0)) handleNotification(notification);
 			if (!completedTurn && !promptError) await waitForTurnCompletion({
 				completion,
@@ -326,7 +345,7 @@ function createCodexBoundedTurnCollector(threadId, taskLabel) {
 			const itemText = collectAssistantTextFromItems(items);
 			const deltaText = assistantItemOrder.map((itemId) => assistantTextByItem.get(itemId)?.trim()).filter((text) => Boolean(text)).join("\n\n").trim();
 			const text = (itemText || deltaText).trim();
-			if (!text) throw new Error(`Codex app-server ${taskLabel} turn returned no text.`);
+			if (!text && !allowEmptyText) throw new Error(`Codex app-server ${taskLabel} turn returned no text.`);
 			return {
 				text,
 				items,
@@ -359,17 +378,5 @@ function resolveCodexBoundedTurnAbortError(signal, taskLabel, timeoutError) {
 function collectAssistantTextFromItems(items) {
 	return (items ?? []).filter((item) => item.type === "agentMessage").map((item) => item.text.trim()).filter(Boolean).join("\n\n").trim();
 }
-function readNotificationTurnId(record) {
-	const direct = readString(record, "turnId");
-	if (direct) return direct;
-	return isJsonObject(record.turn) ? readString(record.turn, "id") : void 0;
-}
-function readString(record, key) {
-	const value = record[key];
-	return typeof value === "string" ? value : void 0;
-}
-function isTerminalTurn(turn) {
-	return turn.status === "completed" || turn.status === "interrupted" || turn.status === "failed";
-}
 //#endregion
 export { runBoundedCodexAppServerTurn as t };

package/dist/{capabilities-BFDTVYr4.js → capabilities-CH3K57v4.js}

@@ -1,4 +1,4 @@
-import { v as CodexAppServerRpcError } from "./shared-client-DTbvH-XV.js";
+import { B as CodexAppServerRpcError } from "./shared-client-Dw-rzii0.js";
 //#region extensions/codex/src/app-server/capabilities.ts
 /**
 * Capability helpers for optional Codex app-server control-plane methods.
@@ -6,10 +6,14 @@ import { v as CodexAppServerRpcError } from "./shared-client-DTbvH-XV.js";
 /** Known app-server methods used by OpenClaw control surfaces. */
 const CODEX_CONTROL_METHODS = {
 	account: "account/read",
-	compact: "thread/compact/start",
+	installedApps: "app/installed",
+	listApps: "app/list",
+	readApps: "app/read",
 	feedback: "feedback/upload",
 	forkThread: "thread/fork",
+	listHooks: "hooks/list",
 	listMcpServers: "mcpServerStatus/list",
+	listPlugins: "plugin/list",
 	listSkills: "skills/list",
 	listThreads: "thread/list",
 	listThreadTurns: "thread/turns/list",
@@ -19,6 +23,8 @@ const CODEX_CONTROL_METHODS = {
 	renameThread: "thread/name/set",
 	resumeThread: "thread/resume",
 	review: "review/start",
+	installPlugin: "plugin/install",
+	reloadMcpServers: "config/mcpServer/reload",
 	unarchiveThread: "thread/unarchive",
 	getThreadGoal: "thread/goal/get",
 	setThreadGoal: "thread/goal/set",

package/dist/cli-metadata.js

@@ -2,7 +2,7 @@ import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 //#region extensions/codex/cli-metadata.ts
 function registerCodexCliMetadata(api) {
 	api.registerCli(async ({ program }) => {
-		const { registerCodexSessionCli } = await import("./session-cli-2PZaFLRh.js");
+		const { registerCodexSessionCli } = await import("./session-cli-B1hKvfkI.js");
 		registerCodexSessionCli(program);
 	}, { descriptors: [{
 		name: "codex",

package/dist/{command-formatters-C336eRVS.js → command-formatters-D0nZ3qtd.js}

@@ -1,6 +1,11 @@
-import { W as isJsonObject } from "./shared-client-DTbvH-XV.js";
-import { c as summarizeCodexRateLimits, o as summarizeCodexAccountRateLimits, r as hasCodexRateLimitSnapshots } from "./rate-limits-CU-gVCCS.js";
+import { ut as isJsonObject } from "./shared-client-Dw-rzii0.js";
+import { c as summarizeCodexRateLimits, o as summarizeCodexAccountRateLimits, r as hasCodexRateLimitSnapshots } from "./rate-limits-BI1dMHDG.js";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/codex/src/command-formatters.ts
+/**
+* Formats Codex command responses for safe chat display, including status,
+* lists, account summaries, and user-facing help text.
+*/
 /** Formats the combined `/codex status` probe result. */
 function formatCodexStatus(probes) {
 	const lines = [`Codex app-server: ${probes.models.ok || probes.account.ok || probes.limits.ok || probes.mcps.ok || probes.skills.ok ? "connected" : "unavailable"}`];
@@ -25,12 +30,12 @@ function formatThreads(response) {
 	if (threads.length === 0) return "No Codex threads returned.";
 	return ["Codex threads:", ...threads.slice(0, 10).map((thread) => {
 		const record = isJsonObject(thread) ? thread : {};
-		const id = readString(record, "threadId") ?? readString(record, "id") ?? "<unknown>";
-		const title = readString(record, "title") ?? readString(record, "name") ?? readString(record, "summary");
+		const id = normalizeOptionalString(record.threadId) ?? normalizeOptionalString(record.id) ?? "<unknown>";
+		const title = normalizeOptionalString(record.title) ?? normalizeOptionalString(record.name) ?? normalizeOptionalString(record.summary);
 		const details = [
-			readString(record, "model"),
-			readString(record, "cwd"),
-			readString(record, "updatedAt") ?? readString(record, "lastUpdatedAt")
+			normalizeOptionalString(record.model),
+			normalizeOptionalString(record.cwd),
+			normalizeOptionalString(record.updatedAt) ?? normalizeOptionalString(record.lastUpdatedAt)
 		].filter((value) => Boolean(value));
 		return `- ${formatCodexDisplayText(id)}${title ? ` - ${formatCodexDisplayText(title)}` : ""}${details.length > 0 ? ` (${details.map(formatCodexDisplayText).join(", ")})` : ""}\n  Resume: ${formatCodexResumeHint(id)}`;
 	})].join("\n");
@@ -85,7 +90,7 @@ function formatList(response, label) {
 	if (entries.length === 0) return `${label}: none returned.`;
 	return [`${label}:`, ...entries.slice(0, 25).map((entry) => {
 		const record = isJsonObject(entry) ? entry : {};
-		return `- ${formatCodexDisplayText(readString(record, "name") ?? readString(record, "id") ?? JSON.stringify(entry))}`;
+		return `- ${formatCodexDisplayText(normalizeOptionalString(record.name) ?? normalizeOptionalString(record.id) ?? JSON.stringify(entry))}`;
 	})].join("\n");
 }
 /** Formats Codex skills grouped by scope, omitting disabled entries. */
@@ -113,7 +118,7 @@ function formatSkills(response) {
 	return lines.join("\n");
 }
 function formatCodexSkillEntry(entry) {
-	return `\`${formatCodexDisplayText(readString(isJsonObject(entry) ? entry : {}, "name") ?? "<unknown>")}\``;
+	return `\`${formatCodexDisplayText(normalizeOptionalString((isJsonObject(entry) ? entry : {}).name) ?? "<unknown>")}\``;
 }
 const CODEX_RESUME_SAFE_THREAD_ID_PATTERN = /^[A-Za-z0-9._:-]+$/;
 function formatCodexResumeHint(threadId) {
@@ -200,8 +205,8 @@ function buildHelp() {
 function summarizeAccount(value) {
 	if (!isJsonObject(value)) return "unavailable";
 	const account = isJsonObject(value.account) ? value.account : value;
-	if (readString(account, "type") === "amazonBedrock") return "Amazon Bedrock";
-	return readString(account, "email") ?? readString(account, "accountEmail") ?? readString(account, "planType") ?? readString(account, "id") ?? "available";
+	if (normalizeOptionalString(account.type) === "amazonBedrock") return "Amazon Bedrock";
+	return normalizeOptionalString(account.email) ?? normalizeOptionalString(account.accountEmail) ?? normalizeOptionalString(account.planType) ?? normalizeOptionalString(account.id) ?? "available";
 }
 function summarizeArrayLike(value) {
 	const entries = extractArray(value);
@@ -249,7 +254,7 @@ function summarizeRateLimits(value) {
 }
 function isMeaningfulRateLimitSnapshot(value) {
 	if (!isJsonObject(value)) return false;
-	if (readString(value, "rateLimitReachedType") ?? readString(value, "rate_limit_reached_type")) return true;
+	if (normalizeOptionalString(value.rateLimitReachedType) ?? normalizeOptionalString(value.rate_limit_reached_type)) return true;
 	return ["primary", "secondary"].some((key) => {
 		const window = value[key];
 		return isJsonObject(window) && Object.values(window).some((entry) => entry != null);
@@ -272,10 +277,5 @@ function extractArray(value) {
 	}
 	return [];
 }
-/** Reads and trims a non-empty string field from a JSON object. */
-function readString(record, key) {
-	const value = record[key];
-	return typeof value === "string" && value.trim() ? value.trim() : void 0;
-}
 //#endregion
-export { formatComputerUseStatus as a, formatSkills as c, formatCodexStatus as i, formatThreads as l, formatAccount as n, formatList as o, formatCodexDisplayText as r, formatModels as s, buildHelp as t, readString as u };
+export { formatComputerUseStatus as a, formatSkills as c, formatCodexStatus as i, formatThreads as l, formatAccount as n, formatList as o, formatCodexDisplayText as r, formatModels as s, buildHelp as t };