@openclaw/codex 2026.10.5-beta.4 → 2026.10.10-beta.1

package/dist/.setup/{command-handlers-fiYvYYq0.mjs → command-handlers-tfb5Uq-O.mjs}

@@ -1,37 +1,38 @@
-import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
-import { m as sessionBindingIdentity, n as assertCodexBindingMayBeReplaced, r as bindingStoreKey } from "./session-binding-record-DU_0biMD.mjs";
+import { r as isJsonObject } from "./protocol-CaPAVwe9.mjs";
+import { g as sessionBindingIdentity, n as assertCodexBindingMayBeReplaced, r as bindingStoreKey } from "./session-binding-record-C_THntMe.mjs";
 import { r as isCodexFastServiceTier } from "./config-utils-DN_YT7dE.mjs";
-import { c as resolveCodexAppServerPreparedApiKeyCacheKey, s as resolveCodexAppServerFallbackApiKeyCacheKey } from "./auth-cache-key-f8ODJ_OX.mjs";
+import { c as resolveCodexAppServerPreparedApiKeyCacheKey, s as resolveCodexAppServerFallbackApiKeyCacheKey } from "./auth-cache-key-CVcYw8HD.mjs";
 import { n as withCodexConversationThreadActivity } from "./thread-ownership-queue-CeyYScUC.mjs";
 import { a as canMutateCodexHost, i as assertCodexHostOwnerCurrent, n as CODEX_HOST_INSPECTION_AUTH_ERROR, o as hasCodexAdminScope, r as CODEX_NATIVE_EXECUTION_AUTH_ERROR, t as CODEX_FULL_PERMISSIONS_AUTH_ERROR } from "./command-authorization-AikPDtcc.mjs";
-import { l as formatRelativeDuration, s as summarizeCodexAccountUsage } from "./rate-limits-CI8pTPqL.mjs";
-import { a as formatCodexAccountLine, c as formatCodexTextForDisplay, d as formatModels, f as formatSkills, i as formatAccount, l as formatComputerUseStatus, m as isLikelyEmailAddress, n as buildHelp, o as formatCodexDisplayText, p as formatThreads, r as escapeCodexChatText, s as formatCodexStatus, t as CODEX_RESUME_SAFE_THREAD_ID_PATTERN, u as formatList } from "./command-formatters-xW9KpoSZ.mjs";
-import { i as readCodexConversationBindingData, n as createCodexCliNodeConversationBindingData, o as resolveCodexDefaultWorkspaceDir, r as createCodexConversationBindingData } from "./conversation-binding-data-UgLuTSQT.mjs";
-import { r as CodexAppServerRpcError } from "./rpc-error-C98SHchT.mjs";
-import { t as CODEX_CONTROL_METHODS } from "./capabilities-DbOzOglY.mjs";
+import { l as formatRelativeDuration, s as summarizeCodexAccountUsage } from "./rate-limits-BpfURnuy.mjs";
+import { a as formatCodexAccountLine, c as formatCodexTextForDisplay, d as formatModels, f as formatSkills, i as formatAccount, l as formatComputerUseStatus, m as isLikelyEmailAddress, n as buildHelp, o as formatCodexDisplayText, p as formatThreads, r as escapeCodexChatText, s as formatCodexStatus, t as CODEX_RESUME_SAFE_THREAD_ID_PATTERN, u as formatList } from "./command-formatters-B_7-QZ1c.mjs";
+import { i as readCodexConversationBindingData, n as createCodexCliNodeConversationBindingData, o as resolveCodexDefaultWorkspaceDir, r as createCodexConversationBindingData } from "./conversation-binding-data-khgW0n-o.mjs";
+import { r as CodexAppServerRpcError } from "./rpc-error-DemqqaxE.mjs";
+import { t as CODEX_CONTROL_METHODS } from "./capabilities-DAS-JX1z.mjs";
 import { n as filterCodexMarketplacePlugins, r as parseCodexPluginMarketplaceId, t as discoverCodexMarketplacePlugins } from "./plugin-marketplace-discovery-BblHM3DU.mjs";
-import { o as formatCodexCliSessions } from "./node-cli-sessions-CzKg2nGq.mjs";
-import { a as defaultCodexAppInventoryCache, r as buildCodexPluginAppCacheKey } from "./plugin-app-cache-key-Bg9DbDI6.mjs";
-import { i as resolveCodexBindingAppServerConnection } from "./binding-connection-B7HAAZSI.mjs";
-import { a as withCodexAppServerJsonClient } from "./request-Bo0kKABI.mjs";
-import { n as findCodexMarketplacePluginSummary, o as pluginReadParams, r as isOpenAiCuratedMarketplaceName, u as CODEX_PLUGINS_MARKETPLACE_NAME } from "./plugin-inventory-CYgdo14P.mjs";
-import "./config-C1YVVLEA.mjs";
-import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-DWzK-k0n.mjs";
-import { a as resolveCodexAppServerAuthProfileStore, i as resolveCodexAppServerAuthProfileIdForAgent, n as normalizeCodexAppServerBindingModelProvider } from "./auth-profile-CgHQ8Vot.mjs";
-import { F as consumeCodexAppServerLiveThread, R as hasCodexAppServerLiveThread, c as getLeasedSharedCodexAppServerClient, h as releaseLeasedSharedCodexAppServerClient, tt as resolveCodexAppServerAuthAccountCacheKey } from "./shared-client-BCx1wbyA.mjs";
-import { a as isCodexAppServerIndeterminateRequestCancellationError, h as assertCodexThreadResumeResponse, p as assertCodexThreadAcceptsDirectInput, s as isCodexAppServerPrewriteRequestCancellationError } from "./client-D93nbdB8.mjs";
-import { o as closeCodexStartupClientBestEffort } from "./attempt-client-cleanup-zNuNTKVr.mjs";
-import { n as fingerprintCodexAppServerAuthBinding } from "./auth-binding-BaxlhaNx.mjs";
-import { n as listAllCodexAppServerModels } from "./models-BHpbAuz8.mjs";
-import { n as refreshCodexAppRuntimeState, r as refreshCodexPluginRuntimeState } from "./plugin-activation-D7WkJMvU.mjs";
-import { i as resolveCodexSessionBinding, n as createCodexSessionGenerationSupersededError } from "./session-binding-JEHNMPsr.mjs";
-import { a as rollbackCodexAppServerBindingSubscription, c as withExclusiveCodexAppServerThread, i as retireCodexConversationThreadBinding, n as releaseCodexAppServerBindingSubscription, r as retainCodexAppServerBindingSubscription, t as isSameCodexAppServerThreadOwner } from "./thread-ownership-BoUd0i6L.mjs";
-import { n as resolveCodexNativeSandboxBlock, t as resolveCodexNativeExecutionBlock } from "./sandbox-guard-DIImwCy1.mjs";
-import { i as assertCodexSupervisionThreadLineage } from "./thread-policy-B3wBRNph.mjs";
-import { t as defaultCodexPluginMetadataCache } from "./plugin-metadata-cache-Bi8TAPwX.mjs";
-import { n as installCodexComputerUse, r as readCodexComputerUseStatus } from "./computer-use-DL2v3Kxq.mjs";
-import { a as requestOptions, i as readCodexStatusProbes, o as safeCodexControlRequest, r as prepareCodexControlSessionAuth, t as codexControlRequest } from "./command-rpc-HIvsy3wS.mjs";
-import { a as readCodexConversationActiveTurn, c as setCodexConversationModel, d as stopCodexConversationTurn, i as parseCodexPermissionsModeArg, l as setCodexConversationPermissions, n as formatPermissionsMode, r as parseCodexFastModeArg, s as setCodexConversationFastMode, u as steerCodexConversationTurn } from "./conversation-control-GXM3unE4.mjs";
+import { o as formatCodexCliSessions } from "./node-cli-sessions-BuJnBnEq.mjs";
+import { a as defaultCodexAppInventoryCache, r as buildCodexPluginAppCacheKey } from "./plugin-app-cache-key-DRb-niJc.mjs";
+import { i as resolveCodexBindingAppServerConnection } from "./binding-connection-GTgUj9pi.mjs";
+import { a as withCodexAppServerJsonClient } from "./request-ePeNJrOd.mjs";
+import { n as findCodexMarketplacePluginSummary, o as pluginReadParams, r as isOpenAiCuratedMarketplaceName, u as CODEX_PLUGINS_MARKETPLACE_NAME } from "./plugin-inventory-DE9wcaeH.mjs";
+import "./config-BfrAlTMT.mjs";
+import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-BZRizyuG.mjs";
+import { a as resolveCodexAppServerAuthProfileStore, i as resolveCodexAppServerAuthProfileIdForAgent, n as normalizeCodexAppServerBindingModelProvider, r as resolveCodexAppServerAuthProfileId } from "./auth-profile-auwzSwwy.mjs";
+import { A as hasCodexAppServerLiveThread, D as consumeCodexAppServerLiveThread, Z as resolveCodexAppServerAuthAccountCacheKey, f as releaseLeasedSharedCodexAppServerClient, o as getLeasedSharedCodexAppServerClient } from "./shared-client-CE_uY0A1.mjs";
+import { f as assertCodexThreadAcceptsDirectInput, i as isCodexAppServerIndeterminateRequestCancellationError, m as assertCodexThreadResumeResponse, o as isCodexAppServerPrewriteRequestCancellationError } from "./client-BS8X7HmG.mjs";
+import { o as closeCodexStartupClientBestEffort } from "./attempt-client-cleanup-6OcbMH46.mjs";
+import { n as fingerprintCodexAppServerAuthBinding } from "./auth-binding-830RLAJW.mjs";
+import { n as listAllCodexAppServerModels } from "./models-BWLEUo2E.mjs";
+import { n as refreshCodexAppRuntimeState, r as refreshCodexPluginRuntimeState } from "./plugin-activation-CXPWe-hl.mjs";
+import { i as resolveCodexSessionBinding, n as createCodexSessionGenerationSupersededError } from "./session-binding-BgsWcbdY.mjs";
+import { a as rollbackCodexAppServerBindingSubscription, c as withExclusiveCodexAppServerThread, i as retireCodexConversationThreadBinding, n as releaseCodexAppServerBindingSubscription, r as retainCodexAppServerBindingSubscription, t as isSameCodexAppServerThreadOwner } from "./thread-ownership-t6Y9fLQS.mjs";
+import { n as prepareCodexNativeExecutionBlock, r as prepareCodexNativeSandboxBlock } from "./sandbox-guard-DneAfNye.mjs";
+import { i as assertCodexSupervisionThreadLineage } from "./thread-policy-Cy301Or8.mjs";
+import { t as defaultCodexPluginMetadataCache } from "./plugin-metadata-cache-BqC-a6Fb.mjs";
+import { n as installCodexComputerUse, r as readCodexComputerUseStatus } from "./computer-use-FqQ-Flbl.mjs";
+import { t as readCodexExperimentalFeature } from "./experimental-features-uGnVDtp-.mjs";
+import { a as requestOptions, i as readCodexStatusProbes, o as safeCodexControlRequest, r as prepareCodexControlSessionAuth, t as codexControlRequest } from "./command-rpc-SXqLQukR.mjs";
+import { a as readCodexConversationActiveTurn, c as setCodexConversationModel, d as stopCodexConversationTurn, i as parseCodexPermissionsModeArg, l as setCodexConversationPermissions, n as formatPermissionsMode, r as parseCodexFastModeArg, s as setCodexConversationFastMode, u as steerCodexConversationTurn } from "./conversation-control-B2EpVZEb.mjs";
 import { normalizeOptionalString, normalizeUniqueStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import crypto from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
@@ -42,20 +43,20 @@ import { coerceErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { isIncognitoSessionKey } from "openclaw/plugin-sdk/session-key-runtime";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
 import { parseAgentSessionKey } from "openclaw/plugin-sdk/routing";
-import { ensureAuthProfileStore, resolveAgentDir as resolveAgentDir$1, resolveAgentWorkspaceDir, resolveAuthProfileEligibility, resolveProfileUnusableUntilForDisplay } from "openclaw/plugin-sdk/agent-runtime";
-import { getSessionEntry, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
-import { findNormalizedProviderValue, resolveAuthProfileOrder } from "openclaw/plugin-sdk/provider-auth";
+import { ensureAuthProfileStoreAsync, resolveAgentDir as resolveAgentDir$1, resolveAgentWorkspaceDir, resolveAuthProfileEligibility, resolveProfileUnusableUntilForDisplay } from "openclaw/plugin-sdk/agent-runtime";
+import { getSessionEntryAsync, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
+import { ensureAuthProfileStore, findNormalizedProviderValue, resolveAuthProfileOrder } from "openclaw/plugin-sdk/provider-auth";
 import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
+import { captureSessionEntryCurrentCheckAsync, composeSessionEntryCommitGuards } from "openclaw/plugin-sdk/session-binding-runtime";
 import { renderMessagePresentationFallbackText } from "openclaw/plugin-sdk/interactive-runtime";
 import { MODEL_SELECTION_LOCKED_MESSAGE, isModelSelectionLocked, resolvePersistedSessionRuntimeId } from "openclaw/plugin-sdk/model-session-runtime";
-import { composeSessionEntryCommitGuards } from "openclaw/plugin-sdk/session-binding-runtime";
 //#region extensions/codex/src/command-account.ts
 const OPENAI_PROVIDER_ID = "openai";
 async function readCodexAccountAuthOverview(params) {
 	if (!params.account.ok && !params.limits.ok) return;
 	const config = params.ctx.config;
 	const agentDir = params.agentDir;
-	const store = ensureAuthProfileStore(agentDir, {
+	const store = await ensureAuthProfileStoreAsync(agentDir, {
 		allowKeychainPrompt: false,
 		config
 	});
@@ -394,22 +395,7 @@ function buildCodexCommandPickerPresentation(title, prompt, buttons) {
 async function readCodexHostedAppsSupport(context, account) {
 	if (account.status !== "known") return "unknown";
 	if (!isJsonObject(account.value.account) || account.value.account.type !== "chatgpt") return "sign_in_required";
-	const features = await readEvidence(async () => {
-		let cursor;
-		const visited = /* @__PURE__ */ new Set();
-		do {
-			const response = await context.request("experimentalFeature/list", {
-				...context.threadId ? { threadId: context.threadId } : {},
-				...cursor ? { cursor } : {},
-				limit: 100
-			});
-			const apps = response.data.find((feature) => feature.name === "apps");
-			if (apps) return apps.enabled;
-			cursor = response.nextCursor ?? void 0;
-			if (cursor && visited.has(cursor)) return;
-			if (cursor) visited.add(cursor);
-		} while (cursor);
-	});
+	const features = await readEvidence(() => readCodexExperimentalFeature((params) => context.request("experimentalFeature/list", params), "apps", context.threadId));
 	if (features.status !== "known") return features.reason === "unsupported" ? "unsupported" : "unknown";
 	return features.value === void 0 ? "unknown" : features.value ? "supported" : "disabled";
 }
@@ -1230,12 +1216,12 @@ async function resolveControlTarget(ctx) {
 	} : void 0;
 }
 async function resolvePreparedCodexCommandAuthority(deps, ctx) {
-	const target = await resolveControlTarget(ctx);
 	const fallback = resolveCodexConversationControlScope(ctx);
 	const sessionId = ctx.sessionId;
 	const sessionKey = ctx.sessionKey;
 	const sessionAgentId = ctx.sessionTarget?.agentId ?? fallback.agentId;
 	const storePath = ctx.sessionTarget?.storePath ?? (sessionKey ? resolveStorePath(ctx.config.session?.store, { agentId: sessionAgentId }) : void 0);
+	const target = await resolveControlTarget(ctx);
 	const sessionIdentity = sessionId ? sessionBindingIdentity({
 		sessionId,
 		sessionKey,
@@ -1249,71 +1235,98 @@ async function resolvePreparedCodexCommandAuthority(deps, ctx) {
 		config: ctx.config,
 		storePath
 	}) : void 0;
-	const assertHostCurrent = currentSession?.authority.assertLegacyCurrent ?? composeSessionEntryCommitGuards([]);
-	const binding = (target && (!sessionIdentity || !isDeepStrictEqual(target.identity, sessionIdentity)) ? await resolveCodexSessionBinding({
-		bindingStore: deps.bindingStore,
-		identity: target.identity,
-		config: ctx.config,
-		storePath,
-		assertCurrent: assertHostCurrent
-	}) : currentSession)?.binding;
-	const assertCurrent = composeSessionEntryCommitGuards([assertHostCurrent], (assertSource) => {
-		assertSource();
-		if (target && !isDeepStrictEqual(deps.bindingStore.read(target.identity), binding)) throw new Error("Codex command binding changed before dispatch");
-		assertSource();
-	});
-	assertCurrent();
-	return {
-		target,
-		binding,
-		currentSessionBinding: currentSession?.binding,
-		sessionId,
-		sessionKey,
-		storePath,
-		assertHostCurrent,
-		assertCurrent,
-		assertMutationCurrent: composeSessionEntryCommitGuards([assertCurrent], (assertSource) => {
-			assertCodexHostOwnerCurrent(ctx);
+	let resolvedTarget = currentSession;
+	const release = () => {
+		if (resolvedTarget !== currentSession) resolvedTarget?.release();
+		currentSession?.release();
+	};
+	try {
+		const assertHostCurrent = currentSession?.authority.assertLegacyCurrent ?? composeSessionEntryCommitGuards([]);
+		resolvedTarget = target && (!sessionIdentity || !isDeepStrictEqual(target.identity, sessionIdentity)) ? await resolveCodexSessionBinding({
+			bindingStore: deps.bindingStore,
+			identity: target.identity,
+			config: ctx.config,
+			storePath,
+			assertCurrent: assertHostCurrent
+		}) : currentSession;
+		const binding = resolvedTarget?.binding;
+		const assertCurrent = composeSessionEntryCommitGuards([assertHostCurrent], (assertSource) => {
 			assertSource();
-		}),
-		assertHostMutationCurrent: composeSessionEntryCommitGuards([assertHostCurrent], (assertSource) => {
-			assertCodexHostOwnerCurrent(ctx);
+			if (target && !isDeepStrictEqual(deps.bindingStore.read(target.identity), binding)) throw new Error("Codex command binding changed before dispatch");
 			assertSource();
-		})
-	};
+		});
+		assertCurrent();
+		const assertCurrentAsync = async () => {
+			await ctx.assertNativePolicyCurrent?.();
+			await resolvedTarget?.authority.withCurrent(assertCurrent);
+			if (!resolvedTarget) assertCurrent();
+		};
+		return {
+			release,
+			target,
+			binding,
+			currentSessionBinding: currentSession?.binding,
+			sessionId,
+			sessionKey,
+			storePath,
+			assertHostCurrent,
+			assertCurrent,
+			assertCurrentAsync,
+			mutationSource: composeSessionEntryCommitGuards([assertCurrent, ctx.nativePolicySource]),
+			assertMutationCurrent: composeSessionEntryCommitGuards([assertCurrent], (assertSource) => {
+				assertCodexHostOwnerCurrent(ctx);
+				assertSource();
+			}),
+			assertHostMutationCurrent: composeSessionEntryCommitGuards([assertHostCurrent], (assertSource) => {
+				assertCodexHostOwnerCurrent(ctx);
+				assertSource();
+			})
+		};
+	} catch (error) {
+		release();
+		throw error;
+	}
 }
 async function resolveCommandAppServerContext(deps, ctx, pluginConfig) {
 	const authority = await resolvePreparedCodexCommandAuthority(deps, ctx);
-	const { target, binding } = authority;
-	const fallback = resolveCodexConversationControlScope(ctx);
-	const agentDir = target?.agentDir ?? fallback.agentDir;
-	const authProfileId = binding?.connectionScope === "supervision" ? void 0 : resolveCodexAppServerAuthProfileIdForAgent({
-		authProfileId: binding?.authProfileId ?? target?.requestedAuthProfileId,
-		agentDir,
-		config: ctx.config
-	});
-	const connection = await resolveCodexBindingAppServerConnection({
-		binding,
-		authProfileId,
-		pluginConfig,
-		agentDir,
-		config: ctx.config,
-		assertCurrent: authority.assertCurrent
-	});
-	return {
-		scope: {
-			agentId: target?.agentId ?? fallback.agentId,
+	try {
+		const { target, binding } = authority;
+		const fallback = resolveCodexConversationControlScope(ctx);
+		const agentDir = target?.agentDir ?? fallback.agentDir;
+		const authProfileId = binding?.connectionScope === "supervision" ? void 0 : await resolveCodexAppServerAuthProfileIdForAgent({
+			authProfileId: binding?.authProfileId ?? target?.requestedAuthProfileId,
 			agentDir,
-			...connection.clientAuthProfileId !== void 0 ? { authProfileId: connection.clientAuthProfileId } : {},
-			...connection.usesSupervisionConnection ? { startOptions: connection.appServer.start } : {},
-			...authority.sessionKey ? { sessionKey: authority.sessionKey } : {},
-			...authority.sessionId ? { sessionId: authority.sessionId } : {},
-			...authority.storePath ? { storePath: authority.storePath } : {},
-			assertCurrent: authority.assertCurrent
-		},
-		target,
-		binding
-	};
+			config: ctx.config
+		});
+		const connection = await resolveCodexBindingAppServerConnection({
+			binding,
+			authProfileId,
+			pluginConfig,
+			agentDir,
+			config: ctx.config,
+			assertCurrent: authority.assertCurrent,
+			assertCurrentAsync: authority.assertCurrentAsync
+		});
+		return {
+			scope: {
+				agentId: target?.agentId ?? fallback.agentId,
+				agentDir,
+				...connection.clientAuthProfileId !== void 0 ? { authProfileId: connection.clientAuthProfileId } : {},
+				...connection.usesSupervisionConnection ? { startOptions: connection.appServer.start } : {},
+				...authority.sessionKey ? { sessionKey: authority.sessionKey } : {},
+				...authority.sessionId ? { sessionId: authority.sessionId } : {},
+				...authority.storePath ? { storePath: authority.storePath } : {},
+				assertCurrent: authority.assertCurrent,
+				assertCurrentAsync: authority.assertCurrentAsync,
+				release: authority.release
+			},
+			target,
+			binding
+		};
+	} catch (error) {
+		authority.release();
+		throw error;
+	}
 }
 async function resolveCommandAppServerScope(deps, ctx, pluginConfig) {
 	return (await resolveCommandAppServerContext(deps, ctx, pluginConfig)).scope;
@@ -1426,7 +1439,10 @@ async function confirmCodexDiagnosticsFeedback(deps, ctx, pluginConfig, token) {
 	const pending = consumeCodexDiagnosticsConfirmation(ctx, token, "confirm");
 	if (typeof pending === "string") return pending;
 	if (!pending.privateRouted && !await hasAnyCodexDiagnosticsIdentity(ctx)) return "Cannot send Codex diagnostics because this command did not include a stable session identity.";
-	const currentTargets = pending.privateRouted ? resolvePendingCodexDiagnosticsTargets(deps, pending.targets, ctx.config) : await resolveCodexDiagnosticsTargets(deps, ctx);
+	const currentTargets = pending.privateRouted ? (await Promise.all(pending.targets.map(async (target) => {
+		const binding = await deps.bindingStore.readAsync(target.identity);
+		return binding?.threadId ? [await resolveCodexDiagnosticsTarget(target, binding, ctx.config)] : [];
+	}))).flat() : await resolveCodexDiagnosticsTargets(deps, ctx);
 	if (!codexDiagnosticsTargetsMatch(pending.targets, currentTargets)) return "The Codex diagnostics sessions changed before confirmation. Run /diagnostics again for the current threads.";
 	return await sendCodexDiagnosticsFeedbackForTargets(deps, ctx, pluginConfig, pending.note ?? "", currentTargets, pending.scopeKey);
 }
@@ -1558,20 +1574,38 @@ async function resolveCodexDiagnosticsTargets(deps, ctx) {
 		const key = bindingStoreKey(candidate.identity);
 		if (seenBindingKeys.has(key)) continue;
 		seenBindingKeys.add(key);
-		const binding = deps.bindingStore.read(candidate.identity);
+		const binding = await deps.bindingStore.readAsync(candidate.identity);
 		if (!binding?.threadId || seenThreadIds.has(binding.threadId)) continue;
 		seenThreadIds.add(binding.threadId);
-		targets.push(resolveCodexDiagnosticsTarget(candidate, binding, ctx.config));
+		targets.push(await resolveCodexDiagnosticsTarget(candidate, binding, ctx.config));
 	}
 	return targets;
 }
 function resolvePendingCodexDiagnosticsTargets(deps, targets, config) {
 	return targets.flatMap((target) => {
 		const binding = deps.bindingStore.read(target.identity);
-		return binding?.threadId ? [resolveCodexDiagnosticsTarget(target, binding, config)] : [];
+		if (!binding?.threadId) return [];
+		return [createCodexDiagnosticsTarget(target, binding, binding.connectionScope === "supervision" ? void 0 : binding.authProfileId?.trim() || resolveCodexAppServerAuthProfileId({
+			authProfileId: binding.authProfileId,
+			config,
+			store: ensureAuthProfileStore(target.agentDir, {
+				profileId: binding.authProfileId,
+				allowKeychainPrompt: false,
+				config,
+				externalCliProviderIds: ["openai"],
+				...binding.authProfileId ? { externalCliProfileIds: [binding.authProfileId] } : {}
+			})
+		}))];
 	});
 }
-function resolveCodexDiagnosticsTarget(target, binding, config) {
+async function resolveCodexDiagnosticsTarget(target, binding, config) {
+	return createCodexDiagnosticsTarget(target, binding, binding.connectionScope === "supervision" ? void 0 : await resolveCodexAppServerAuthProfileIdForAgent({
+		authProfileId: binding.authProfileId,
+		agentDir: target.agentDir,
+		config
+	}));
+}
+function createCodexDiagnosticsTarget(target, binding, authProfileId) {
 	const candidate = {
 		identity: target.identity,
 		agentDir: target.agentDir,
@@ -1590,11 +1624,6 @@ function resolveCodexDiagnosticsTarget(target, binding, config) {
 		appServerRuntimeFingerprint: binding.appServerRuntimeFingerprint,
 		pendingSupervisionBranch: binding.pendingSupervisionBranch
 	};
-	const authProfileId = resolveCodexAppServerAuthProfileIdForAgent({
-		authProfileId: binding.authProfileId,
-		agentDir: target.agentDir,
-		config
-	});
 	return {
 		...candidate,
 		threadId: binding.threadId,
@@ -1603,12 +1632,12 @@ function resolveCodexDiagnosticsTarget(target, binding, config) {
 }
 //#endregion
 //#region extensions/codex/src/command-handler-bindings.ts
-function isCurrentSessionModelSelectionLocked(ctx) {
+async function isCurrentSessionModelSelectionLocked(ctx) {
 	const sessionKey = ctx.sessionKey?.trim();
 	if (!sessionKey) return false;
 	const { agentId } = resolveCodexConversationControlScope(ctx);
 	const storePath = ctx.sessionTarget?.storePath ?? resolveStorePath(ctx.config.session?.store, { agentId });
-	return isModelSelectionLocked(getSessionEntry({
+	return isModelSelectionLocked(await getSessionEntryAsync({
 		storePath,
 		sessionKey,
 		hydrateSkillPromptRefs: false,
@@ -1618,7 +1647,7 @@ function isCurrentSessionModelSelectionLocked(ctx) {
 async function bindConversation(deps, ctx, pluginConfig, args) {
 	const parsed = parseBindArgs(args);
 	if (parsed.help) return { text: "Usage: /codex bind [thread-id] [--cwd <path>] [--model <model>] [--provider <provider>]" };
-	if (isCurrentSessionModelSelectionLocked(ctx)) return { text: MODEL_SELECTION_LOCKED_MESSAGE };
+	if (await isCurrentSessionModelSelectionLocked(ctx)) return { text: MODEL_SELECTION_LOCKED_MESSAGE };
 	const scope = resolveCodexConversationControlScope(ctx);
 	const workspaceDir = parsed.cwd ?? deps.resolveCodexDefaultWorkspaceDir(pluginConfig);
 	const currentConversation = await ctx.getCurrentConversationBinding();
@@ -1631,12 +1660,13 @@ async function bindConversation(deps, ctx, pluginConfig, args) {
 		config: ctx.config
 	}) : void 0;
 	const currentOwner = currentConversationData?.kind === "codex-app-server-session" ? conversationBindingIdentity(currentConversationData.bindingId) : sessionOwner;
-	const existingBinding = currentOwner ? deps.bindingStore.read(currentOwner) : void 0;
+	const existingBinding = currentOwner ? await deps.bindingStore.readAsync(currentOwner) : void 0;
 	assertCodexBindingMayBeReplaced(existingBinding, "binding this conversation to another thread");
 	const sessionSource = sessionOwner && existingBinding ? {
 		agentId: sessionOwner.agentId,
 		sessionId: sessionOwner.sessionId,
 		threadId: existingBinding.threadId,
+		storePath: ctx.sessionTarget?.storePath ?? resolveStorePath(ctx.config.session?.store, { agentId: sessionOwner.agentId }),
 		...sessionOwner.sessionKey ? { sessionKey: sessionOwner.sessionKey } : {}
 	} : void 0;
 	const authProfileId = existingBinding?.authProfileId;
@@ -1655,6 +1685,7 @@ async function bindConversation(deps, ctx, pluginConfig, args) {
 		}
 	});
 	const threadLabel = parsed.threadId ?? "a new thread";
+	await ctx.assertNativePolicyCurrent?.();
 	assertCodexHostOwnerCurrent(ctx);
 	const request = await ctx.requestConversationBinding({
 		summary: `Codex app-server thread ${formatCodexDisplayText(threadLabel)} in ${formatCodexDisplayText(workspaceDir)}`,
@@ -1666,7 +1697,7 @@ async function bindConversation(deps, ctx, pluginConfig, args) {
 	return { text: `Bound this conversation to ${formatCodexDisplayText(threadLabel)} in ${formatCodexDisplayText(workspaceDir)}. The next message will initialize it.` };
 }
 async function detachConversation(deps, ctx) {
-	if (isCurrentSessionModelSelectionLocked(ctx)) return MODEL_SELECTION_LOCKED_MESSAGE;
+	if (await isCurrentSessionModelSelectionLocked(ctx)) return MODEL_SELECTION_LOCKED_MESSAGE;
 	const current = await ctx.getCurrentConversationBinding();
 	const data = readCodexConversationBindingData(current);
 	const identity = data?.kind === "codex-app-server-session" ? conversationBindingIdentity(data.bindingId) : void 0;
@@ -1674,7 +1705,7 @@ async function detachConversation(deps, ctx) {
 	let expectedThreadId;
 	let expectedStartId;
 	if (data?.kind === "codex-app-server-session") {
-		const binding = deps.bindingStore.read(identity);
+		const binding = await deps.bindingStore.readAsync(identity);
 		assertCodexBindingMayBeReplaced(binding, "detaching its conversation binding");
 		if (deps.readCodexConversationActiveTurn(identity)) return "This Codex conversation has an active run; use /codex stop before detaching it.";
 		expectedThreadId = binding?.threadId;
@@ -1698,6 +1729,7 @@ async function detachConversation(deps, ctx) {
 		})) return "This Codex conversation binding changed while detaching; try again.";
 		return detachedPublicConversation;
 	});
+	await ctx.assertNativePolicyCurrent?.();
 	assertCodexHostOwnerCurrent(ctx);
 	return await detachPublicConversation();
 }
@@ -1714,11 +1746,11 @@ async function describeConversationBinding(deps, ctx) {
 		"- Active run: not tracked"
 	].join("\n");
 	const identity = conversationBindingIdentity(data.bindingId);
-	const threadBinding = deps.bindingStore.read(identity);
+	const threadBinding = await deps.bindingStore.readAsync(identity);
 	const active = deps.readCodexConversationActiveTurn(identity);
 	const sessionKey = ctx.sessionKey?.trim();
 	const { agentId } = resolveCodexConversationControlScope(ctx);
-	const sessionEntry = sessionKey ? getSessionEntry({
+	const sessionEntry = sessionKey ? await getSessionEntryAsync({
 		agentId,
 		storePath: ctx.sessionTarget?.storePath ?? resolveStorePath(ctx.config.session?.store, { agentId }),
 		sessionKey,
@@ -1739,6 +1771,7 @@ async function describeConversationBinding(deps, ctx) {
 }
 async function buildThreads(deps, ctx, pluginConfig, filter) {
 	const scope = await resolveCommandAppServerScope(deps, ctx, pluginConfig);
+	using _ = { [Symbol.dispose]: scope.release };
 	const response = await deps.codexControlRequest(pluginConfig, CODEX_CONTROL_METHODS.listThreads, {
 		limit: 10,
 		...filter.trim() ? { searchTerm: filter.trim() } : {}
@@ -1763,7 +1796,7 @@ async function resumeThread(deps, ctx, pluginConfig, args) {
 	if (parsed.help) return args.includes("--help") || args.includes("-h") || parsed.host ? "Usage: /codex resume <thread-id>\nUsage: /codex resume <session-id> --host <node> --bind here" : "Usage: /codex resume <thread-id>";
 	if (parsed.host) return await bindCodexCliNodeSession(deps, ctx, parsed);
 	if (!normalizedThreadId || args.length !== 1) return "Usage: /codex resume <thread-id>";
-	if (isCurrentSessionModelSelectionLocked(ctx)) return MODEL_SELECTION_LOCKED_MESSAGE;
+	if (await isCurrentSessionModelSelectionLocked(ctx)) return MODEL_SELECTION_LOCKED_MESSAGE;
 	if (!ctx.sessionId) return "Cannot attach a Codex thread because this command did not include an OpenClaw session id.";
 	const scope = resolveCodexConversationControlScope(ctx);
 	const identity = sessionBindingIdentity({
@@ -1772,13 +1805,14 @@ async function resumeThread(deps, ctx, pluginConfig, args) {
 		agentId: scope.agentId,
 		config: ctx.config
 	});
-	const { authority } = await resolveCodexSessionBinding({
+	const { authority, release } = await resolveCodexSessionBinding({
 		reclaimStale: true,
 		bindingStore: deps.bindingStore,
 		identity,
 		config: ctx.config,
 		storePath: ctx.sessionTarget?.storePath
 	});
+	using _ = { [Symbol.dispose]: release };
 	const assertHostGeneration = authority.assertLegacyCurrent;
 	return await withExclusiveCodexAppServerThread({
 		bindingStore: deps.bindingStore,
@@ -1788,16 +1822,16 @@ async function resumeThread(deps, ctx, pluginConfig, args) {
 			const generation = await deps.bindingStore.prepareSessionGenerationReclaim(identity);
 			assertHostGeneration();
 			if (generation.kind !== "resolved" || !generation.result) throw createCodexSessionGenerationSupersededError(identity.sessionId);
-			const currentBinding = deps.bindingStore.read(identity);
+			const currentBinding = await deps.bindingStore.readAsync(identity);
 			assertCodexBindingMayBeReplaced(currentBinding, "attaching a different resumed thread");
 			let pendingResumeConfiguration = false;
-			const commitResumedThread = async (value, client, { authProfileId, assertCurrent }) => {
+			const commitResumedThread = async (value, client, { authProfileId, assertCurrent, assertCurrentAsync, source }) => {
 				const response = assertCodexThreadResumeResponse(value);
 				const effectiveThreadId = response.thread.id;
 				if (effectiveThreadId !== normalizedThreadId) throw new Error(`Codex thread/resume returned ${effectiveThreadId} for ${normalizedThreadId}`);
 				const resumedCwd = response.thread.cwd;
 				if (typeof resumedCwd !== "string") throw new Error(`Codex thread/resume returned no cwd for ${normalizedThreadId}`);
-				const modelProvider = normalizeCodexAppServerBindingModelProvider({
+				const modelProvider = await normalizeCodexAppServerBindingModelProvider({
 					authProfileId,
 					modelProvider: response.modelProvider ?? void 0,
 					agentDir: scope.agentDir,
@@ -1808,7 +1842,7 @@ async function resumeThread(deps, ctx, pluginConfig, args) {
 				let sameOwner = false;
 				let knownOwnership;
 				try {
-					const bindingBeforeCommit = deps.bindingStore.read(identity);
+					const bindingBeforeCommit = await deps.bindingStore.readAsync(identity);
 					assertCodexBindingMayBeReplaced(bindingBeforeCommit, "committing a different resumed thread");
 					sameOwner = isSameCodexAppServerThreadOwner(bindingBeforeCommit, {
 						threadId: effectiveThreadId,
@@ -1816,6 +1850,7 @@ async function resumeThread(deps, ctx, pluginConfig, args) {
 					});
 					const sameThreadBinding = bindingBeforeCommit?.threadId === effectiveThreadId ? bindingBeforeCommit : void 0;
 					pendingResumeConfiguration = sameThreadBinding?.preserveNativeModel !== true && (!sameThreadBinding?.dynamicToolsFingerprint || !sameThreadBinding.webSearchThreadConfigFingerprint || sameThreadBinding.pendingResumeConfiguration === true);
+					await assertCurrentAsync?.();
 					assertCurrent();
 					assertCodexThreadAcceptsDirectInput(response.thread);
 					knownOwnership = sameOwner ? await consumeCodexAppServerLiveThread(client, effectiveThreadId) : void 0;
@@ -1825,6 +1860,11 @@ async function resumeThread(deps, ctx, pluginConfig, args) {
 					if (!retained) throw new Error("Codex resumed thread lost its native subscription owner.");
 					if (bindingBeforeCommit && !sameOwner) await releaseCodexAppServerBindingSubscription(bindingBeforeCommit, {
 						assertCurrent,
+						withCurrent: async (write) => {
+							await assertCurrentAsync?.();
+							assertCurrent();
+							write();
+						},
 						retainedClientId: clientId
 					});
 					assertCurrent();
@@ -1842,7 +1882,11 @@ async function resumeThread(deps, ctx, pluginConfig, args) {
 							modelProvider,
 							historyCoveredThrough: (/* @__PURE__ */ new Date()).toISOString()
 						}
-					}, assertCurrent)) throw new Error("Codex thread binding changed while attaching the resumed thread.");
+					}, composeSessionEntryCommitGuards([
+						assertCurrent,
+						source,
+						ctx.nativePolicySource
+					]))) throw new Error("Codex thread binding changed while attaching the resumed thread.");
 				} catch (error) {
 					if (sameOwner && knownOwnership && !retained) {
 						if (!await retainCodexAppServerBindingSubscription(client, effectiveThreadId, knownOwnership)) await closeCodexStartupClientBestEffort(client);
@@ -1862,6 +1906,7 @@ async function resumeThread(deps, ctx, pluginConfig, args) {
 				sessionId: ctx.sessionId,
 				storePath: ctx.sessionTarget?.storePath,
 				assertCurrent: assertHostGeneration,
+				assertCurrentAsync: ctx.assertNativePolicyCurrent,
 				assertOwnerCurrent: () => assertCodexHostOwnerCurrent(ctx),
 				beforeRequest: async (request) => {
 					const { thread } = await request({
@@ -1881,10 +1926,10 @@ async function resumeThread(deps, ctx, pluginConfig, args) {
 }
 async function bindCodexCliNodeSession(deps, ctx, parsed) {
 	if (!parsed.threadId || !parsed.host || parsed.bindHere !== true) return "Usage: /codex resume <session-id> --host <node> --bind here";
-	if (isCurrentSessionModelSelectionLocked(ctx)) return MODEL_SELECTION_LOCKED_MESSAGE;
+	if (await isCurrentSessionModelSelectionLocked(ctx)) return MODEL_SELECTION_LOCKED_MESSAGE;
 	if (ctx.sessionId) {
 		const scope = resolveCodexConversationControlScope(ctx);
-		const binding = deps.bindingStore.read(sessionBindingIdentity({
+		const binding = await deps.bindingStore.readAsync(sessionBindingIdentity({
 			sessionId: ctx.sessionId,
 			sessionKey: ctx.sessionKey,
 			agentId: scope.agentId,
@@ -1907,6 +1952,7 @@ async function bindCodexCliNodeSession(deps, ctx, parsed) {
 		cwd: resolved.session?.cwd
 	});
 	const summary = `Codex CLI session ${formatCodexDisplayText(parsed.threadId)} on ${formatCodexDisplayText(nodeId)}`;
+	await ctx.assertNativePolicyCurrent?.();
 	assertCodexHostOwnerCurrent(ctx);
 	const request = await ctx.requestConversationBinding({
 		summary,
@@ -1936,21 +1982,71 @@ const CODEX_NATIVE_CONTROL_SUBCOMMANDS = /* @__PURE__ */ new Set([
 	"unbind",
 	"stop"
 ]);
-function resolveCodexNativeCommandSandboxBlock(ctx, subcommand, args) {
-	if (isReadOnlyCodexGoalCommand(subcommand, args) || !CODEX_NATIVE_EXECUTION_SUBCOMMANDS.has(subcommand) || returnsBeforeNativeCodexExecution(subcommand, args)) return;
-	if (isCodexCliNodeResumeBind(subcommand, args)) return resolveCodexNativeSandboxBlock({
-		config: ctx.config,
-		sessionKey: ctx.sessionKey,
-		sessionId: ctx.sessionId,
-		surface: `/${["codex", subcommand].join(" ")}`
-	});
-	return resolveCodexNativeExecutionBlock({
-		config: ctx.config,
-		agentId: ctx.agentId,
-		sessionKey: ctx.sessionKey,
-		sessionId: ctx.sessionId,
-		surface: `/${["codex", subcommand].join(" ")}`
-	});
+async function resolveCodexNativeCommandSandboxBlock(ctx, subcommand, args) {
+	if (isReadOnlyCodexGoalCommand(subcommand, args) || returnsBeforeNativeCodexExecution(subcommand, args)) return {
+		block: void 0,
+		async assertCurrent() {},
+		release() {}
+	};
+	const sessionKey = ctx.sessionTarget?.sessionKey ?? ctx.sessionKey;
+	const checksModelLock = [
+		"bind",
+		"resume",
+		"detach",
+		"unbind",
+		"model"
+	].includes(subcommand);
+	if (!checksModelLock && !CODEX_NATIVE_EXECUTION_SUBCOMMANDS.has(subcommand)) return {
+		block: void 0,
+		async assertCurrent() {},
+		release() {}
+	};
+	const agentId = ctx.sessionTarget?.agentId ?? resolveCodexConversationControlScope(ctx).agentId;
+	const storePath = ctx.sessionTarget?.storePath ?? resolveStorePath(ctx.config.session?.store, { agentId });
+	const modelCurrent = checksModelLock && sessionKey ? await captureSessionEntryCurrentCheckAsync({
+		agentId,
+		storePath,
+		sessionKey,
+		fields: ["modelSelectionLocked"]
+	}) : void 0;
+	if (!CODEX_NATIVE_EXECUTION_SUBCOMMANDS.has(subcommand)) return {
+		block: void 0,
+		assertCurrent: modelCurrent?.assertCurrent ?? (async () => {}),
+		source: modelCurrent?.source,
+		release: modelCurrent?.release ?? (() => {})
+	};
+	let execution;
+	try {
+		const surface = `/${["codex", subcommand].join(" ")}`;
+		execution = isCodexCliNodeResumeBind(subcommand, args) ? await prepareCodexNativeSandboxBlock({
+			config: ctx.config,
+			sessionKey: ctx.sessionKey,
+			sessionId: ctx.sessionId,
+			surface
+		}) : await prepareCodexNativeExecutionBlock({
+			config: ctx.config,
+			agentId: ctx.agentId,
+			sessionKey,
+			sessionId: ctx.sessionId,
+			storePath,
+			surface
+		});
+	} catch (error) {
+		modelCurrent?.release();
+		throw error;
+	}
+	return {
+		block: execution.block,
+		source: composeSessionEntryCommitGuards([modelCurrent?.source, execution.source]),
+		assertCurrent: async () => {
+			await modelCurrent?.assertCurrent();
+			await execution.assertCurrent();
+		},
+		release: () => {
+			modelCurrent?.release();
+			execution.release();
+		}
+	};
 }
 function isReadOnlyCodexGoalCommand(subcommand, args) {
 	if (subcommand !== "goal" || args.length > 1) return false;
@@ -2006,6 +2102,7 @@ async function handleNativeGoal(deps, ctx, pluginConfig, args) {
 	const action = (args[0] ?? "status").toLowerCase();
 	const objective = args.slice(1).join(" ").trim();
 	const authority = await resolvePreparedCodexCommandAuthority(deps, ctx);
+	using _ = { [Symbol.dispose]: authority.release };
 	const { target, binding } = authority;
 	if (!target) return "Cannot manage the Codex goal because this command has no stable binding identity.";
 	if (!binding?.threadId) return "No Codex thread is attached to this OpenClaw session yet.";
@@ -2015,7 +2112,8 @@ async function handleNativeGoal(deps, ctx, pluginConfig, args) {
 		pluginConfig,
 		agentDir: target.agentDir,
 		config: ctx.config,
-		assertCurrent: authority.assertCurrent
+		assertCurrent: authority.assertCurrent,
+		assertCurrentAsync: authority.assertCurrentAsync
 	});
 	const goalRequestOptions = {
 		agentDir: target.agentDir,
@@ -2025,6 +2123,7 @@ async function handleNativeGoal(deps, ctx, pluginConfig, args) {
 		sessionKey: authority.sessionKey,
 		storePath: authority.storePath,
 		assertCurrent: authority.assertCurrent,
+		assertCurrentAsync: authority.assertCurrentAsync,
 		...connection.usesSupervisionConnection ? { startOptions: connection.appServer.start } : {}
 	};
 	if (action === "status" || action === "get" || action === "clear") {
@@ -2066,12 +2165,14 @@ function formatNativeGoal(response) {
 }
 async function controlConversationTurn(deps, ctx, command, message) {
 	const authority = await resolvePreparedCodexCommandAuthority(deps, ctx);
+	using _ = { [Symbol.dispose]: authority.release };
 	const { target, binding } = authority;
 	if (!target) return `Cannot ${command} Codex because this command did not include a stable binding identity.`;
 	const params = {
 		identity: target.identity,
 		binding,
-		assertCurrent: authority.assertMutationCurrent
+		assertCurrent: authority.assertMutationCurrent,
+		assertCurrentAsync: authority.assertCurrentAsync
 	};
 	return (command === "stop" ? await deps.stopCodexConversationTurn(params) : await deps.steerCodexConversationTurn({
 		...params,
@@ -2082,12 +2183,13 @@ async function setConversationModel(deps, ctx, args) {
 	if (args.length > 1) return "Usage: /codex model <model>";
 	const [model = ""] = args;
 	const normalized = model.trim();
-	if (normalized && isCurrentSessionModelSelectionLocked(ctx)) return MODEL_SELECTION_LOCKED_MESSAGE;
+	if (normalized && await isCurrentSessionModelSelectionLocked(ctx)) return MODEL_SELECTION_LOCKED_MESSAGE;
 	const authority = await resolvePreparedCodexCommandAuthority(deps, ctx);
+	using _ = { [Symbol.dispose]: authority.release };
 	const { target, binding } = authority;
 	if (!target) return "Cannot set Codex model because this command did not include a stable binding identity.";
 	if (!normalized) {
-		const currentSession = authority.sessionId && authority.sessionKey && authority.storePath ? getSessionEntry({
+		const currentSession = authority.sessionId && authority.sessionKey && authority.storePath ? await getSessionEntryAsync({
 			storePath: authority.storePath,
 			sessionKey: authority.sessionKey,
 			hydrateSkillPromptRefs: false,
@@ -2107,13 +2209,15 @@ async function setConversationModel(deps, ctx, args) {
 		binding,
 		storePath: authority.storePath,
 		assertCurrent: authority.assertCurrent,
-		assertCommitAllowed: authority.assertMutationCurrent
+		assertCurrentAsync: authority.assertCurrentAsync,
+		assertCommitAllowed: composeSessionEntryCommitGuards([authority.mutationSource, authority.assertMutationCurrent])
 	});
 }
 async function setConversationPreference(deps, ctx, args, kind) {
 	const usage = `Usage: /codex ${kind} ${kind === "fast" ? "[on|off|status]" : "[default|yolo|status]"}`;
 	if (args.length > 1) return usage;
 	const authority = await resolvePreparedCodexCommandAuthority(deps, ctx);
+	using _ = { [Symbol.dispose]: authority.release };
 	const { target, binding } = authority;
 	if (kind === "fast") {
 		if (!target) return "Cannot set Codex fast mode because this command did not include a stable binding identity.";
@@ -2125,7 +2229,7 @@ async function setConversationPreference(deps, ctx, args, kind) {
 			bindingStore: deps.bindingStore,
 			binding,
 			enabled: parsed,
-			assertCurrent: parsed === void 0 ? authority.assertCurrent : authority.assertMutationCurrent
+			assertCurrent: parsed === void 0 ? authority.assertCurrent : composeSessionEntryCommitGuards([authority.mutationSource, authority.assertMutationCurrent])
 		});
 	}
 	if (!target || !ctx.sessionId || !ctx.sessionKey) return "Cannot set Codex permissions because this command did not include a complete session identity.";
@@ -2138,6 +2242,7 @@ async function setConversationPreference(deps, ctx, args, kind) {
 		config: ctx.config,
 		storePath: authority.storePath,
 		assertCurrent: parsed ? authority.assertHostMutationCurrent : authority.assertHostCurrent,
+		sourceAuthority: parsed ? composeSessionEntryCommitGuards([authority.mutationSource, authority.assertHostMutationCurrent]) : void 0,
 		session: {
 			agentId: target.agentId,
 			sessionId: ctx.sessionId,
@@ -2148,13 +2253,14 @@ async function setConversationPreference(deps, ctx, args, kind) {
 async function startThreadAction(deps, ctx, pluginConfig, kind, args) {
 	if (args.length > 0) return `Usage: /codex ${kind}`;
 	const authority = await resolvePreparedCodexCommandAuthority(deps, ctx);
+	using _ = { [Symbol.dispose]: authority.release };
 	const { target, binding } = authority;
 	if (!target) return `Cannot start Codex ${kind === "compact" ? "compaction" : "review"} because this command did not include a stable binding identity.`;
 	if (!binding?.threadId) return `No Codex thread is attached to this OpenClaw session yet.`;
 	if (kind === "compact") {
 		const sessionTarget = ctx.sessionTarget;
 		if (!ctx.sessionId || !ctx.sessionKey || !sessionTarget || sessionTarget.sessionId !== ctx.sessionId || sessionTarget.sessionKey !== ctx.sessionKey) return "Codex compaction is unavailable because this command is not bound to a complete session identity.";
-		const currentSession = getSessionEntry({
+		const currentSession = await getSessionEntryAsync({
 			storePath: authority.storePath ?? sessionTarget.storePath,
 			sessionKey: ctx.sessionKey,
 			hydrateSkillPromptRefs: false,
@@ -2166,6 +2272,7 @@ async function startThreadAction(deps, ctx, pluginConfig, kind, args) {
 		}
 		const compactCurrent = ctx.runtimeContext?.compactCurrent;
 		if (!compactCurrent) return "Codex compaction is unavailable because this command is not bound to a session.";
+		await authority.assertCurrentAsync();
 		authority.assertMutationCurrent();
 		const result = await compactCurrent();
 		return result.compacted ? `Compacted Codex session (${result.tokensAfter ?? "unknown"} tokens after).` : `Codex compaction did not complete: ${formatCodexDisplayText(result.reason ?? "no reason returned")}.`;
@@ -2176,7 +2283,8 @@ async function startThreadAction(deps, ctx, pluginConfig, kind, args) {
 		pluginConfig,
 		agentDir: target.agentDir,
 		config: ctx.config,
-		assertCurrent: authority.assertCurrent
+		assertCurrent: authority.assertCurrent,
+		assertCurrentAsync: authority.assertCurrentAsync
 	});
 	await deps.bindingStore.withLease(target.identity, () => deps.codexControlRequest(pluginConfig, CODEX_CONTROL_METHODS.review, {
 		threadId: binding.threadId,
@@ -2189,6 +2297,7 @@ async function startThreadAction(deps, ctx, pluginConfig, kind, args) {
 		sessionKey: authority.sessionKey,
 		storePath: authority.storePath,
 		assertCurrent: authority.assertCurrent,
+		assertCurrentAsync: authority.assertCurrentAsync,
 		assertOwnerCurrent: () => assertCodexHostOwnerCurrent(ctx),
 		...connection.usesSupervisionConnection ? {
 			startOptions: connection.appServer.start,
@@ -2613,8 +2722,8 @@ async function withCodexPluginCommandContext(params, run) {
 		gatewayClientScopes: params.ctx.gatewayClientScopes?.slice()
 	};
 	const current = await deps.codexPluginsManagementIo?.readConfig() ?? {};
-	const initialPolicy = JSON.stringify(current);
-	const { scope, target, binding } = await resolveCommandAppServerContext(deps, ctx, pluginConfig);
+	const { scope, binding } = await resolveCommandAppServerContext(deps, ctx, pluginConfig);
+	using _ = { [Symbol.dispose]: scope.release };
 	const conversation = readCodexConversationBindingData(await ctx.getCurrentConversationBinding());
 	const workspaceDir = binding?.cwd || (conversation?.kind === "codex-app-server-session" ? conversation.workspaceDir : void 0) || resolveAgentWorkspaceDir(ctx.config, scope.agentId);
 	const configuredRuntime = resolveCodexAppServerRuntimeOptions({ pluginConfig });
@@ -2626,102 +2735,108 @@ async function withCodexPluginCommandContext(params, run) {
 		...scope,
 		config: ctx.config
 	}, appServer.start);
-	const preparedAuth = "preparedAuth" in auth.clientOptions ? auth.clientOptions.preparedAuth : void 0;
-	const usesNativeAuth = scope.authProfileId === null || appServer.start.homeScope === "user";
-	const profileId = usesNativeAuth ? void 0 : auth.authProfileId;
-	const readAuthBinding = () => profileId ? fingerprintCodexAppServerAuthBinding({
-		authProfileId: profileId,
-		authProfileStore: resolveCodexAppServerAuthProfileStore({
+	try {
+		const { assertCurrentAsync } = {
+			assertCurrentAsync: scope.assertCurrentAsync,
+			...auth.clientOptions
+		};
+		const preparedAuth = "preparedAuth" in auth.clientOptions ? auth.clientOptions.preparedAuth : void 0;
+		const usesNativeAuth = scope.authProfileId === null || appServer.start.homeScope === "user";
+		const profileId = usesNativeAuth ? void 0 : auth.authProfileId;
+		const readAuthBinding = async () => profileId ? fingerprintCodexAppServerAuthBinding({
+			authProfileId: profileId,
+			authProfileStore: await resolveCodexAppServerAuthProfileStore({
+				authProfileId: profileId,
+				agentDir: scope.agentDir,
+				config: ctx.config
+			}),
+			agentDir: scope.agentDir,
+			config: ctx.config
+		}) : Promise.resolve(void 0);
+		const authBinding = "authBindingFingerprint" in auth.clientOptions ? auth.clientOptions.authBindingFingerprint : await readAuthBinding();
+		const accountId = usesNativeAuth ? void 0 : preparedAuth?.kind === "api-key" ? resolveCodexAppServerPreparedApiKeyCacheKey(preparedAuth.apiKey) : preparedAuth?.kind === "profile" ? preparedAuth.snapshot.secretFreeCacheKey : await resolveCodexAppServerAuthAccountCacheKey({
 			authProfileId: profileId,
 			agentDir: scope.agentDir,
 			config: ctx.config
-		}),
-		agentDir: scope.agentDir,
-		config: ctx.config
-	}) : Promise.resolve(void 0);
-	const authBinding = "authBindingFingerprint" in auth.clientOptions ? auth.clientOptions.authBindingFingerprint : await readAuthBinding();
-	const accountId = usesNativeAuth ? void 0 : preparedAuth?.kind === "api-key" ? resolveCodexAppServerPreparedApiKeyCacheKey(preparedAuth.apiKey) : preparedAuth?.kind === "profile" ? preparedAuth.snapshot.secretFreeCacheKey : await resolveCodexAppServerAuthAccountCacheKey({
-		authProfileId: profileId,
-		agentDir: scope.agentDir,
-		config: ctx.config
-	});
-	if (await readAuthBinding() !== authBinding) throw new Error(SCOPE_CHANGED_MESSAGE);
-	return await withCodexAppServerJsonClient({
-		startOptions: appServer.start,
-		pluginConfig,
-		agentDir: scope.agentDir,
-		config: ctx.config,
-		sessionId: ctx.sessionId,
-		sessionKey: ctx.sessionKey,
-		timeoutMs: appServer.requestTimeoutMs,
-		timeoutMessage: "Codex plugin request timed out. Check the Codex connection and retry.",
-		assertCurrent: scope.assertCurrent,
-		...auth.clientOptions
-	}, async (request, client, requestScope) => {
-		const assertCurrent = () => {
-			requestScope.assertCurrent();
-			if (client.getCloseError()) throw new Error(SCOPE_CHANGED_MESSAGE);
-		};
-		const validateCurrent = async () => {
-			assertCurrent();
-			const currentTarget = await resolveControlTarget(ctx);
-			const currentConversation = readCodexConversationBindingData(await ctx.getCurrentConversationBinding());
-			const currentPolicy = JSON.stringify(await deps.codexPluginsManagementIo?.readConfig() ?? {});
-			const currentAuthBinding = await readAuthBinding();
-			assertCurrent();
-			if (!isDeepStrictEqual(currentTarget, target) || !isDeepStrictEqual(currentConversation, conversation) || currentPolicy !== initialPolicy || currentAuthBinding !== authBinding) throw new Error(SCOPE_CHANGED_MESSAGE);
-		};
-		try {
-			await request({
-				method: "account/read",
-				requestParams: { refreshToken: false },
-				assertCurrent
-			});
-		} catch {
-			requestScope.assertCurrent();
-			throw new Error("Codex account startup could not be confirmed. Check /codex account and retry.");
-		}
-		const unsubscribe = client.addNotificationHandler((notification) => {
-			if (notification.method === "account/updated") requestScope.abort(/* @__PURE__ */ new Error(SCOPE_CHANGED_MESSAGE));
 		});
-		try {
-			await validateCurrent();
-			const result = await run({
-				request: async (method, requestParams) => {
-					await validateCurrent();
-					const response = await request({
-						method,
-						requestParams,
-						assertCurrent: () => {
-							assertCurrent();
-							assertCodexHostOwnerCurrent(ctx);
-						}
-					});
-					await validateCurrent();
-					return response;
-				},
-				workspaceDir,
-				agentId: scope.agentId,
-				current,
-				...profileId ? { profileId } : {},
-				...binding?.clientId === client.getInstanceId() ? { threadId: binding.threadId } : {},
-				appCacheKey: buildCodexPluginAppCacheKey({
-					appServer,
-					agentDir: scope.agentDir,
-					authProfileId: profileId,
-					accountId,
-					envApiKeyFingerprint: usesNativeAuth || preparedAuth || profileId ? void 0 : resolveCodexAppServerFallbackApiKeyCacheKey({ startOptions: appServer.start }),
-					appServerVersion: client.getServerVersion(),
-					runtimeIdentity: client.getRuntimeIdentity()
-				}),
-				validateCurrent
+		if (await readAuthBinding() !== authBinding) throw new Error(SCOPE_CHANGED_MESSAGE);
+		return await withCodexAppServerJsonClient({
+			startOptions: appServer.start,
+			pluginConfig,
+			agentDir: scope.agentDir,
+			config: ctx.config,
+			sessionId: ctx.sessionId,
+			sessionKey: ctx.sessionKey,
+			timeoutMs: appServer.requestTimeoutMs,
+			timeoutMessage: "Codex plugin request timed out. Check the Codex connection and retry.",
+			assertCurrent: scope.assertCurrent,
+			...auth.clientOptions
+		}, async (request, client, requestScope) => {
+			const assertCurrent = () => {
+				requestScope.assertCurrent();
+				if (client.getCloseError()) throw new Error(SCOPE_CHANGED_MESSAGE);
+			};
+			const validateCurrent = async () => {
+				assertCurrent();
+				const currentAuthBinding = await readAuthBinding();
+				await assertCurrentAsync?.();
+				assertCurrent();
+				if (currentAuthBinding !== authBinding) throw new Error(SCOPE_CHANGED_MESSAGE);
+			};
+			try {
+				await request({
+					method: "account/read",
+					requestParams: { refreshToken: false },
+					assertCurrent
+				});
+			} catch {
+				requestScope.assertCurrent();
+				throw new Error("Codex account startup could not be confirmed. Check /codex account and retry.");
+			}
+			const unsubscribe = client.addNotificationHandler((notification) => {
+				if (notification.method === "account/updated") requestScope.abort(/* @__PURE__ */ new Error(SCOPE_CHANGED_MESSAGE));
 			});
-			await validateCurrent();
-			return result;
-		} finally {
-			unsubscribe();
-		}
-	});
+			try {
+				await validateCurrent();
+				const result = await run({
+					request: async (method, requestParams) => {
+						await validateCurrent();
+						const response = await request({
+							method,
+							requestParams,
+							assertCurrent: () => {
+								assertCurrent();
+								assertCodexHostOwnerCurrent(ctx);
+							}
+						});
+						await validateCurrent();
+						return response;
+					},
+					workspaceDir,
+					agentId: scope.agentId,
+					current,
+					...profileId ? { profileId } : {},
+					...binding?.clientId === client.getInstanceId() ? { threadId: binding.threadId } : {},
+					appCacheKey: buildCodexPluginAppCacheKey({
+						appServer,
+						agentDir: scope.agentDir,
+						authProfileId: profileId,
+						accountId,
+						envApiKeyFingerprint: usesNativeAuth || preparedAuth || profileId ? void 0 : resolveCodexAppServerFallbackApiKeyCacheKey({ startOptions: appServer.start }),
+						appServerVersion: client.getServerVersion(),
+						runtimeIdentity: client.getRuntimeIdentity()
+					}),
+					validateCurrent
+				});
+				await validateCurrent();
+				return result;
+			} finally {
+				unsubscribe();
+			}
+		});
+	} finally {
+		auth.release();
+	}
 }
 //#endregion
 //#region extensions/codex/src/command-handlers.ts
@@ -2733,168 +2848,186 @@ const CODEX_HOST_INSPECTION_SUBCOMMANDS = /* @__PURE__ */ new Set([
 	"status",
 	"threads"
 ]);
-async function handleCodexSubcommand(ctx, options) {
+async function handleCodexSubcommand(inputCtx, options) {
 	const deps = resolveCodexCommandDeps(options.deps);
-	const args = splitArgs(ctx.args);
+	const args = splitArgs(inputCtx.args);
 	if (args.length === 0) return buildCodexSubcommandPickerReply();
 	const [subcommand = "status", ...rest] = args;
 	const normalized = subcommand.toLowerCase();
 	if (normalized === "help") return { text: buildHelp() };
-	if (CODEX_HOST_INSPECTION_SUBCOMMANDS.has(normalized) && !canMutateCodexHost(ctx)) return { text: CODEX_HOST_INSPECTION_AUTH_ERROR };
-	if (CODEX_NATIVE_CONTROL_SUBCOMMANDS.has(normalized) && !returnsBeforeNativeCodexExecution(normalized, rest) && !isReadOnlyCodexGoalCommand(normalized, rest) && !canMutateCodexHost(ctx)) return { text: CODEX_NATIVE_EXECUTION_AUTH_ERROR };
-	const sandboxBlock = resolveCodexNativeCommandSandboxBlock(ctx, normalized, rest);
-	if (sandboxBlock) return { text: sandboxBlock };
-	const usageCommand = normalized === "unbind" ? "detach" : normalized;
-	if (rest.length > 0 && [
-		"status",
-		"models",
-		"detach",
-		"binding",
-		"stop",
-		"mcp",
-		"skills",
-		"account"
-	].includes(usageCommand)) return { text: `Usage: /codex ${usageCommand}` };
-	if (normalized === "plugins") {
-		if (rest[0]?.toLowerCase() === "refresh") {
-			if (rest.length !== 1) return { text: "Usage: /codex plugins refresh — refresh hosted app inventory for the current Codex account/runtime." };
-			if (!canMutateCodexHost(ctx)) return { text: "Only an owner or operator.admin gateway client can refresh hosted app inventory." };
-			return await withCodexPluginCommandContext({
-				deps,
-				ctx,
-				pluginConfig: options.pluginConfig
-			}, (context) => refreshCodexHostedApps(context));
-		}
-		if (!deps.codexPluginsManagementIo) return { text: "Codex sub-plugin management is not wired up (codexPluginsManagementIo dep is undefined). Edit ~/.openclaw/openclaw.json or use `openclaw config patch` until the runtime exposes the IO." };
-		let appServerScope;
-		const getAppServerScope = () => appServerScope ??= resolveCommandAppServerScope(deps, ctx, options.pluginConfig);
-		return await handleCodexPluginsSubcommand(ctx, rest, deps.codexPluginsManagementIo, {
-			withContext: (run) => withCodexPluginCommandContext({
-				deps,
-				ctx,
-				pluginConfig: options.pluginConfig
-			}, run),
-			workspaceDir: async () => {
-				const data = readCodexConversationBindingData(await ctx.getCurrentConversationBinding());
-				return (data?.kind === "codex-app-server-session" ? data.workspaceDir : void 0)?.trim() || deps.resolveCodexDefaultWorkspaceDir(options.pluginConfig);
-			},
-			list: async (requestParams) => {
-				const scope = await getAppServerScope();
-				return await deps.codexControlRequest(options.pluginConfig, CODEX_CONTROL_METHODS.listPlugins, requestParams, {
-					...scope,
-					config: ctx.config
-				});
-			},
-			install: async (requestParams) => {
-				const scope = await getAppServerScope();
-				return await deps.codexControlRequest(options.pluginConfig, CODEX_CONTROL_METHODS.installPlugin, requestParams, {
-					...scope,
-					config: ctx.config,
-					assertOwnerCurrent: () => assertCodexHostOwnerCurrent(ctx)
-				});
-			},
-			refresh: async (workspaceDir) => {
-				const scope = await getAppServerScope();
-				const configuredAppServer = resolveCodexAppServerRuntimeOptions({ pluginConfig: options.pluginConfig });
-				const appServer = scope.startOptions ? {
-					...configuredAppServer,
-					start: scope.startOptions
-				} : configuredAppServer;
-				const authProfileId = scope.authProfileId ?? void 0;
-				const accountId = await resolveCodexAppServerAuthAccountCacheKey({
-					authProfileId,
-					agentDir: scope.agentDir,
-					config: ctx.config
-				});
-				const client = await getLeasedSharedCodexAppServerClient({
-					startOptions: appServer.start,
-					pluginConfig: options.pluginConfig,
-					authProfileId: scope.authProfileId,
-					agentDir: scope.agentDir,
-					config: ctx.config
-				});
-				try {
-					const appCacheKey = buildCodexPluginAppCacheKey({
-						appServer,
-						agentDir: scope.agentDir,
+	if (CODEX_HOST_INSPECTION_SUBCOMMANDS.has(normalized) && !canMutateCodexHost(inputCtx)) return { text: CODEX_HOST_INSPECTION_AUTH_ERROR };
+	if (CODEX_NATIVE_CONTROL_SUBCOMMANDS.has(normalized) && !returnsBeforeNativeCodexExecution(normalized, rest) && !isReadOnlyCodexGoalCommand(normalized, rest) && !canMutateCodexHost(inputCtx)) return { text: CODEX_NATIVE_EXECUTION_AUTH_ERROR };
+	const nativePolicy = await resolveCodexNativeCommandSandboxBlock(inputCtx, normalized, rest);
+	try {
+		if (nativePolicy.block) return { text: nativePolicy.block };
+		const previousPolicyCheck = inputCtx.assertNativePolicyCurrent;
+		const ctx = {
+			...inputCtx,
+			nativePolicySource: nativePolicy.source,
+			assertNativePolicyCurrent: async () => {
+				await previousPolicyCheck?.();
+				await nativePolicy.assertCurrent();
+			}
+		};
+		const usageCommand = normalized === "unbind" ? "detach" : normalized;
+		if (rest.length > 0 && [
+			"status",
+			"models",
+			"detach",
+			"binding",
+			"stop",
+			"mcp",
+			"skills",
+			"account"
+		].includes(usageCommand)) return { text: `Usage: /codex ${usageCommand}` };
+		if (normalized === "plugins") {
+			if (rest[0]?.toLowerCase() === "refresh") {
+				if (rest.length !== 1) return { text: "Usage: /codex plugins refresh — refresh hosted app inventory for the current Codex account/runtime." };
+				if (!canMutateCodexHost(ctx)) return { text: "Only an owner or operator.admin gateway client can refresh hosted app inventory." };
+				return await withCodexPluginCommandContext({
+					deps,
+					ctx,
+					pluginConfig: options.pluginConfig
+				}, (context) => refreshCodexHostedApps(context));
+			}
+			if (!deps.codexPluginsManagementIo) return { text: "Codex sub-plugin management is not wired up (codexPluginsManagementIo dep is undefined). Edit ~/.openclaw/openclaw.json or use `openclaw config patch` until the runtime exposes the IO." };
+			let appServerScope;
+			await using _ = { [Symbol.asyncDispose]: async () => {
+				await appServerScope?.then((scope) => scope.release(), () => {});
+			} };
+			const getAppServerScope = () => appServerScope ??= resolveCommandAppServerScope(deps, ctx, options.pluginConfig);
+			return await handleCodexPluginsSubcommand(ctx, rest, deps.codexPluginsManagementIo, {
+				withContext: (run) => withCodexPluginCommandContext({
+					deps,
+					ctx,
+					pluginConfig: options.pluginConfig
+				}, run),
+				workspaceDir: async () => {
+					const data = readCodexConversationBindingData(await ctx.getCurrentConversationBinding());
+					return (data?.kind === "codex-app-server-session" ? data.workspaceDir : void 0)?.trim() || deps.resolveCodexDefaultWorkspaceDir(options.pluginConfig);
+				},
+				list: async (requestParams) => {
+					const scope = await getAppServerScope();
+					return await deps.codexControlRequest(options.pluginConfig, CODEX_CONTROL_METHODS.listPlugins, requestParams, {
+						...scope,
+						config: ctx.config
+					});
+				},
+				install: async (requestParams) => {
+					const scope = await getAppServerScope();
+					return await deps.codexControlRequest(options.pluginConfig, CODEX_CONTROL_METHODS.installPlugin, requestParams, {
+						...scope,
+						config: ctx.config,
+						assertOwnerCurrent: () => assertCodexHostOwnerCurrent(ctx)
+					});
+				},
+				refresh: async (workspaceDir) => {
+					const scope = await getAppServerScope();
+					const configuredAppServer = resolveCodexAppServerRuntimeOptions({ pluginConfig: options.pluginConfig });
+					const appServer = scope.startOptions ? {
+						...configuredAppServer,
+						start: scope.startOptions
+					} : configuredAppServer;
+					const authProfileId = scope.authProfileId ?? void 0;
+					const accountId = await resolveCodexAppServerAuthAccountCacheKey({
 						authProfileId,
-						accountId,
-						envApiKeyFingerprint: authProfileId ? void 0 : resolveCodexAppServerFallbackApiKeyCacheKey({ startOptions: appServer.start }),
-						appServerVersion: client.getServerVersion(),
-						runtimeIdentity: client.getRuntimeIdentity()
+						agentDir: scope.agentDir,
+						config: ctx.config
 					});
-					return await refreshCodexPluginRuntimeState({
-						configCwd: workspaceDir,
-						appCache: defaultCodexAppInventoryCache,
-						appCacheKey,
-						metadataCache: defaultCodexPluginMetadataCache,
-						request: async (method, requestParams) => {
-							const requestMethod = resolvePluginRuntimeRefreshMethod(method);
-							return await deps.codexControlRequest(options.pluginConfig, requestMethod, requestParams, {
-								...scope,
-								config: ctx.config
-							});
-						}
+					const client = await getLeasedSharedCodexAppServerClient({
+						startOptions: appServer.start,
+						pluginConfig: options.pluginConfig,
+						authProfileId: scope.authProfileId,
+						agentDir: scope.agentDir,
+						config: ctx.config
 					});
-				} finally {
-					releaseLeasedSharedCodexAppServerClient(client);
+					try {
+						const appCacheKey = buildCodexPluginAppCacheKey({
+							appServer,
+							agentDir: scope.agentDir,
+							authProfileId,
+							accountId,
+							envApiKeyFingerprint: authProfileId ? void 0 : resolveCodexAppServerFallbackApiKeyCacheKey({ startOptions: appServer.start }),
+							appServerVersion: client.getServerVersion(),
+							runtimeIdentity: client.getRuntimeIdentity()
+						});
+						return await refreshCodexPluginRuntimeState({
+							configCwd: workspaceDir,
+							appCache: defaultCodexAppInventoryCache,
+							appCacheKey,
+							metadataCache: defaultCodexPluginMetadataCache,
+							request: async (method, requestParams) => {
+								const requestMethod = resolvePluginRuntimeRefreshMethod(method);
+								return await deps.codexControlRequest(options.pluginConfig, requestMethod, requestParams, {
+									...scope,
+									config: ctx.config
+								});
+							}
+						});
+					} finally {
+						releaseLeasedSharedCodexAppServerClient(client);
+					}
 				}
-			}
-		});
-	}
-	if (normalized === "status") {
-		const { agentDir } = resolveCodexConversationControlScope(ctx);
-		return { text: formatCodexStatus(await deps.readCodexStatusProbes(options.pluginConfig, ctx.config, agentDir)) };
-	}
-	if (normalized === "models") {
-		const { agentDir } = resolveCodexConversationControlScope(ctx);
-		return { text: formatModels(await deps.listCodexAppServerModels(deps.requestOptions(options.pluginConfig, 100, ctx.config, agentDir))) };
-	}
-	if (normalized === "threads") return { text: await buildThreads(deps, ctx, options.pluginConfig, rest.join(" ")) };
-	if (normalized === "goal") return { text: await handleNativeGoal(deps, ctx, options.pluginConfig, rest) };
-	if (normalized === "sessions") return { text: await buildCodexCliSessions(deps, rest) };
-	if (normalized === "resume") return { text: await resumeThread(deps, ctx, options.pluginConfig, rest) };
-	if (normalized === "bind") return await bindConversation(deps, ctx, options.pluginConfig, rest);
-	if (normalized === "detach" || normalized === "unbind") return { text: await detachConversation(deps, ctx) };
-	if (normalized === "binding") return { text: await describeConversationBinding(deps, ctx) };
-	if (normalized === "stop" || normalized === "steer") return { text: await controlConversationTurn(deps, ctx, normalized, rest.join(" ")) };
-	if (normalized === "model") return { text: await setConversationModel(deps, ctx, rest) };
-	if (normalized === "fast" || normalized === "permissions") {
-		if (isMenuVerb(rest)) return buildCodexChoiceMenuReply(normalized);
-		return { text: await setConversationPreference(deps, ctx, rest, normalized) };
-	}
-	if (normalized === "compact" || normalized === "review") return { text: await startThreadAction(deps, ctx, options.pluginConfig, normalized, rest) };
-	if (normalized === "diagnostics") return await handleCodexDiagnosticsFeedback(deps, ctx, options.pluginConfig, rest.join(" "));
-	if (normalized === "computer-use" || normalized === "computeruse") {
-		if (isMenuVerb(rest)) return buildCodexChoiceMenuReply("computer-use");
-		return { text: await handleComputerUseCommand(deps, ctx, options.pluginConfig, rest) };
-	}
-	if (normalized === "mcp" || normalized === "skills") {
-		const scope = await resolveCommandAppServerScope(deps, ctx, options.pluginConfig);
-		const response = await deps.codexControlRequest(options.pluginConfig, normalized === "mcp" ? CODEX_CONTROL_METHODS.listMcpServers : CODEX_CONTROL_METHODS.listSkills, normalized === "mcp" ? { limit: 100 } : {}, {
-			config: ctx.config,
-			...scope
-		});
-		return { text: normalized === "mcp" ? formatList(response, "MCP servers") : formatSkills(response) };
-	}
-	if (normalized === "account") {
-		const scope = await resolveCommandAppServerScope(deps, ctx, options.pluginConfig);
-		const requestScope = {
-			config: ctx.config,
-			...scope
-		};
-		const [account, limits] = await Promise.all([deps.safeCodexControlRequest(options.pluginConfig, CODEX_CONTROL_METHODS.account, { refreshToken: false }, requestScope), deps.safeCodexControlRequest(options.pluginConfig, CODEX_CONTROL_METHODS.rateLimits, void 0, requestScope)]);
-		return { text: formatAccount(account, limits, await readCodexAccountAuthOverview({
-			ctx,
-			agentDir: scope.agentDir,
-			authProfileId: scope.authProfileId,
-			pluginConfig: options.pluginConfig,
-			safeCodexControlRequest: deps.safeCodexControlRequest,
-			account,
-			limits
-		})) };
+			});
+		}
+		if (normalized === "status") {
+			const { agentDir } = resolveCodexConversationControlScope(ctx);
+			return { text: formatCodexStatus(await deps.readCodexStatusProbes(options.pluginConfig, ctx.config, agentDir)) };
+		}
+		if (normalized === "models") {
+			const { agentDir } = resolveCodexConversationControlScope(ctx);
+			return { text: formatModels(await deps.listCodexAppServerModels(deps.requestOptions(options.pluginConfig, 100, ctx.config, agentDir))) };
+		}
+		if (normalized === "threads") return { text: await buildThreads(deps, ctx, options.pluginConfig, rest.join(" ")) };
+		if (normalized === "goal") return { text: await handleNativeGoal(deps, ctx, options.pluginConfig, rest) };
+		if (normalized === "sessions") return { text: await buildCodexCliSessions(deps, rest) };
+		if (normalized === "resume") return { text: await resumeThread(deps, ctx, options.pluginConfig, rest) };
+		if (normalized === "bind") return await bindConversation(deps, ctx, options.pluginConfig, rest);
+		if (normalized === "detach" || normalized === "unbind") return { text: await detachConversation(deps, ctx) };
+		if (normalized === "binding") return { text: await describeConversationBinding(deps, ctx) };
+		if (normalized === "stop" || normalized === "steer") return { text: await controlConversationTurn(deps, ctx, normalized, rest.join(" ")) };
+		if (normalized === "model") return { text: await setConversationModel(deps, ctx, rest) };
+		if (normalized === "fast" || normalized === "permissions") {
+			if (isMenuVerb(rest)) return buildCodexChoiceMenuReply(normalized);
+			return { text: await setConversationPreference(deps, ctx, rest, normalized) };
+		}
+		if (normalized === "compact" || normalized === "review") return { text: await startThreadAction(deps, ctx, options.pluginConfig, normalized, rest) };
+		if (normalized === "diagnostics") return await handleCodexDiagnosticsFeedback(deps, ctx, options.pluginConfig, rest.join(" "));
+		if (normalized === "computer-use" || normalized === "computeruse") {
+			if (isMenuVerb(rest)) return buildCodexChoiceMenuReply("computer-use");
+			return { text: await handleComputerUseCommand(deps, ctx, options.pluginConfig, rest) };
+		}
+		if (normalized === "mcp" || normalized === "skills") {
+			const scope = await resolveCommandAppServerScope(deps, ctx, options.pluginConfig);
+			using _ = { [Symbol.dispose]: scope.release };
+			const response = await deps.codexControlRequest(options.pluginConfig, normalized === "mcp" ? CODEX_CONTROL_METHODS.listMcpServers : CODEX_CONTROL_METHODS.listSkills, normalized === "mcp" ? { limit: 100 } : {}, {
+				config: ctx.config,
+				...scope
+			});
+			return { text: normalized === "mcp" ? formatList(response, "MCP servers") : formatSkills(response) };
+		}
+		if (normalized === "account") {
+			const scope = await resolveCommandAppServerScope(deps, ctx, options.pluginConfig);
+			using _ = { [Symbol.dispose]: scope.release };
+			const requestScope = {
+				config: ctx.config,
+				...scope
+			};
+			const [account, limits] = await Promise.all([deps.safeCodexControlRequest(options.pluginConfig, CODEX_CONTROL_METHODS.account, { refreshToken: false }, requestScope), deps.safeCodexControlRequest(options.pluginConfig, CODEX_CONTROL_METHODS.rateLimits, void 0, requestScope)]);
+			return { text: formatAccount(account, limits, await readCodexAccountAuthOverview({
+				ctx,
+				agentDir: scope.agentDir,
+				authProfileId: scope.authProfileId,
+				pluginConfig: options.pluginConfig,
+				safeCodexControlRequest: deps.safeCodexControlRequest,
+				account,
+				limits
+			})) };
+		}
+		return { text: `Unknown Codex command: ${formatCodexDisplayText(subcommand)}\n\n${buildHelp()}` };
+	} finally {
+		nativePolicy.release();
 	}
-	return { text: `Unknown Codex command: ${formatCodexDisplayText(subcommand)}\n\n${buildHelp()}` };
 }
 function resolvePluginRuntimeRefreshMethod(method) {
 	const recognized = [