@openclaw/codex 2026.9.8 → 2026.10.1-beta.2

package/README.md

@@ -22,6 +22,10 @@ openclaw codex archive <thread-id> --confirm-no-other-runner [--json] [--url <ur
 
 The catalog never includes archived threads and has no archived or include-archived option. Rows appear in the normal Control UI sessions sidebar and open in the normal Chat pane. Transcript history requires a recent Codex App Server with `thread/turns/list` and is fetched 20 full-item turns at a time through opaque cursors; OpenClaw does not fall back to an unbounded `thread/read`, and rejects a serialized transcript page above 20 MiB before transport. `--limit` defaults to 50 sessions per host, `--cursor` requires `--host`, and the sessions Gateway timeout defaults to 75,000 ms so cold paired-node catalogs can complete. Continue and archive retain the shared 30,000 ms default. All operator surfaces require `operator.write`. Paired-node rows can be listed and read; continue and archive operate only on the Gateway-local host, and archive requires the no-other-runner confirmation. Catalog registration does not require `supervision.enabled`; that setting gates agent-facing supervision tools.
 
+Local discovery reads native provenance from plain or compressed rollouts. A failed read can fall back to the other representation and does not cache an unknown originator as a permanent unmanaged result.
+
+With `appServer.remoteWorkspaceRoot`, OpenClaw maps workspace-relative paths to the remote root. Local filesystem-root workspaces, including `/` and Windows drive roots, follow the same mapping.
+
 A supervised OpenClaw Chat cannot be deleted while its model-selection lock protects the native binding. Before native archive, OpenClaw checks the exact target and every non-archived spawned descendant reported by Codex; any active OpenClaw binding blocks the operation. Descendant pagination errors, cycles, and safety-limit exhaustion also fail closed. Codex still does not expose a conditional archive operation or cross-process runner lease, so the confirmation covers unknown native clients and the race between the status read and archive request.
 
 Disabling or uninstalling the plugin leaves supervised Chats locked and unavailable rather than rerouting them. Reinstall or re-enable the same plugin and restart the Gateway to resume those Chats.
@@ -30,10 +34,14 @@ These shell commands differ from the in-chat `/codex` runtime commands. In parti
 
 Native Codex plugin catalogs are discoverable with `/codex plugins available`, including repository marketplaces declared in `.agents/plugins/marketplace.json` in the bound workspace. An owner or `operator.admin` can install and authorize an exact plugin with `/codex plugins install <plugin>@<marketplace>`. The owner-scoped `codex_plugins` agent tool only reads marketplace metadata; installation and policy changes stay on authenticated `/codex` management commands. Explicitly installing a plugin trusts its skills, apps, MCP servers, and hooks.
 
+Cached app inventory diagnostics reflect the current refresh or invalidation. Failures from superseded requests remain logged without replacing that newer status.
+
 For a supervised branch, Codex App Server selects the snapshot fork's model and provider from its current native configuration. OpenClaw starts the canonical harness thread with exactly that returned pair. Codex persists the canonical thread's native selection, and later resumes preserve it because OpenClaw omits model and provider overrides. OpenClaw cannot substitute its outer runtime, model, or fallback. The returned initial pair can differ from the source's last recorded model.
 
 The visible-history mirror keeps at most 200 user or assistant messages, 512 KiB total, and 64 KiB per message. Image inputs become `[Image attachment]`; image data and local paths are not copied.
 
+When assembled context bootstraps a Codex thread, redacted tool payloads retain literal JSON field names. Tool inputs retain their shape; tool results retain redacted content.
+
 Settled-turn finalization uses the same configured Codex App Server transport as the supervised conversation. Remote websocket App Server configurations stay on their configured transport. Managed user-home stdio launches running inside an Agent home, and not through the proxy launcher, use a private stdio side turn for native-tool isolation. The bounded finalizer preserves the selected model, provider, and native authorization returned by Codex, and rejects native tool evidence outside the finalization contract. It may mirror a final answer after completed tool work; it does not diagnose why a model omitted a visible final message.
 
 When settled-turn recovery rejects history, the `codex settled-turn finalization context capture failed` warning includes a stable `reason`, such as `item_limit`, `byte_limit`, `field_limit`, `unsupported_user_image`, or `snapshot_invalidated`. Unknown failures use `history_read_failed`. The warning excludes transcript content and exception text. Rejected history remains unavailable for finalization, and completed actions are never replayed.

package/dist/.setup/{account-usage-runtime-G348lY1q.mjs → account-usage-runtime-DGqFpAud.mjs}

@@ -1,9 +1,9 @@
 import { n as isCodexAppServerProxyLaunch } from "./launch-args-DbFCehO7.mjs";
-import { t as buildCodexAppServerUsageSnapshot } from "./rate-limits-B7-X2TgG.mjs";
-import { n as readCodexAppServerUsage } from "./request-BZOfsSXW.mjs";
-import "./config-DKhXquav.mjs";
-import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-C0NbLms1.mjs";
-import { a as resolveCodexAppServerAuthProfileStore } from "./auth-profile-B0okYl2D.mjs";
+import { t as buildCodexAppServerUsageSnapshot } from "./rate-limits-CMPy24F5.mjs";
+import { t as readCodexAppServerUsage } from "./request-jSbhc1sg.mjs";
+import "./config-0Gxk3_eq.mjs";
+import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-cUYrqu_a.mjs";
+import { a as resolveCodexAppServerAuthProfileStore } from "./auth-profile-CgHQ8Vot.mjs";
 import { isDeepStrictEqual } from "node:util";
 import { listAgentIds, resolveAgentDir } from "openclaw/plugin-sdk/agent-scope-runtime";
 import { z } from "zod";

package/dist/.setup/app-server-policy-Bg4FZw1f.mjs

@@ -0,0 +1,23 @@
+import { n as canUseCodexModelBackedApprovalsReviewerForModel } from "./config-0Gxk3_eq.mjs";
+//#region extensions/codex/src/app-server/app-server-policy.ts
+function resolveCodexAppServerForModelProvider(params) {
+	if (params.appServer.approvalsReviewer === "user" || canUseCodexModelBackedApprovalsReviewerForModel({
+		modelProvider: params.provider,
+		model: params.model,
+		config: params.config,
+		env: {
+			...params.env ?? process.env,
+			...params.appServer.start.env
+		},
+		agentDir: params.agentDir,
+		codexConfigToml: params.codexConfigToml,
+		homeScope: params.appServer.start.homeScope,
+		codexArgs: params.appServer.start.args
+	})) return params.appServer;
+	return {
+		...params.appServer,
+		approvalsReviewer: "user"
+	};
+}
+//#endregion
+export { resolveCodexAppServerForModelProvider as t };

package/dist/.setup/{apply-Cqb-YoCS.mjs → apply-CXTudl9p.mjs}

@@ -1,14 +1,14 @@
-import { n as isOpenAiCuratedMarketplace, u as CODEX_PLUGINS_MARKETPLACE_NAME } from "./plugin-inventory-Cky2XJUw.mjs";
-import { d as readCodexPluginConfig } from "./config-parsing-b088LyhT.mjs";
-import { s as resolveCodexAppServerFallbackApiKeyCacheKey } from "./auth-cache-key-Dnps4W4_.mjs";
-import { a as defaultCodexAppInventoryCache, r as buildCodexPluginAppCacheKey } from "./plugin-app-cache-key-BL9B5H0L.mjs";
-import { i as requestCodexAppServerJson } from "./request-BZOfsSXW.mjs";
-import "./config-DKhXquav.mjs";
-import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-C0NbLms1.mjs";
-import { i as resolveCodexAppServerAuthProfileIdForAgent } from "./auth-profile-B0okYl2D.mjs";
-import { c as getLeasedSharedCodexAppServerClient, et as resolveCodexAppServerAuthAccountCacheKey, h as releaseLeasedSharedCodexAppServerClient, o as clearSharedCodexAppServerClientIfCurrentAndWait } from "./shared-client-CJCTeFpQ.mjs";
-import { t as ensureCodexPluginActivation } from "./plugin-activation-cNHRfaxU.mjs";
-import { CODEX_PLUGIN_CONFIG_PATH, buildCodexMigrationPlan, buildCodexPluginsConfigValue, hasCodexPluginConfigConflict, n as resolveCodexConfigPatchMode, readCodexPluginMigrationConfigEntry, t as createCodexAuthItemApplier } from "./plan-DPdMk1Oy.mjs";
+import { d as readCodexPluginConfig } from "./config-parsing-BQq-CHTF.mjs";
+import { s as resolveCodexAppServerFallbackApiKeyCacheKey } from "./auth-cache-key-CGm0UJOr.mjs";
+import { a as defaultCodexAppInventoryCache, r as buildCodexPluginAppCacheKey } from "./plugin-app-cache-key-BW8rd98k.mjs";
+import { r as requestCodexAppServerJson } from "./request-jSbhc1sg.mjs";
+import { l as CODEX_PLUGINS_MARKETPLACE_NAME, n as isOpenAiCuratedMarketplaceName } from "./plugin-inventory-Bf0_piTw.mjs";
+import "./config-0Gxk3_eq.mjs";
+import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-cUYrqu_a.mjs";
+import { i as resolveCodexAppServerAuthProfileIdForAgent } from "./auth-profile-CgHQ8Vot.mjs";
+import { c as getLeasedSharedCodexAppServerClient, et as resolveCodexAppServerAuthAccountCacheKey, h as releaseLeasedSharedCodexAppServerClient, o as clearSharedCodexAppServerClientIfCurrentAndWait } from "./shared-client-qhyYWbew.mjs";
+import { t as ensureCodexPluginActivation } from "./plugin-activation-BcyBv8PG.mjs";
+import { CODEX_PLUGIN_CONFIG_PATH, buildCodexMigrationPlan, buildCodexPluginsConfigValue, hasCodexPluginConfigConflict, n as resolveCodexConfigPatchMode, readCodexPluginMigrationConfigEntry, t as createCodexAuthItemApplier } from "./plan-BJ37d2Og.mjs";
 import { uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { parseStrictNonNegativeInteger } from "openclaw/plugin-sdk/number-runtime";
 import path from "node:path";
@@ -16,30 +16,6 @@ import { coerceErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { sleep } from "openclaw/plugin-sdk/runtime-env";
 import { MIGRATION_REASON_TARGET_EXISTS, applyMigrationManualItem, markMigrationItemConflict, markMigrationItemError, markMigrationItemSkipped, resolveMigrationConfigRuntime, summarizeMigrationItems, writeMigrationConfigPath } from "openclaw/plugin-sdk/migration";
 import { archiveMigrationItem, copyMemoryMigrationFileItem, copyMigrationFileItem, resolvePlannedMigrationTargets, withCachedMigrationConfigRuntime, writeMigrationReport } from "openclaw/plugin-sdk/migration-runtime";
-//#region extensions/codex/src/migration/apply-report.ts
-function codexPluginActivationReportState(result) {
-	switch (result.reason) {
-		case "already_active":
-		case "installed": return {
-			installed: true,
-			enabled: true
-		};
-		case "auth_required":
-		case "refresh_failed": return {
-			installed: true,
-			enabled: false
-		};
-		case "disabled":
-		case "install_failed":
-		case "marketplace_missing":
-		case "plugin_missing": return {
-			installed: false,
-			enabled: false
-		};
-	}
-	return result.reason;
-}
-//#endregion
 //#region extensions/codex/src/migration/apply.ts
 const CODEX_PLUGIN_AUTH_REQUIRED_REASON = "auth_required";
 const CODEX_PLUGIN_NOT_SELECTED_REASON = "not selected for migration";
@@ -47,6 +23,40 @@ const CODEX_PLUGIN_LOAD_WARNING = "Some Codex plugins could not be migrated. Run
 const TARGET_CODEX_MARKETPLACE_DISCOVERY_POLL_MS = 250;
 const TARGET_CODEX_MARKETPLACE_DISCOVERY_TIMEOUT_MS = 3e4;
 const TARGET_CODEX_MARKETPLACE_DISCOVERY_TIMEOUT_ENV = "OPENCLAW_CODEX_MIGRATION_PLUGIN_LIST_TIMEOUT_MS";
+const PLUGIN_ACTIVATION_REPORT_STATE = {
+	already_active: {
+		installed: true,
+		enabled: true
+	},
+	installed: {
+		installed: true,
+		enabled: true
+	},
+	auth_required: {
+		installed: true,
+		enabled: false
+	},
+	refresh_failed: {
+		installed: true,
+		enabled: false
+	},
+	disabled: {
+		installed: false,
+		enabled: false
+	},
+	install_failed: {
+		installed: false,
+		enabled: false
+	},
+	marketplace_missing: {
+		installed: false,
+		enabled: false
+	},
+	plugin_missing: {
+		installed: false,
+		enabled: false
+	}
+};
 var CodexPluginConfigConflictError = class extends Error {
 	constructor(reason) {
 		super(reason);
@@ -83,7 +93,6 @@ async function applyCodexMigrationPlan(params) {
 	const codexHome = typeof plan.metadata?.codexHome === "string" && plan.metadata.codexHome.trim() ? plan.metadata.codexHome : plan.source;
 	const authSource = {
 		codexHome,
-		authPath: path.join(codexHome, "auth.json"),
 		modelsCachePath: path.join(codexHome, "models_cache.json")
 	};
 	const runtime = withCachedMigrationConfigRuntime(params.ctx.runtime ?? params.runtime, params.ctx.config);
@@ -158,7 +167,7 @@ async function applyCodexPluginInstallItem(ctx, item) {
 			...item.details,
 			code: result.reason,
 			activationReason: result.reason,
-			...codexPluginActivationReportState(result),
+			...PLUGIN_ACTIVATION_REPORT_STATE[result.reason],
 			installAttempted: result.installAttempted,
 			diagnostics: result.diagnostics.map((diagnostic) => diagnostic.message)
 		};
@@ -236,7 +245,7 @@ async function requestTargetCodexAppServerJson(params) {
 			...params,
 			timeoutMs: remainingMs
 		});
-		if (lastResponse.marketplaces.some(isOpenAiCuratedMarketplace)) return lastResponse;
+		if (lastResponse.marketplaces.some((marketplace) => isOpenAiCuratedMarketplaceName(marketplace.name))) return lastResponse;
 		if (Date.now() >= discoveryDeadline) return lastResponse;
 		const waitMs = Math.min(TARGET_CODEX_MARKETPLACE_DISCOVERY_POLL_MS, discoveryDeadline - Date.now());
 		await sleep(waitMs);
@@ -271,7 +280,7 @@ async function buildTargetCodexPluginAppCacheKey(ctx) {
 	});
 }
 async function applyCodexPluginConfigItem(ctx, item, appliedItems) {
-	if (appliedItems.some((candidate) => candidate.kind === "plugin" && candidate.action === "install" && readCodexPluginPolicy(candidate) !== void 0 && !isCodexPluginConfigTerminal(candidate))) return {
+	if (appliedItems.some((candidate) => candidate.kind === "plugin" && candidate.action === "install" && readCodexPluginMigrationConfigEntry(candidate, true) !== void 0 && !isCodexPluginConfigTerminal(candidate))) return {
 		...item,
 		status: "warning",
 		reason: "selected Codex plugin activation is incomplete"

package/dist/.setup/attempt-client-cleanup-BH0hW2xU.mjs

@@ -0,0 +1,155 @@
+import { w as retireSharedCodexAppServerClientIfCurrent } from "./auth-cache-key-CGm0UJOr.mjs";
+import { a as codexPrewriteRejectionCause, o as isCodexAppServerOverloadError, r as CodexAppServerRpcError } from "./rpc-error-hmWM21RB.mjs";
+import { J as unsubscribeCodexAppServerLiveThread, ft as isCodexAppServerStartupError, u as isCodexAppServerStartSelectionChangedError } from "./shared-client-qhyYWbew.mjs";
+import { V as isCodexAppServerBrokenPipeError, c as isCodexAppServerRequestTimeoutError } from "./client-C8lgBOoO.mjs";
+import { n as getCodexAppServerTurnRouter } from "./turn-router-sS69wYnI.mjs";
+import { t as __exportAll } from "./session-binding-sidecars-BrdV95Fg.mjs";
+import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
+import { AgentHarnessPreflightError, embeddedAgentLog } from "openclaw/plugin-sdk/agent-harness-runtime";
+//#region extensions/codex/src/app-server/attempt-client-cleanup.ts
+var attempt_client_cleanup_exports = /* @__PURE__ */ __exportAll({
+	CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS: () => CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS,
+	CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS: () => CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS,
+	CodexAppServerUnsafeSubscriptionError: () => CodexAppServerUnsafeSubscriptionError,
+	assertCodexThreadResumeSubscription: () => assertCodexThreadResumeSubscription,
+	closeCodexStartupClientBestEffort: () => closeCodexStartupClientBestEffort,
+	interruptCodexTurnAndWaitBestEffort: () => interruptCodexTurnAndWaitBestEffort,
+	isCodexNoActiveTurnInterruptError: () => isCodexNoActiveTurnInterruptError,
+	retireUnsafeCodexTurnClientBestEffort: () => retireUnsafeCodexTurnClientBestEffort,
+	shouldRetireCodexStartupClient: () => shouldRetireCodexStartupClient,
+	terminateCodexBackgroundTerminals: () => terminateCodexBackgroundTerminals,
+	unsubscribeCodexThreadBestEffort: () => unsubscribeCodexThreadBestEffort
+});
+const CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS = 5e3;
+const CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS = 5e3;
+const CODEX_NO_ACTIVE_TURN_ERROR_CODE = -32600;
+const CODEX_NO_ACTIVE_TURN_ERROR_MESSAGE = "no active turn to interrupt";
+/** Codex also reports this before an accepted turn publishes its start event. */
+function isCodexNoActiveTurnInterruptError(error) {
+	return error instanceof CodexAppServerRpcError && error.code === CODEX_NO_ACTIVE_TURN_ERROR_CODE && error.message === CODEX_NO_ACTIVE_TURN_ERROR_MESSAGE;
+}
+/** Raised when a thread subscription may be live on a client OpenClaw no longer controls. */
+var CodexAppServerUnsafeSubscriptionError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "CodexAppServerUnsafeSubscriptionError";
+	}
+};
+function assertCodexThreadResumeSubscription(requestedThreadId, returnedThreadId) {
+	if (returnedThreadId !== requestedThreadId) throw new CodexAppServerUnsafeSubscriptionError(`Codex thread/resume returned ${returnedThreadId} for ${requestedThreadId}`);
+}
+async function closeCodexStartupClientBestEffort(client) {
+	if (!client) return;
+	const retiredSharedClient = retireSharedCodexAppServerClientIfCurrent(client);
+	if (!retiredSharedClient || retiredSharedClient.closed) await client.closeAndWait();
+}
+/** Retires an unsafe turn client without replacing an already-authoritative failure. */
+async function retireUnsafeCodexTurnClientBestEffort(client, operation) {
+	try {
+		await closeCodexStartupClientBestEffort(client);
+	} catch (error) {
+		embeddedAgentLog.debug("codex app-server unsafe turn client retirement failed", {
+			operation,
+			error
+		});
+		try {
+			client.close();
+		} catch (closeError) {
+			embeddedAgentLog.debug("codex app-server unsafe turn client close failed", {
+				operation,
+				error: closeError
+			});
+		}
+	}
+}
+/** Sends a bounded turn interrupt and waits for Codex to confirm terminal abort handling. */
+async function interruptCodexTurnAndWaitBestEffort(client, params) {
+	const timeoutMs = params.timeoutMs && Number.isFinite(params.timeoutMs) && params.timeoutMs > 0 ? params.timeoutMs : CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS;
+	const requestParams = {
+		threadId: params.threadId,
+		turnId: params.turnId
+	};
+	let cancelWatch;
+	try {
+		if (!params.turnId) {
+			await client.request("turn/interrupt", requestParams, { timeoutMs });
+			return true;
+		}
+		const deadline = performance.now() + timeoutMs;
+		const started = createDeferred();
+		const completion = getCodexAppServerTurnRouter(client).watchNativeTurnCompletion({
+			threadId: params.threadId,
+			turnId: params.turnId,
+			timeoutMs,
+			onStarted: () => started.resolve(true)
+		});
+		cancelWatch = completion.cancel;
+		if (completion.state !== "pending") return await completion.completion;
+		const requestInterrupt = async () => {
+			try {
+				await client.request("turn/interrupt", requestParams, {
+					timeoutMs: Math.max(1, deadline - performance.now()),
+					signal: completion.settledSignal
+				});
+				return true;
+			} catch (error) {
+				if (completion.state === "confirmed") return true;
+				if (isCodexNoActiveTurnInterruptError(error)) return false;
+				throw error;
+			}
+		};
+		if (!await requestInterrupt()) {
+			if (await Promise.race([completion.completion.then(() => false), started.promise]) && completion.state === "pending" && performance.now() < deadline) await requestInterrupt();
+		}
+		return await completion.completion;
+	} catch (error) {
+		embeddedAgentLog.debug("codex app-server turn interrupt failed during abort", { error });
+		return false;
+	} finally {
+		cancelWatch?.();
+	}
+}
+/** Stops native terminals on the cancelled thread without retiring peer threads. */
+async function terminateCodexBackgroundTerminals(client, threadId, oneShotCliRun = false, waitForNativeItems) {
+	const options = {
+		timeoutMs: CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS,
+		signal: AbortSignal.timeout(CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS)
+	};
+	try {
+		const { data } = await client.request("thread/backgroundTerminals/list", { threadId }, options);
+		for (const { processId } of data) await client.request("thread/backgroundTerminals/terminate", {
+			threadId,
+			processId
+		}, options);
+		if (data.length > 0) {
+			if ((await client.request("thread/backgroundTerminals/list", {
+				threadId,
+				limit: 1
+			}, options)).data.length > 0) throw new Error("native background terminals remain running");
+			if (oneShotCliRun) throw new Error("native terminal termination did not confirm process cleanup");
+		}
+		await waitForNativeItems?.(options.signal);
+	} catch (cause) {
+		throw new Error("Codex background-terminal cleanup failed; inspect the thread's running terminals before starting more work.", { cause });
+	}
+}
+async function unsubscribeCodexThreadBestEffort(client, params) {
+	try {
+		await unsubscribeCodexAppServerLiveThread(client, params.threadId, params.timeoutMs, params.assertCurrent, params.withCurrent);
+		return true;
+	} catch (error) {
+		params.assertCurrent?.();
+		embeddedAgentLog.debug("codex app-server thread unsubscribe cleanup failed", {
+			threadId: params.threadId,
+			error
+		});
+		return false;
+	}
+}
+function shouldRetireCodexStartupClient(error, spawnedBy, signal) {
+	const cause = codexPrewriteRejectionCause(error);
+	if (signal.aborted || isCodexAppServerStartupError(cause) || isCodexAppServerRequestTimeoutError(cause)) return true;
+	return !isCodexAppServerStartSelectionChangedError(cause) && !isCodexAppServerOverloadError(cause) && !(cause instanceof AgentHarnessPreflightError && cause.scope === void 0) && (isCodexAppServerBrokenPipeError(cause) || !spawnedBy);
+}
+//#endregion
+export { attempt_client_cleanup_exports as a, isCodexNoActiveTurnInterruptError as c, terminateCodexBackgroundTerminals as d, unsubscribeCodexThreadBestEffort as f, assertCodexThreadResumeSubscription as i, retireUnsafeCodexTurnClientBestEffort as l, CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS as n, closeCodexStartupClientBestEffort as o, CodexAppServerUnsafeSubscriptionError as r, interruptCodexTurnAndWaitBestEffort as s, CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS as t, shouldRetireCodexStartupClient as u };

package/dist/.setup/{attempt-workspace-context-BJ5Z_olH.mjs → attempt-workspace-context-BY0jprWJ.mjs}

@@ -1,5 +1,6 @@
 import { r as flattenCodexDynamicToolFunctions } from "./protocol-CANUwXJ3.mjs";
-import { lt as isMessageOnlyCodexSourceReply } from "./thread-requests-OWGOiDaV.mjs";
+import { ut as isMessageOnlyCodexSourceReply } from "./thread-requests-CL1e8Wmx.mjs";
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
 import path from "node:path";
 import { buildAgentWorkspaceInstructionSnapshot, buildBootstrapContextForFiles, embeddedAgentLog, prepareAgentWorkspaceContext } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { resolveAgentWorkspaceMemoryRouting, shouldIncludeAgentHarnessRuntimeContext } from "openclaw/plugin-sdk/agent-harness-attempt-runtime";
@@ -17,7 +18,7 @@ const CODEX_BOOTSTRAP_CONTEXT_ORDER = /* @__PURE__ */ new Map([
 ]);
 /** A child baseline reads the bounded workspace snapshot without invoking admission hooks. */
 async function prepareCodexWorkspaceDeveloperInstructions(params) {
-	if (isSameCodexWorkspacePath(params.workspaceDir, params.cwd)) return;
+	if (path.resolve(params.workspaceDir) === path.resolve(params.cwd)) return;
 	const files = await resolveBootstrapFilesForPreparation(params);
 	const contextFiles = buildBootstrapContextForFiles(files, {
 		config: params.config,
@@ -26,7 +27,7 @@ async function prepareCodexWorkspaceDeveloperInstructions(params) {
 	return buildAgentWorkspaceInstructionSnapshot(contextFiles, params.workspaceDir).instructions;
 }
 async function buildCodexWorkspaceBootstrapContext(params) {
-	const availableToolNames = new Set(flattenCodexDynamicToolFunctions(params.tools).map((tool) => normalizeCodexDynamicToolName(tool.name)));
+	const availableToolNames = new Set(flattenCodexDynamicToolFunctions(params.tools).map((tool) => normalizeLowercaseStringOrEmpty(tool.name)));
 	const inheritsAgentWorkspace = (params.executionWorkspace ?? params.resolvedWorkspace) !== params.resolvedWorkspace;
 	const injectOpenClawContext = shouldIncludeAgentHarnessRuntimeContext(params.params);
 	const restrictedProjectDocNeedsOpenClawCarrier = params.params.pluginHarnessToolPolicyRestricted === true && !params.params.disableTools && !isMessageOnlyCodexSourceReply(params.params) && params.params.bootstrapContextMode !== "lightweight";
@@ -74,15 +75,16 @@ async function buildCodexWorkspaceBootstrapContext(params) {
 			inheritsAgentWorkspace,
 			promptContextFiles,
 			threadDeveloperInstructionFiles: includeAgentWorkspaceInstructions ? prepared.instructionSnapshot.files : [],
-			turnScopedDeveloperInstructionFiles: injectOpenClawContext ? prepared.personaFiles : [],
+			personaFiles: injectOpenClawContext ? prepared.personaFiles : [],
 			memoryReferenceFiles,
 			memoryToolRoutedBootstrapFiles,
 			memoryToolNames,
 			memoryToolRouted,
 			promptContext: renderCodexWorkspaceBootstrapPromptContext(promptContextFiles),
 			threadDeveloperInstructions: includeAgentWorkspaceInstructions ? params.agentWorkspaceDeveloperInstructions ?? prepared.instructionSnapshot.instructions : void 0,
-			turnScopedDeveloperInstructions: injectOpenClawContext ? prepared.personaInstructions : void 0,
-			memoryCollaborationInstructions: injectOpenClawContext ? renderCodexWorkspaceMemoryCollaborationInstructions({
+			personaInstructions: injectOpenClawContext ? prepared.personaInstructions : void 0,
+			sharedPersonaInstructions: injectOpenClawContext ? prepared.sharedPersonaInstructions : void 0,
+			memoryInstructions: injectOpenClawContext ? renderCodexWorkspaceMemoryInstructions({
 				files: memoryReferenceFiles,
 				toolNames: memoryToolNames,
 				memoryRecallInstructions: prepared.memoryRecallInstructions
@@ -122,18 +124,15 @@ function renderCodexWorkspaceMemoryReference(params) {
 	for (const file of params.files) lines.push(`- ${file.path}`);
 	return lines.join("\n").trim();
 }
-function renderCodexWorkspaceMemoryCollaborationInstructions(params) {
+function renderCodexWorkspaceMemoryInstructions(params) {
 	const sections = [params.memoryRecallInstructions ? [params.memoryRecallInstructions, renderCodexMemoryToolSearchBridge(params.toolNames)].filter(isNonEmptyString).join("\n").trim() : void 0, renderCodexWorkspaceMemoryReference(params)].filter(isNonEmptyString);
 	return sections.length > 0 ? sections.join("\n\n") : void 0;
 }
 function renderCodexMemoryToolSearchBridge(toolNames) {
-	const memoryToolNames = toolNames.map((name) => normalizeCodexDynamicToolName(name)).filter((name) => CODEX_MEMORY_TOOL_NAMES.has(name)).toSorted();
+	const memoryToolNames = toolNames.map(normalizeLowercaseStringOrEmpty).filter((name) => CODEX_MEMORY_TOOL_NAMES.has(name)).toSorted();
 	if (memoryToolNames.length === 0) return;
 	return `Codex may expose ${memoryToolNames.join(" and ")} as deferred tools. When the memory guidance above calls for memory recall, use an already-loaded memory tool directly. If the needed memory tool is deferred and not currently callable, use \`tool_search\` to load it, then call that memory tool.`;
 }
-function isSameCodexWorkspacePath(left, right) {
-	return path.resolve(left) === path.resolve(right);
-}
 /**
 * Remaps bootstrap file paths from the resolved workspace to the effective Codex
 * workspace while preserving platform path separators.
@@ -154,11 +153,8 @@ function getCodexContextFileDisplayBasename(filePath) {
 function getCodexContextFileBasename(filePath) {
 	return normalizeCodexContextFilePath(filePath).split("/").pop() ?? "";
 }
-function normalizeCodexDynamicToolName(name) {
-	return name.trim().toLowerCase();
-}
 function isNonEmptyString(value) {
 	return typeof value === "string" && value.length > 0;
 }
 //#endregion
-export { getCodexContextFileDisplayBasename as a, normalizeCodexDynamicToolName as c, getCodexContextFileBasename as i, prepareCodexWorkspaceDeveloperInstructions as l, CODEX_NATIVE_PROJECT_DOC_BASENAMES as n, isNonEmptyString as o, buildCodexWorkspaceBootstrapContext as r, normalizeCodexContextFilePath as s, CODEX_MEMORY_CONTEXT_BASENAME as t };
+export { getCodexContextFileDisplayBasename as a, prepareCodexWorkspaceDeveloperInstructions as c, getCodexContextFileBasename as i, CODEX_NATIVE_PROJECT_DOC_BASENAMES as n, isNonEmptyString as o, buildCodexWorkspaceBootstrapContext as r, normalizeCodexContextFilePath as s, CODEX_MEMORY_CONTEXT_BASENAME as t };

package/dist/.setup/{auth-binding-BLWz7stm.mjs → auth-binding-BoMwpuPN.mjs}

@@ -1,30 +1,13 @@
 import { i as isCodexResponsesOAuthCredential, o as resolveCodexResponsesOAuthProfileFingerprint } from "./responses-oauth-twnuTaAa.mjs";
-import { t as __exportAll } from "./session-binding-sidecars-jo6H8dFr.mjs";
-import { resolveApiKeyForProfile } from "openclaw/plugin-sdk/agent-runtime";
+import { t as __exportAll } from "./session-binding-sidecars-BrdV95Fg.mjs";
 import { fingerprintResolvedAuthProfileCredential } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { resolveApiKeyForProfile } from "openclaw/plugin-sdk/agent-runtime";
 import { resolveOpenAICodexAuthIdentity } from "openclaw/plugin-sdk/provider-auth";
 //#region extensions/codex/src/app-server/auth-binding.ts
 var auth_binding_exports = /* @__PURE__ */ __exportAll({
 	fingerprintCodexAppServerAuthBinding: () => fingerprintCodexAppServerAuthBinding,
 	prepareCodexAppServerAuthBinding: () => prepareCodexAppServerAuthBinding
 });
-function withMaterializedCredential(params) {
-	const store = structuredClone(params.store);
-	if (params.credential.type === "api_key") {
-		const { keyRef: _keyRef, ...credential } = params.credential;
-		store.profiles[params.profileId] = {
-			...credential,
-			key: params.value
-		};
-	} else if (params.credential.type === "token") {
-		const { tokenRef: _tokenRef, ...credential } = params.credential;
-		store.profiles[params.profileId] = {
-			...credential,
-			token: params.value
-		};
-	}
-	return store;
-}
 /** Resolves one forwarded profile once so attestation and execution share exact material. */
 async function prepareCodexAppServerAuthBinding(params) {
 	const credential = params.authProfileStore.profiles[params.authProfileId];
@@ -73,14 +56,23 @@ async function prepareCodexAppServerAuthBinding(params) {
 		}
 	});
 	if (!fingerprint) throw new Error(`Codex could not attest auth profile "${params.authProfileId}". Re-select the OpenAI profile and retry.`);
+	const store = structuredClone(params.authProfileStore);
+	if (credential.type === "api_key") {
+		const { keyRef: _keyRef, ...materialized } = credential;
+		store.profiles[params.authProfileId] = {
+			...materialized,
+			key: resolved.apiKey
+		};
+	} else {
+		const { tokenRef: _tokenRef, ...materialized } = credential;
+		store.profiles[params.authProfileId] = {
+			...materialized,
+			token: resolved.apiKey
+		};
+	}
 	return {
 		fingerprint,
-		authProfileStore: withMaterializedCredential({
-			store: params.authProfileStore,
-			profileId: params.authProfileId,
-			credential,
-			value: resolved.apiKey
-		})
+		authProfileStore: store
 	};
 }
 async function fingerprintCodexAppServerAuthBinding(params) {