@openclaw/codex 2026.9.8 → 2026.10.1-beta.1

package/dist/.setup/{thread-lifecycle-_bAbjedG.mjs → thread-lifecycle-DkcoX9q-.mjs}

@@ -1,41 +1,43 @@
 import { i as isJsonObject, r as flattenCodexDynamicToolFunctions } from "./protocol-CANUwXJ3.mjs";
-import { a as matchesPendingSupervisionBranch, n as assertCodexBindingMayBeReplaced, v as sessionBindingIdentity } from "./session-binding-record-Oe9L-CNY.mjs";
-import { u as stringifyCodexPolicy } from "./config-security-CE-FcGw9.mjs";
+import { n as matchesPendingSupervisionBranch } from "./session-binding-record-codec-z4ZpDn6E.mjs";
+import { m as sessionBindingIdentity, n as assertCodexBindingMayBeReplaced } from "./session-binding-record-BZB8RgcF.mjs";
+import { u as fingerprintCodexPolicy } from "./config-security-KAPScztc.mjs";
 import { n as resolveCodexAppServerLocalHomeDir, t as resolveCodexAppServerHomeDir } from "./auth-start-options-BPIPeEX8.mjs";
-import { d as readCodexEffectiveConfig, n as codexSandboxPolicyForTurn, s as assertCodexModelBackedReviewerEffectiveConfig, u as CODEX_SESSION_OVERRIDABLE_LAYER_TYPES } from "./config-options-CzyWLTJt.mjs";
-import { i as markStartedCodexManagedThread } from "./managed-thread-store-BMqgThVL.mjs";
-import { l as retainSharedCodexAppServerClientByInstanceId, n as getCurrentSharedClientEntry } from "./shared-client-lifecycle-7xgtlo15.mjs";
+import { d as readCodexEffectiveConfig, n as codexSandboxPolicyForTurn, s as assertCodexModelBackedReviewerEffectiveConfig, u as CODEX_SESSION_OVERRIDABLE_LAYER_TYPES } from "./config-options-HG_Rr3W_.mjs";
+import { S as retainSharedCodexAppServerClientByInstanceId, d as getCurrentSharedClientEntry } from "./auth-cache-key-CEd9QlIs.mjs";
 import { t as withCodexAppServerThreadMutation } from "./thread-ownership-queue-Dp24d7-F.mjs";
-import { t as isIncognitoSessionKey } from "./incognito-session-DWYapfwf.mjs";
-import { n as CodexAppServerRpcError, r as isCodexThreadReadMissingError } from "./rpc-error-BlD2vuzn.mjs";
+import { o as isCodexAppServerOverloadError, r as CodexAppServerRpcError, s as isCodexThreadReadMissingError } from "./rpc-error-hmWM21RB.mjs";
 import { t as codexCatalogHomeId } from "./session-catalog-home-id-vlih0B_g.mjs";
 import { r as withAbortableTimeout } from "./timeout-CXOfNoaX.mjs";
-import { t as projectBoundedCodexThreadHistory } from "./transcript-history-projection-DRSifI-1.mjs";
-import { t as buildCodexAppServerConnectionFingerprint } from "./plugin-app-cache-key-BL9B5H0L.mjs";
-import { n as readCodexSessionMeta } from "./session-catalog-provenance-DoAvktcj.mjs";
-import { t as assertCodexSessionRuntimeOwnership } from "./binding-connection-DTtN1KrX.mjs";
-import "./config-DKhXquav.mjs";
-import { i as sanitizeInlineImageDataUrl, r as invalidInlineImageText } from "./session-history-read-Ov3StuL4.mjs";
-import { c as resolveCodexContextEngineProjectionMaxChars, o as neutralizeCodexExplicitMentionSigils } from "./context-engine-projection-PezSESth.mjs";
-import { n as normalizeCodexAppServerBindingModelProvider } from "./auth-profile-B0okYl2D.mjs";
-import { A as bindCodexInferenceThread, B as isCodexAppServerClientRuntimeLive, C as CodexThreadBindingConflictError, F as consumeCodexAppServerLiveThread, G as releaseCodexAppServerLiveThread, J as unsubscribeCodexAppServerLiveThread, M as getCodexInferenceThreadQualification, N as prepareCodexInferenceThreadConfig, Q as createCodexEphemeralThreadPolicy, S as CodexAdoptedThreadActiveError, T as CodexThreadStartRequestError, V as isCodexAppServerLiveThreadClaimed, j as getCodexInferenceThread, k as assertCodexInferenceRouteConfig, n as captureCodexAppServerClientLifetime, w as CodexThreadClientReplacementError, z as hasCodexAppServerSiblingThreadWork } from "./shared-client-CJCTeFpQ.mjs";
-import { C as assertExactSupervisionModelSelection, D as readSupervisionResponseThreadId, O as resolveCodexThreadRolloutPath, d as isCodexAppServerRequestTimeoutError, l as isCodexAppServerOverloadError, p as resolveCodexAppServerClientInstanceId, r as getCodexAppServerClientInstanceId, v as assertCodexThreadAcceptsDirectInput, x as assertCodexThreadStartResponse, y as assertCodexThreadForkResponse } from "./client-qyUBJlGZ.mjs";
-import { c as isCodexAppServerUnsafeSubscriptionError, g as hasCodexAppServerSiblingRouteWork, n as CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS, o as closeCodexStartupClientBestEffort, p as unsubscribeCodexThreadBestEffort, r as CodexAppServerUnsafeSubscriptionError, u as retireUnsafeCodexTurnClientBestEffort } from "./attempt-client-cleanup-B-S7ngS_.mjs";
-import { $ as readActiveCodexTurnIdsFromResume, B as loadCodexNativeToolCatalog, C as mergeCodexNativeProjectDocThreadConfig, E as assertCodexNativeHookRelayAllowed, F as attestCodexThreadToolSurface, G as areUserMcpServersFingerprintsCompatible, H as applyCodexNativeSkillIsolation, I as checkCodexThreadAppAvailability, J as fingerprintCodexThreadConfig, K as codexDynamicToolsFingerprint, L as discardUnattestedCodexPluginThread, Q as legacyFingerprintUserMcpServersConfigPatch, R as attestCodexRestrictedToolSurfaceMcpServersDisabled, St as mergeCodexThreadConfigs, T as CodexManagedHooksOnlyError, Tt as buildCodexAppApprovalOverrides, U as resolveCodexNativeSkillIsolation, W as areCodexDynamicToolFingerprintsCompatible, X as fingerprintJsonObject, Y as fingerprintEnvironmentSelection, Z as fingerprintUserMcpServersConfigPatch, _ as resolveCodexAppServerModelProvider, at as shouldRotateCodexGpt56MultiAgentBinding, bt as disableUnlistedCodexApps, c as codexThreadSandboxOrPermissions, d as resolveCodexThreadApprovalsReviewer, et as shouldStartTransientNoToolThread, g as CODEX_NATIVE_PERSONALITY_NONE, h as buildDeveloperInstructions, i as buildCodexRuntimeThreadConfigForRun, it as shouldRotateCodexAppServerBindingForRuntime, l as readCodexInheritedMcpServerNames, lt as isMessageOnlyCodexSourceReply, m as mergeCodexNativeShellEnvironment, mt as buildCodexPluginAppsConfigPatchFromPolicyContext, n as buildCodexRingZeroThreadConfigPatch, nt as isTransientWebSearchRestriction, o as buildThreadResumeParams, p as resolveCodexWebSearchPlan, q as codexLegacyDynamicToolsFingerprint, rt as shouldRecheckRecoverablePluginBinding, s as buildThreadStartParams, t as assertCodexManagedRequirementsDoNotOverrideToolPolicy, u as readCodexManagedRequirementsFingerprint, ut as isSystemAgentOnlyCodexDynamicToolAllowlist, v as resolveCodexAppServerRequestModelSelection, x as joinPresentSections, xt as isCodexPluginThreadBindingStale, y as resolveCodexAppServerThreadModelSelection, yt as buildPluginAppPolicyContext, z as hasCodexNativeToolCatalog } from "./thread-requests-OWGOiDaV.mjs";
-import { o as resolveCodexSessionBinding, r as hashCodexAppServerBindingFingerprint } from "./session-binding-DGCYAfvD.mjs";
-import { a as refreshCodexThreadPolicy, i as assertCodexSupervisionThreadLineage, n as CodexThreadPolicyHandoffError, o as refreshCodexThreadSkillsCatalog, r as assertAdoptedCodexThreadResumeAllowed, t as CodexIncognitoPolicyChangeError } from "./thread-policy-gNPzzpVp.mjs";
-import { t as resumeCodexAppServerThread } from "./thread-resume-GOry0AYh.mjs";
-import { c as withExclusiveCodexAppServerThread, r as retainCodexAppServerBindingSubscription, t as isSameCodexAppServerThreadOwner } from "./thread-ownership-B6pPt21M.mjs";
-import "./transcript-mirror-kxmCYsuF.mjs";
+import { t as projectBoundedCodexThreadHistory } from "./transcript-history-projection-B9a7HwUV.mjs";
+import { t as buildCodexAppServerConnectionFingerprint } from "./plugin-app-cache-key-BW8rd98k.mjs";
+import { n as readCodexSessionMeta } from "./session-catalog-provenance-CmsOE5mh.mjs";
+import { t as assertCodexSessionRuntimeOwnership } from "./binding-connection-C-08ez1w.mjs";
+import "./config-0Gxk3_eq.mjs";
+import { r as invalidInlineImageText } from "./session-history-read-CNN8zwbD.mjs";
+import { c as resolveCodexContextEngineProjectionMaxChars, o as neutralizeCodexExplicitMentionSigils } from "./context-engine-projection-CsgYSQhW.mjs";
+import { n as normalizeCodexAppServerBindingModelProvider } from "./auth-profile-CgHQ8Vot.mjs";
+import { A as bindCodexInferenceThread, B as isCodexAppServerClientRuntimeLive, C as CodexThreadBindingConflictError, F as consumeCodexAppServerLiveThread, G as releaseCodexAppServerLiveThread, J as unsubscribeCodexAppServerLiveThread, M as getCodexInferenceThreadQualification, N as prepareCodexInferenceThreadConfig, Q as createCodexEphemeralThreadPolicy, S as CodexAdoptedThreadActiveError, T as CodexThreadStartRequestError, V as isCodexAppServerLiveThreadClaimed, j as getCodexInferenceThread, k as assertCodexInferenceRouteConfig, n as captureCodexAppServerClientLifetime, w as CodexThreadClientReplacementError, z as hasCodexAppServerSiblingThreadWork } from "./shared-client-DJJ3ljH2.mjs";
+import { B as getCodexAppServerClientInstanceId, C as resolveCodexThreadRolloutPath, H as resolveCodexAppServerClientInstanceId, S as readSupervisionResponseThreadId, c as isCodexAppServerRequestTimeoutError, g as assertCodexThreadStartResponse, m as assertCodexThreadForkResponse, p as assertCodexThreadAcceptsDirectInput, v as assertExactSupervisionModelSelection } from "./client-CBzEVDyb.mjs";
+import { r as hasCodexAppServerSiblingRouteWork } from "./turn-router-CX1-EoCp.mjs";
+import { f as unsubscribeCodexThreadBestEffort, l as retireUnsafeCodexTurnClientBestEffort, n as CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS, o as closeCodexStartupClientBestEffort, r as CodexAppServerUnsafeSubscriptionError } from "./attempt-client-cleanup-yLjGwbwT.mjs";
+import { $ as legacyFingerprintUserMcpServersConfigPatch, B as hasCodexNativeToolCatalog, Ct as mergeCodexThreadConfigs, D as assertCodexNativeHookRelayAllowed, E as CodexManagedHooksOnlyError, Et as buildCodexAppApprovalOverrides, G as areCodexDynamicToolFingerprintsCompatible, I as attestCodexThreadToolSurface, J as codexLegacyDynamicToolsFingerprint, K as areUserMcpServersFingerprintsCompatible, L as checkCodexThreadAppAvailability, Q as fingerprintUserMcpServersConfigPatch, R as discardUnattestedCodexPluginThread, S as joinPresentSections, St as isCodexPluginThreadBindingStale, U as applyCodexNativeSkillIsolation, V as loadCodexNativeToolCatalog, W as resolveCodexNativeSkillIsolation, X as fingerprintEnvironmentSelection, Y as fingerprintCodexThreadConfig, Z as fingerprintJsonObject, _ as CODEX_NATIVE_PERSONALITY_NONE, at as shouldRotateCodexAppServerBindingForRuntime, b as resolveCodexAppServerThreadModelSelection, bt as buildPluginAppPolicyContext, c as codexThreadSandboxOrPermissions, d as readCodexManagedRequirementsFingerprint, dt as isSystemAgentOnlyCodexDynamicToolAllowlist, et as readActiveCodexTurnIdsFromResume, f as resolveCodexThreadApprovalsReviewer, g as buildDeveloperInstructions, h as mergeCodexNativeShellEnvironment, ht as buildCodexPluginAppsConfigPatchFromPolicyContext, i as buildCodexRuntimeThreadConfigForRun, it as shouldRecheckRecoverablePluginBinding, m as resolveCodexWebSearchPlan, n as buildCodexRingZeroThreadConfigPatch, o as buildThreadResumeParams, ot as shouldRotateCodexGpt56MultiAgentBinding, q as codexDynamicToolsFingerprint, rt as isTransientWebSearchRestriction, s as buildThreadStartParams, t as assertCodexManagedRequirementsDoNotOverrideToolPolicy, tt as shouldStartTransientNoToolThread, u as readCodexInheritedMcpServerNames, ut as isMessageOnlyCodexSourceReply, v as resolveCodexAppServerModelProvider, w as mergeCodexNativeProjectDocThreadConfig, xt as disableUnlistedCodexApps, y as resolveCodexAppServerRequestModelSelection, z as attestCodexRestrictedToolSurfaceMcpServersDisabled } from "./thread-requests-COrRJcZb.mjs";
+import { a as hashCodexAppServerBindingFingerprint, r as resolveCodexSessionBinding } from "./session-binding-Ce7BqiPN.mjs";
+import { r as readCodexMcpToolConnectorId } from "./mcp-tool-metadata-j10HhfTC.mjs";
+import { a as refreshCodexThreadInstructions, i as assertCodexSupervisionThreadLineage, n as CodexThreadPolicyHandoffError, o as refreshCodexThreadPolicy, r as assertAdoptedCodexThreadResumeAllowed, t as CodexIncognitoPolicyChangeError } from "./thread-policy-CXZV97TS.mjs";
+import { t as resumeCodexAppServerThread } from "./thread-resume-rx7J68Rx.mjs";
+import { c as withExclusiveCodexAppServerThread, r as retainCodexAppServerBindingSubscription, t as isSameCodexAppServerThreadOwner } from "./thread-ownership-0aRHD9iK.mjs";
 import { asOptionalRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import crypto from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
 import { resolveSessionAgentIdsStrict } from "openclaw/plugin-sdk/agent-scope-runtime";
 import path from "node:path";
+import { isIncognitoSessionKey } from "openclaw/plugin-sdk/session-key-runtime";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { createStageTimingTracker, formatStageTimings } from "openclaw/plugin-sdk/time-runtime";
-import { resolveAgentDir as resolveAgentDir$1 } from "openclaw/plugin-sdk/agent-runtime";
 import { AgentHarnessPreflightError, buildHarnessVisibleReplyGuidance, buildTemporalContextText, embeddedAgentLog, formatErrorMessage, isActiveHarnessContextEngine, isHostScopedAgentToolActive } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { resolveAgentDir as resolveAgentDir$2 } from "openclaw/plugin-sdk/agent-runtime";
+import { sanitizeInlineImageDataUrl } from "openclaw/plugin-sdk/inline-image-data-url-runtime";
 import { selectSupportedReasoningEffort } from "openclaw/plugin-sdk/agent-harness-attempt-runtime";
 import { buildCodexUserMcpServersThreadConfigPatchForRun } from "openclaw/plugin-sdk/codex-mcp-projection";
 import { isDiagnosticFlagEnabled } from "openclaw/plugin-sdk/diagnostic-flags";
@@ -115,10 +117,15 @@ function resolveCodexNativeModelInputTools(config) {
 	const multiAgent = isJsonObject(features?.multi_agent_v2) ? features.multi_agent_v2 : void 0;
 	const namespace = typeof multiAgent?.tool_namespace === "string" ? multiAgent.tool_namespace.trim() : "collaboration";
 	return [
+		"spawn_agent",
 		"multi_agent_v1send_input",
 		"send_message",
 		"followup_task",
-		...namespace ? [`${namespace}send_message`, `${namespace}followup_task`] : []
+		...namespace ? [
+			`${namespace}spawn_agent`,
+			`${namespace}send_message`,
+			`${namespace}followup_task`
+		] : []
 	];
 }
 //#endregion
@@ -128,20 +135,6 @@ function isCodexAppServerProfilerEnabled(config, env = process.env) {
 	return PROFILER_FLAGS.some((flag) => isDiagnosticFlagEnabled(flag, config, env));
 }
 //#endregion
-//#region extensions/codex/src/app-server/mcp-tool-metadata.ts
-/** Hosted app ownership is authoritative only on metadata supplied by Codex. */
-function readCodexMcpToolConnectorId(tool) {
-	const metadata = asOptionalRecord(asOptionalRecord(tool)?.["_meta"]);
-	return normalizeOptionalString(metadata?.connector_id) ?? normalizeOptionalString(metadata?.connectorId);
-}
-/** Preserve MCP App visibility so model-only tools cannot become widget authority. */
-function readCodexMcpToolUiVisibility(tool) {
-	const metadata = asOptionalRecord(asOptionalRecord(tool)?.["_meta"]);
-	const visibility = asOptionalRecord(metadata?.ui)?.visibility;
-	if (!Array.isArray(visibility)) return;
-	return [...new Set(visibility.filter((value) => value === "app" || value === "model"))].toSorted();
-}
-//#endregion
 //#region extensions/codex/src/app-server/scheduled-app-tool-policy.ts
 function normalizeAppToolApprovalMode(value) {
 	return value === "auto" || value === "prompt" || value === "writes" || value === "approve" ? value : void 0;
@@ -461,17 +454,16 @@ function intersectCodexPluginThreadConfigWithScheduledAuthority(config, authorit
 			}];
 		}));
 	}
-	const fingerprint = crypto.createHash("sha256").update(stringifyCodexPolicy({
-		version: 1,
-		namespace: CODEX_SCHEDULED_APP_AUTHORITY_NAMESPACE,
-		authority: scheduled,
-		inputFingerprint: config.inputFingerprint,
-		policyContext,
-		configPatch
-	})).digest("hex");
 	return {
 		...config,
-		fingerprint,
+		fingerprint: fingerprintCodexPolicy({
+			version: 1,
+			namespace: CODEX_SCHEDULED_APP_AUTHORITY_NAMESPACE,
+			authority: scheduled,
+			inputFingerprint: config.inputFingerprint,
+			policyContext,
+			configPatch
+		}),
 		configPatch,
 		provisionalAppIds: Object.keys(apps).toSorted(),
 		policyContext
@@ -501,12 +493,12 @@ function buildLegacyScheduledCodexAppRecoveryPrompt(params) {
 function buildScheduledCodexAppAuthorityInputFingerprint(baseFingerprint, authority) {
 	const scheduled = parseScheduledCodexAppAuthority(authority);
 	if (!scheduled) return baseFingerprint;
-	return crypto.createHash("sha256").update(stringifyCodexPolicy({
+	return fingerprintCodexPolicy({
 		version: 1,
 		namespace: CODEX_SCHEDULED_APP_AUTHORITY_NAMESPACE,
 		baseFingerprint,
 		authority: scheduled
-	})).digest("hex");
+	});
 }
 //#endregion
 //#region extensions/codex/src/app-server/thread-lifecycle-timing.ts
@@ -620,14 +612,17 @@ async function prepareCodexThreadRequestContext(params, options) {
 		throwIfAborted: options.throwIfAborted
 	};
 }
-function publishCodexThreadInferenceBinding(params, binding, reusedConfiguration = false) {
-	params.assertCurrent?.();
-	params.signal?.throwIfAborted();
-	assertCodexInferenceRouteConfig(params.client, params.inferenceRoute, params.config, binding.modelProvider, params.inferenceProviderRoutes);
-	if (reusedConfiguration) {
-		if (getCodexInferenceThread(params.client, binding.threadId) !== params.inferenceRoute) throw new Error("Codex inference thread configuration changed before reuse");
-	} else bindCodexInferenceThread(params.client, binding.threadId, params.inferenceRoute, params.inferenceProviderRoutes);
-	return binding;
+async function publishCodexThreadInferenceBinding(params, binding, reusedConfiguration = false) {
+	const publish = () => {
+		params.assertCurrent?.();
+		params.signal?.throwIfAborted();
+		assertCodexInferenceRouteConfig(params.client, params.inferenceRoute, params.config, binding.modelProvider, params.inferenceProviderRoutes);
+		if (reusedConfiguration) {
+			if (getCodexInferenceThread(params.client, binding.threadId) !== params.inferenceRoute) throw new Error("Codex inference thread configuration changed before reuse");
+		} else bindCodexInferenceThread(params.client, binding.threadId, params.inferenceRoute, params.inferenceProviderRoutes);
+		return binding;
+	};
+	return params.authority ? await params.authority.withCurrent(publish) : publish();
 }
 function resolveCodexThreadAgentDir(params) {
 	const agentId = resolveSessionAgentIdsStrict({
@@ -635,7 +630,7 @@ function resolveCodexThreadAgentDir(params) {
 		sessionKey: params.params.sessionKey,
 		agentId: params.agentId ?? params.params.agentId
 	}).sessionAgentId;
-	return params.agentDir ?? params.params.agentDir ?? resolveAgentDir$1(params.params.config ?? {}, agentId);
+	return params.agentDir ?? params.params.agentDir ?? resolveAgentDir$2(params.params.config ?? {}, agentId);
 }
 function buildCodexThreadBindingPolicy(params, preflight) {
 	return {
@@ -723,8 +718,8 @@ async function prepareCodexThreadLifecyclePreflight(params) {
 	const hostSystemAgentActive = params.hostSystemAgentActive ?? isHostScopedAgentToolActive("openclaw");
 	const ringZeroActive = hostSystemAgentActive && isSystemAgentOnlyCodexDynamicToolAllowlist(params.params.toolsAllow);
 	const messageOnlySourceReply = isMessageOnlyCodexSourceReply(params.params);
-	const restrictedToolSurface = ringZeroActive || messageOnlySourceReply || params.params.pluginHarnessToolPolicyRestricted === true;
-	const allowConfiguredManagedHooks = params.params.pluginHarnessToolPolicyRestricted === true && !ringZeroActive && !messageOnlySourceReply && params.params.scheduledRuntimeAuthority === void 0;
+	const restrictedToolSurface = ringZeroActive || messageOnlySourceReply || params.params.requireWorkspaceOnly === true || params.params.pluginHarnessToolPolicyRestricted === true;
+	const allowConfiguredManagedHooks = params.params.pluginHarnessToolPolicyRestricted === true && params.params.requireWorkspaceOnly !== true && !ringZeroActive && !messageOnlySourceReply && params.params.scheduledRuntimeAuthority === void 0;
 	const imageGenerationDenied = params.params.pluginHarnessToolPolicySafeDeniedTools?.includes("image_generate") === true;
 	if (restrictedToolSurface && params.nativeCodeModeEnabled !== false) throw new Error("Codex restricted tool surfaces require native code mode to be disabled");
 	if (!effectiveConfig) effectiveConfig = await lifecycleTiming.measure("effective-config-read", () => readCodexEffectiveConfig(params.client, params.cwd, { signal: params.signal }));
@@ -735,7 +730,7 @@ async function prepareCodexThreadLifecyclePreflight(params) {
 		restrictedToolSurface,
 		requiredNativeShell: params.nativeCodeModeEnabled !== false,
 		additionalDeniedFeatures: imageGenerationDenied ? ["image_generation"] : void 0,
-		allowedManagedRequirementsFingerprint: readScheduledCodexAppManagedRequirementsFingerprint(params.params.scheduledRuntimeAuthority),
+		allowedManagedRequirementsFingerprint: params.params.requireWorkspaceOnly === true ? void 0 : readScheduledCodexAppManagedRequirementsFingerprint(params.params.scheduledRuntimeAuthority),
 		allowConfiguredManagedHooks
 	}, params.signal));
 	const features = effectiveConfig?.config.features;
@@ -772,8 +767,28 @@ async function prepareCodexThreadLifecyclePreflight(params) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/thread-lifecycle-io.ts
+function recordCodexThreadReady(params, context, threadId, action) {
+	const { contextEngineBinding, lifecycleTiming } = context;
+	const event = {
+		sessionId: params.params.sessionId,
+		sessionKey: params.params.sessionKey,
+		threadId,
+		action
+	};
+	if (contextEngineBinding) embeddedAgentLog.info("codex app-server wrote context-engine thread binding", {
+		...event,
+		engineId: contextEngineBinding.engineId,
+		epoch: contextEngineBinding.projection?.epoch,
+		fingerprint: contextEngineBinding.projection?.fingerprint
+	});
+	lifecycleTiming.mark("thread-ready");
+	lifecycleTiming.logSummary({
+		runId: params.params.runId,
+		...event
+	});
+}
 async function resumeExistingCodexThread(params, context) {
-	const { binding: resumeBinding, bindingIdentity, startModelSelection, startModelProvider, userMcpServersConfigPatch, dynamicToolsFingerprint, webSearchThreadConfigFingerprint, ringZeroConfigFingerprint, ringZeroClientInstanceId, contextEngineBinding, hostSystemAgentActive, restrictedToolSurface, restrictedToolSurfaceInheritedMcpServerNames, nativeSkillIsolation, lifecycleTiming, normalizeBindingModelProvider, throwIfAborted, clearCurrentBinding } = context;
+	const { binding: resumeBinding, bindingIdentity, startModelSelection, startModelProvider, userMcpServersConfigPatch, dynamicToolsFingerprint, webSearchThreadConfigFingerprint, ringZeroConfigFingerprint, ringZeroClientInstanceId, hostSystemAgentActive, restrictedToolSurface, restrictedToolSurfaceInheritedMcpServerNames, nativeSkillIsolation, lifecycleTiming, normalizeBindingModelProvider, throwIfAborted, stageBindingReplacement } = context;
 	let acceptedConfiguration;
 	let disposeConfiguration;
 	let resumeReservation;
@@ -815,6 +830,7 @@ async function resumeExistingCodexThread(params, context) {
 			abandonClient,
 			request: resumeParams,
 			signal: params.signal,
+			withCurrent: params.authority?.withCurrent,
 			assertCurrent: () => {
 				configuration.assertCurrent();
 				assertCodexInferenceRouteConfig(params.client, params.inferenceRoute, resumeParams.config, requestModelProvider ?? (resumeBinding.preserveNativeModel ? configuration.modelProvider ?? void 0 : void 0), params.inferenceProviderRoutes);
@@ -838,7 +854,8 @@ async function resumeExistingCodexThread(params, context) {
 			threadConfig: resumeParams.config,
 			restrictedToolSurface,
 			lifecycleTiming,
-			assertCurrent: assertHandoffCurrent
+			assertCurrent: assertHandoffCurrent,
+			withCurrent: params.authority?.withCurrent
 		});
 		throwIfAborted();
 		await refreshCodexThreadPolicy({
@@ -847,7 +864,8 @@ async function resumeExistingCodexThread(params, context) {
 			developerInstructions: resumeParams.developerInstructions,
 			timeoutMs: params.appServer.requestTimeoutMs,
 			signal: params.signal,
-			assertCurrent: assertHandoffCurrent
+			assertCurrent: assertHandoffCurrent,
+			withCurrent: params.authority?.withCurrent
 		});
 		policyOutcome = "acknowledged";
 		assertHandoffCurrent();
@@ -877,25 +895,9 @@ async function resumeExistingCodexThread(params, context) {
 			kind: "patch",
 			threadId: resumeBinding.threadId,
 			patch: resumePatch
-		}, assertHandoffCurrent))) throw new CodexThreadBindingConflictError(resumeBinding.threadId, "committing a resumed thread");
+		}, assertHandoffCurrent, params.authority))) throw new CodexThreadBindingConflictError(resumeBinding.threadId, "committing a resumed thread");
 		assertHandoffCurrent();
-		if (contextEngineBinding) embeddedAgentLog.info("codex app-server wrote context-engine thread binding", {
-			sessionId: params.params.sessionId,
-			sessionKey: params.params.sessionKey,
-			threadId: response.thread.id,
-			engineId: contextEngineBinding.engineId,
-			epoch: contextEngineBinding.projection?.epoch,
-			fingerprint: contextEngineBinding.projection?.fingerprint,
-			action: "resumed"
-		});
-		lifecycleTiming.mark("thread-ready");
-		lifecycleTiming.logSummary({
-			runId: params.params.runId,
-			sessionId: params.params.sessionId,
-			sessionKey: params.params.sessionKey,
-			threadId: response.thread.id,
-			action: "resumed"
-		});
+		recordCodexThreadReady(params, context, response.thread.id, "resumed");
 		const activeTurnIds = readActiveCodexTurnIdsFromResume(response);
 		return {
 			...resumeBinding,
@@ -921,7 +923,8 @@ async function resumeExistingCodexThread(params, context) {
 			const subscriptionReleased = await unsubscribeCodexThreadBestEffort(params.client, {
 				threadId: resumeBinding.threadId,
 				timeoutMs: CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS,
-				assertCurrent: acceptedConfiguration.assertCurrent
+				assertCurrent: acceptedConfiguration.assertCurrent,
+				withCurrent: params.authority?.withCurrent
 			}).catch(() => false);
 			if (!subscriptionReleased || handoffError instanceof CodexThreadPolicyHandoffError && handoffError.outcome === "unknown") {
 				if (resumeBinding.connectionScope === "supervision") await retireUnsafeCodexTurnClientBestEffort(params.client, "session policy handoff");
@@ -936,7 +939,7 @@ async function resumeExistingCodexThread(params, context) {
 		}
 		if (resumeBinding.pendingResumeConfiguration || resumeBinding.preserveNativeModel || resumeBinding.connectionScope === "supervision" || params.signal?.aborted) throw error;
 		embeddedAgentLog.warn("codex app-server thread resume failed; starting a new thread", { error });
-		await clearCurrentBinding("rotating a stale thread binding");
+		stageBindingReplacement("rotating a stale thread binding");
 	} finally {
 		disposeConfiguration?.();
 	}
@@ -970,7 +973,8 @@ async function startFreshCodexThread(params, context) {
 			assertCurrent();
 			return await params.client.request("thread/start", startParams, {
 				signal: params.signal,
-				assertCurrent: assertInferenceCurrent
+				assertCurrent: assertInferenceCurrent,
+				withCurrent: params.authority?.withCurrent
 			});
 		} catch (error) {
 			if (error instanceof CodexAppServerRpcError) throw new CodexThreadStartRequestError(error);
@@ -999,7 +1003,8 @@ async function startFreshCodexThread(params, context) {
 			threadConfig: startParams.config,
 			restrictedToolSurface,
 			lifecycleTiming,
-			assertCurrent
+			assertCurrent,
+			withCurrent: params.authority?.withCurrent
 		});
 		assertCurrent();
 	} catch (error) {
@@ -1044,7 +1049,7 @@ async function startFreshCodexThread(params, context) {
 		const managedSourceHomeId = codexCatalogHomeId(resolveCodexAppServerLocalHomeDir(params.appServer.start, resolveCodexThreadAgentDir(params)));
 		let committed;
 		try {
-			await lifecycleTiming.measure("thread-start-mark-managed", () => markStartedCodexManagedThread(params.bindingStore.managedThreads, {
+			await lifecycleTiming.measure("thread-start-mark-managed", () => params.bindingStore.managedThreads?.mark({
 				sourceHomeId: managedSourceHomeId,
 				threadId: response.thread.id,
 				...rolloutPath ? { rolloutPath } : {}
@@ -1057,29 +1062,16 @@ async function startFreshCodexThread(params, context) {
 				kind: "set",
 				if: { kind: "absent" },
 				binding: nextBinding
-			}, assertCurrent));
+			}, assertCurrent, params.authority));
 		} catch (error) {
 			return await rejectUncommittedThread(error);
 		}
 		if (!committed) return await rejectUncommittedThread(new CodexThreadBindingConflictError(replacementPredecessor?.threadId ?? response.thread.id, "committing a fresh thread"));
-		if (contextEngineBinding) embeddedAgentLog.info("codex app-server wrote context-engine thread binding", {
-			sessionId: params.params.sessionId,
-			sessionKey: params.params.sessionKey,
-			threadId: response.thread.id,
-			engineId: contextEngineBinding.engineId,
-			epoch: contextEngineBinding.projection?.epoch,
-			fingerprint: contextEngineBinding.projection?.fingerprint,
-			action: rotatedContextEngineBinding ? "rotated" : "started"
-		});
 	}
-	lifecycleTiming.mark("thread-ready");
-	lifecycleTiming.logSummary({
-		runId: params.params.runId,
-		sessionId: params.params.sessionId,
-		sessionKey: params.params.sessionKey,
-		threadId: response.thread.id,
-		action: rotatedContextEngineBinding ? "rotated" : "started"
-	});
+	recordCodexThreadReady(params, {
+		lifecycleTiming,
+		contextEngineBinding: preserveExistingBinding ? void 0 : contextEngineBinding
+	}, response.thread.id, rotatedContextEngineBinding ? "rotated" : "started");
 	return {
 		...startedBinding,
 		modelProvider: response.modelProvider ?? requestModelProvider ?? startModelProvider ?? modelProvider,
@@ -1114,9 +1106,10 @@ async function releaseCodexConsumedLiveThread(options) {
 	if (await options.lifecycleTiming.measure("retained-thread-unsubscribe", () => unsubscribeCodexThreadBestEffort(options.client, {
 		threadId: options.threadId,
 		timeoutMs: 5e3,
-		assertCurrent: options.assertCurrent
+		assertCurrent: options.assertCurrent,
+		withCurrent: options.withCurrent
 	}))) return;
-	return await abandonCodexLiveThreadRelease(options, options.cause);
+	return await abandonCodexLiveThreadRelease(options);
 }
 async function abandonCodexLiveThreadRelease(options, cause) {
 	options.assertCurrent?.();
@@ -1126,9 +1119,9 @@ async function abandonCodexLiveThreadRelease(options, cause) {
 /** Releases through the retained owner, preserving its guarded callback and rollback. */
 async function releaseCodexRetainedLiveThread(options) {
 	try {
-		return await options.lifecycleTiming.measure("retained-thread-unsubscribe", () => releaseCodexAppServerLiveThread(options.client, options.threadId, options.assertCurrent));
+		return await options.lifecycleTiming.measure("retained-thread-unsubscribe", () => releaseCodexAppServerLiveThread(options.client, options.threadId, options.assertCurrent, options.withCurrent));
 	} catch (error) {
-		if (isCodexAppServerUnsafeSubscriptionError(error)) throw error;
+		if (error instanceof CodexAppServerUnsafeSubscriptionError) throw error;
 		return await abandonCodexLiveThreadRelease(options, error);
 	}
 }
@@ -1248,25 +1241,32 @@ async function tryReuseCodexLiveThread(options) {
 				prebuiltFinalConfigPatch
 			};
 		}
-		await attestCodexThreadToolSurface({
-			client: params.client,
-			threadId: binding.threadId,
-			appIds: pluginThreadConfig?.provisionalAppIds ?? [],
-			signal: params.signal,
-			threadConfig: resumeParams.config,
-			restrictedToolSurface,
-			lifecycleTiming,
-			assertCurrent: assertWarmOwner
-		});
+		try {
+			await attestCodexThreadToolSurface({
+				client: params.client,
+				threadId: binding.threadId,
+				appIds: pluginThreadConfig?.provisionalAppIds ?? [],
+				signal: params.signal,
+				threadConfig: resumeParams.config,
+				restrictedToolSurface,
+				lifecycleTiming,
+				assertCurrent: assertWarmOwner,
+				withCurrent: params.authority?.withCurrent
+			});
+		} catch (error) {
+			assertWarmOwner();
+			throw error;
+		}
 		assertWarmOwner();
-		if (ephemeralPolicy && ephemeralPolicy.skillsInstructions !== params.skillsInstructions) try {
-			await refreshCodexThreadSkillsCatalog({
+		if (ephemeralPolicy && ephemeralPolicy.refreshableInstructions !== params.refreshableInstructions) try {
+			await refreshCodexThreadInstructions({
 				client: params.client,
 				threadId: binding.threadId,
-				skillsInstructions: params.skillsInstructions,
+				refreshableInstructions: params.refreshableInstructions,
 				timeoutMs: params.appServer.requestTimeoutMs,
 				signal: params.signal,
-				assertCurrent: assertWarmOwner
+				assertCurrent: assertWarmOwner,
+				withCurrent: params.authority?.withCurrent
 			});
 		} catch (error) {
 			preserveSubscription = true;
@@ -1275,17 +1275,18 @@ async function tryReuseCodexLiveThread(options) {
 		const nativeHookRelayGeneration = prebuiltFinalConfigPatch.nativeHookRelayGeneration ?? binding.nativeHookRelayGeneration;
 		const model = binding.preserveNativeModel ? nativeThread?.model?.trim() || binding.model : startModelSelection.model;
 		const modelProvider = binding.preserveNativeModel ? nativeThread?.modelProvider?.trim() || binding.modelProvider : binding.modelProvider;
+		const bindingPatch = {
+			cwd: params.cwd,
+			model,
+			modelProvider,
+			nativeHookRelayGeneration,
+			environmentSelectionFingerprint
+		};
 		if (!(incognito || await lifecycleTiming.measure("warm-thread-write-binding", () => params.bindingStore.mutate(bindingIdentity, {
 			kind: "patch",
 			threadId: binding.threadId,
-			patch: {
-				cwd: params.cwd,
-				model,
-				modelProvider,
-				nativeHookRelayGeneration,
-				environmentSelectionFingerprint
-			}
-		}, assertWarmOwner)))) throw new CodexThreadBindingConflictError(binding.threadId, "committing a reused thread");
+			patch: bindingPatch
+		}, assertWarmOwner, params.authority)))) throw new CodexThreadBindingConflictError(binding.threadId, "committing a reused thread");
 		assertWarmOwner();
 		lifecycleTiming.mark("thread-ready");
 		lifecycleTiming.logSummary({
@@ -1300,17 +1301,11 @@ async function tryReuseCodexLiveThread(options) {
 			kind: "ready",
 			binding: {
 				...binding,
-				...!incognito ? {
-					cwd: params.cwd,
-					model,
-					modelProvider,
-					nativeHookRelayGeneration,
-					environmentSelectionFingerprint
-				} : {},
+				...!incognito ? bindingPatch : {},
 				liveThreadConfigFingerprint,
 				liveThreadEphemeralPolicy: ephemeralPolicy && {
 					...ephemeralPolicy,
-					skillsInstructions: params.skillsInstructions
+					refreshableInstructions: params.refreshableInstructions
 				},
 				liveThreadOwnership: retainedThread,
 				...!incognito && retainedThread.serviceTier && resumeParams.serviceTier === void 0 ? { clearInheritedServiceTier: true } : {},
@@ -1321,14 +1316,19 @@ async function tryReuseCodexLiveThread(options) {
 		if (!ownershipTransferred) {
 			let failure;
 			try {
-				if (preserveSubscription) try {
-					assertWarmOwner();
-					preserveSubscription = isSameCodexAppServerThreadOwner(params.bindingStore.read(bindingIdentity), binding);
-				} catch {
-					preserveSubscription = false;
-				}
+				let pendingRetention;
 				if (preserveSubscription) {
-					if (!await retainCodexAppServerBindingSubscription(params.client, binding.threadId, retainedThread)) failure = { cause: /* @__PURE__ */ new Error("Codex live thread ownership could not be returned to its session") };
+					const retain = () => {
+						assertWarmOwner();
+						if (isSameCodexAppServerThreadOwner(params.bindingStore.read(bindingIdentity), binding)) pendingRetention = retainCodexAppServerBindingSubscription(params.client, binding.threadId, retainedThread);
+					};
+					try {
+						if (params.authority) await params.authority.withCurrent(retain);
+						else retain();
+					} catch {}
+				}
+				if (pendingRetention) {
+					if (!await pendingRetention) failure = { cause: /* @__PURE__ */ new Error("Codex live thread ownership could not be returned to its session") };
 				} else await retainedThread.release(binding.threadId);
 			} catch (cause) {
 				failure = { cause };
@@ -1352,8 +1352,9 @@ async function withCodexThreadLifecycleBinding(params, run) {
 		agentId: params.agentId ?? params.params.agentId,
 		config: params.params.config
 	});
-	const { binding: snapshot, assertCurrent } = await resolveCodexSessionBinding({
+	const { binding: snapshot, authority } = await resolveCodexSessionBinding({
 		reclaimStale: true,
+		authority: params.authority,
 		bindingStore: params.bindingStore,
 		identity,
 		config: params.params.config,
@@ -1365,12 +1366,16 @@ async function withCodexThreadLifecycleBinding(params, run) {
 		signal: params.signal,
 		assertBinding: params.params.expectedSessionRuntimeOwnership ? (binding) => assertCodexSessionRuntimeOwnership(binding, params.params.expectedSessionRuntimeOwnership) : void 0
 	});
+	const assertCurrent = authority.assertCurrent;
 	const runWithLease = () => params.bindingStore.withLease(identity, async () => {
 		const binding = params.bindingStore.read(identity);
 		assertCodexSessionRuntimeOwnership(binding, params.params.expectedSessionRuntimeOwnership);
 		if (binding?.threadId !== snapshot?.threadId || binding?.clientId !== snapshot?.clientId) throw new CodexThreadBindingConflictError(binding?.threadId ?? snapshot?.threadId ?? params.params.sessionId, "acquiring thread lifecycle ownership");
 		assertCurrent();
-		return await run(identity, binding, assertCurrent);
+		return await run(identity, binding, authority);
+	}, {
+		assertCurrent,
+		authority
 	});
 	return snapshot?.pendingResumeConfiguration ? await withExclusiveCodexAppServerThread({
 		bindingStore: params.bindingStore,
@@ -1400,7 +1405,8 @@ async function resumePendingCodexThread(params, context) {
 				abandonClient: params.abandonClient,
 				lifecycleTiming,
 				threadId: binding.threadId,
-				assertCurrent
+				assertCurrent,
+				withCurrent: params.authority?.withCurrent
 			});
 		}
 	});
@@ -1414,21 +1420,15 @@ async function preparePendingCodexThreadResume(params, binding, dynamicToolsFing
 	const localHome = resolveCodexAppServerLocalHomeDir(params.appServer.start, agentDir);
 	if (params.appServer.start.transport !== "stdio" || params.appServer.start.homeScope === "user" || path.resolve(localHome) !== resolveCodexAppServerHomeDir(agentDir) || binding.connectionScope === "supervision" || binding.preserveNativeModel === true) throw fail("configuration adoption requires an OpenClaw-owned local Codex home");
 	if (isCodexAppServerLiveThreadClaimed(params.client, binding.threadId)) throw fail("the thread is claimed by active work; stop that run before resuming");
-	const assertClient = captureCodexAppServerClientLifetime(params.client, "native-process");
-	const assertCurrent = () => {
-		params.params.hostCapabilities.assertActive();
-		params.assertCurrent?.();
-		params.signal?.throwIfAborted();
-		assertClient();
-		if (isCodexAppServerLiveThreadClaimed(params.client, binding.threadId)) throw new CodexAdoptedThreadActiveError();
-	};
+	const assertCurrent = captureCodexThreadResumeAuthority(params, binding, "native-process");
 	assertCurrent();
 	const { thread } = await params.client.request("thread/read", {
 		threadId: binding.threadId,
 		includeTurns: false
 	}, {
 		signal: params.signal,
-		assertCurrent
+		assertCurrent,
+		withCurrent: params.authority?.withCurrent
 	});
 	assertCurrent();
 	if (thread.id !== binding.threadId || !isCodexThreadNonRunning(thread.status)) throw fail("the native thread is not idle; wait for its current run to finish");
@@ -1453,14 +1453,7 @@ async function preparePendingCodexThreadResume(params, binding, dynamicToolsFing
 }
 /** Observe teardown before release; a successful resume alone can acknowledge ignored overrides. */
 async function prepareCodexThreadResume(params, binding, context) {
-	const assertClient = captureCodexAppServerClientLifetime(params.client, binding.connectionScope === "supervision" ? "connection" : "thread-configuration");
-	const assertCurrent = () => {
-		params.params.hostCapabilities.assertActive();
-		params.assertCurrent?.();
-		params.signal?.throwIfAborted();
-		assertClient();
-		if (isCodexAppServerLiveThreadClaimed(params.client, binding.threadId)) throw new CodexAdoptedThreadActiveError();
-	};
+	const assertCurrent = captureCodexThreadResumeAuthority(params, binding, binding.connectionScope === "supervision" ? "connection" : "thread-configuration");
 	assertCurrent();
 	let thread;
 	try {
@@ -1474,6 +1467,16 @@ async function prepareCodexThreadResume(params, binding, context) {
 		assertCurrent
 	};
 }
+function captureCodexThreadResumeAuthority(params, binding, scope) {
+	const assertClient = captureCodexAppServerClientLifetime(params.client, scope);
+	return () => {
+		params.params.hostCapabilities.assertActive();
+		params.assertCurrent?.();
+		params.signal?.throwIfAborted();
+		assertClient();
+		if (isCodexAppServerLiveThreadClaimed(params.client, binding.threadId)) throw new CodexAdoptedThreadActiveError();
+	};
+}
 function isCodexThreadNonRunning(status) {
 	return status?.type === "idle" || status?.type === "notLoaded" || status?.type === "systemError";
 }
@@ -1495,12 +1498,46 @@ function observeCodexThreadConfiguration(params, thread, assertCurrent) {
 	};
 }
 //#endregion
+//#region extensions/codex/src/app-server/thread-supervision-cleanup.ts
+function withPendingSupervisionCleanup(pending, cleanupThreadIds) {
+	return {
+		sourceThreadId: pending.sourceThreadId,
+		...pending.connectionFingerprint ? { connectionFingerprint: pending.connectionFingerprint } : {},
+		...pending.lastTurnId ? { lastTurnId: pending.lastTurnId } : {},
+		...cleanupThreadIds.length > 0 ? { cleanupThreadIds } : {}
+	};
+}
+async function cleanPendingSupervisionArtifacts(client, pending) {
+	const remaining = [];
+	for (const threadId of pending.cleanupThreadIds ?? []) if (!await archiveSupervisionArtifact(client, threadId)) remaining.push(threadId);
+	return { remaining };
+}
+async function archiveSupervisionArtifact(client, threadId) {
+	try {
+		await client.request("thread/archive", { threadId }, { timeoutMs: CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS });
+		return true;
+	} catch (error) {
+		const message = formatErrorMessage(error).toLowerCase();
+		if (message.includes("no rollout found for thread id") || message.includes("thread not found") || message.includes("already archived")) return true;
+		await unsubscribeCodexThreadBestEffort(client, {
+			threadId,
+			timeoutMs: CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS
+		});
+		embeddedAgentLog.warn("failed to archive temporary Codex supervision thread", {
+			threadId,
+			error
+		});
+		return false;
+	}
+}
+//#endregion
 //#region extensions/codex/src/app-server/thread-supervision.ts
 async function materializePendingSupervisionBranch(params) {
 	let pending = params.binding.pendingSupervisionBranch;
 	const requestOptions = {
 		signal: params.signal,
-		assertCurrent: params.throwIfAborted
+		assertCurrent: params.throwIfAborted,
+		withCurrent: params.authority?.withCurrent
 	};
 	const connectionFingerprint = buildCodexAppServerConnectionFingerprint(params.appServer, params.attempt.agentDir);
 	if (!pending.connectionFingerprint || pending.connectionFingerprint !== connectionFingerprint) throw new Error("Codex supervision source connection changed before branch materialization");
@@ -1656,7 +1693,7 @@ async function materializePendingSupervisionBranch(params) {
 					modelProvider: bindingModelProvider,
 					historyCoveredThrough
 				}
-			}, params.throwIfAborted);
+			}, params.throwIfAborted, params.authority);
 		} catch (error) {
 			let current;
 			try {
@@ -1719,7 +1756,7 @@ async function materializePendingSupervisionBranch(params) {
 		} catch (stateError) {
 			cleanupStateError = stateError;
 		}
-		const unsafeCleanup = cleanup.remaining.length > 0 || isCodexAppServerUnsafeSubscriptionError(error);
+		const unsafeCleanup = cleanup.remaining.length > 0 || error instanceof CodexAppServerUnsafeSubscriptionError;
 		if (unsafeCleanup) await params.abandonClient();
 		if (cleanupStateError) {
 			const cause = new AggregateError([error, cleanupStateError], "Codex supervised branch cleanup state could not be recorded", { cause: error });
@@ -1781,63 +1818,28 @@ async function recoverPendingSupervisionArtifacts(params, pending) {
 	if (!pending.cleanupThreadIds?.length) return pending;
 	const cleanup = await cleanPendingSupervisionArtifacts(params.client, pending);
 	const next = withPendingSupervisionCleanup(pending, cleanup.remaining);
-	if (cleanup.remaining.length > 0) {
-		if (cleanup.remaining.length !== pending.cleanupThreadIds.length) {
-			if (!await params.bindingStore.mutate(params.bindingIdentity, {
-				kind: "patch-pending-supervision-branch",
-				expected: pending,
-				pending: next
-			})) throw new CodexThreadBindingConflictError(pending.sourceThreadId, "recording supervised Codex cleanup recovery");
-		}
-		throw new Error(`Codex supervised branch cleanup must finish before retry: ${cleanup.remaining.join(", ")}`);
+	const incomplete = cleanup.remaining.length > 0;
+	if (!incomplete || cleanup.remaining.length !== pending.cleanupThreadIds.length) {
+		if (!await params.bindingStore.mutate(params.bindingIdentity, {
+			kind: "patch-pending-supervision-branch",
+			expected: pending,
+			pending: next
+		})) throw new CodexThreadBindingConflictError(pending.sourceThreadId, incomplete ? "recording supervised Codex cleanup recovery" : "recovering a supervised Codex branch");
 	}
-	if (!await params.bindingStore.mutate(params.bindingIdentity, {
-		kind: "patch-pending-supervision-branch",
-		expected: pending,
-		pending: next
-	})) throw new CodexThreadBindingConflictError(pending.sourceThreadId, "recovering a supervised Codex branch");
+	if (incomplete) throw new Error(`Codex supervised branch cleanup must finish before retry: ${cleanup.remaining.join(", ")}`);
 	return next;
 }
-function withPendingSupervisionCleanup(pending, cleanupThreadIds) {
-	return {
-		sourceThreadId: pending.sourceThreadId,
-		...pending.connectionFingerprint ? { connectionFingerprint: pending.connectionFingerprint } : {},
-		...pending.lastTurnId ? { lastTurnId: pending.lastTurnId } : {},
-		...cleanupThreadIds.length > 0 ? { cleanupThreadIds } : {}
-	};
-}
-async function cleanPendingSupervisionArtifacts(client, pending) {
-	const remaining = [];
-	for (const threadId of pending.cleanupThreadIds ?? []) if (!await archiveSupervisionArtifact(client, threadId)) remaining.push(threadId);
-	return { remaining };
-}
-async function archiveSupervisionArtifact(client, threadId) {
-	try {
-		await client.request("thread/archive", { threadId }, { timeoutMs: CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS });
-		return true;
-	} catch (error) {
-		const message = formatErrorMessage(error).toLowerCase();
-		if (message.includes("no rollout found for thread id") || message.includes("thread not found") || message.includes("already archived")) return true;
-		await unsubscribeCodexThreadBestEffort(client, {
-			threadId,
-			timeoutMs: CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS
-		});
-		embeddedAgentLog.warn("failed to archive temporary Codex supervision thread", {
-			threadId,
-			error
-		});
-		return false;
-	}
-}
 //#endregion
 //#region extensions/codex/src/app-server/thread-lifecycle-run.ts
 async function startOrResumeThread(input) {
 	const incognito = isIncognitoSessionKey(input.params.sessionKey);
 	const clientId = resolveCodexAppServerClientInstanceId(input.client);
-	return await withCodexThreadLifecycleBinding(input, async (bindingIdentity, saved, assert) => {
+	return await withCodexThreadLifecycleBinding(input, async (bindingIdentity, saved, authority) => {
+		const assert = authority.assertCurrent;
 		const params = {
 			...input,
-			assertCurrent: assert
+			assertCurrent: assert,
+			authority
 		};
 		const expectedOwnership = params.params.expectedSessionRuntimeOwnership;
 		let binding = saved;
@@ -1848,6 +1850,7 @@ async function startOrResumeThread(input) {
 				binding,
 				appServer: params.appServer,
 				agentDir: resolveCodexThreadAgentDir(params),
+				authority,
 				assertCurrent: () => {
 					params.signal?.throwIfAborted();
 					assert();
@@ -1873,7 +1876,7 @@ async function startOrResumeThread(input) {
 				assertCurrent: assert,
 				throwIfAborted
 			});
-			params.skillsInstructions = params.inferenceRoute ? void 0 : input.skillsInstructions;
+			params.refreshableInstructions = params.inferenceRoute ? void 0 : input.refreshableInstructions;
 			return context;
 		};
 		const releaseRetainedThread = (threadId, ownerClientId = initialBoundClientId, assertCurrent) => releaseCodexBoundLiveThread({
@@ -1883,7 +1886,8 @@ async function startOrResumeThread(input) {
 			abandonClient: params.abandonClient,
 			lifecycleTiming,
 			threadId,
-			assertCurrent
+			assertCurrent,
+			withCurrent: authority.withCurrent
 		});
 		if (binding?.pendingSupervisionBranch) {
 			const requestContext = await prepareRequestContext();
@@ -1897,13 +1901,14 @@ async function startOrResumeThread(input) {
 				abandonClient: params.abandonClient ?? (() => closeCodexStartupClientBestEffort(params.client)),
 				bindingStore: params.bindingStore,
 				bindingIdentity,
+				authority,
 				binding: pendingBinding,
 				attempt: params.params,
 				cwd: params.cwd,
 				dynamicTools: params.dynamicTools,
 				appServer: params.appServer,
 				developerInstructions: params.developerInstructions,
-				skillsInstructions: params.skillsInstructions,
+				refreshableInstructions: params.refreshableInstructions,
 				config,
 				nativeCodeModeEnabled: params.nativeCodeModeEnabled,
 				nativeProviderWebSearchSupport: params.nativeProviderWebSearchSupport,
@@ -1942,16 +1947,21 @@ async function startOrResumeThread(input) {
 				}
 			}));
 		}
-		const clearCurrentBinding = async (operation) => {
+		const stageBindingReplacement = (operation) => {
 			const current = binding;
 			if (!current?.threadId) return;
 			assertCodexBindingMayBeReplaced(current, operation, expectedOwnership);
-			if (!await params.bindingStore.mutate(bindingIdentity, {
-				kind: "clear",
-				threadId: current.threadId
-			}, assert)) throw new CodexThreadBindingConflictError(current.threadId, operation);
+			assert();
+			replacementPredecessor = current;
 			binding = void 0;
 		};
+		const rotateStaleBinding = (current, changed, details) => {
+			embeddedAgentLog.debug(`codex app-server ${changed} changed; starting a new thread`, {
+				threadId: current.threadId,
+				...details
+			});
+			stageBindingReplacement("rotating a stale thread binding");
+		};
 		const transientDelegationRestriction = params.params.delegationCapability === "report_only";
 		const persistentWebSearchRestriction = params.webSearchAllowed === false && params.persistentWebSearchAllowed === false;
 		const transientNativeToolRestriction = params.nativeCodeModeEnabled === false && !persistentWebSearchRestriction;
@@ -1959,30 +1969,24 @@ async function startOrResumeThread(input) {
 		if (binding?.pendingResumeConfiguration) return publishCodexThreadInferenceBinding(params, await resumePendingCodexThread(params, {
 			...await prepareRequestContext(),
 			binding,
-			clearCurrentBinding,
+			stageBindingReplacement,
 			releaseRetainedThread: (threadId, assertCurrent) => releaseRetainedThread(threadId, initialBoundClientId, assertCurrent),
 			transientRestriction: transientDelegationRestriction || transientNativeToolRestriction || transientWebSearchRestriction
 		}));
-		if (binding?.threadId && !restrictedToolSurface && binding.nativeToolPolicyRestricted === true) await clearCurrentBinding("rotating a host-policy-restricted thread binding");
+		if (binding?.threadId && !restrictedToolSurface && binding.nativeToolPolicyRestricted === true) stageBindingReplacement("rotating a host-policy-restricted thread binding");
 		if (binding?.threadId && binding.nativeSkillIsolationFingerprint !== nativeSkillIsolationFingerprint) {
 			embeddedAgentLog.debug("codex app-server native skill isolation changed; starting a new thread", { threadId: binding.threadId });
-			await clearCurrentBinding("rotating stale native skill isolation");
+			stageBindingReplacement("rotating stale native skill isolation");
 		}
 		if (binding?.threadId && (binding.ringZeroConfigFingerprint !== ringZeroConfigFingerprint || binding.ringZeroClientInstanceId !== ringZeroClientInstanceId) && (ringZeroActive || binding.ringZeroConfigFingerprint !== void 0)) {
 			embeddedAgentLog.debug("codex app-server ring-zero restriction changed; rotating thread", { threadId: binding.threadId });
-			await clearCurrentBinding("rotating a ring-zero thread binding");
+			stageBindingReplacement("rotating a ring-zero thread binding");
 		}
 		if (binding?.threadId && shouldRotateCodexAppServerBindingForRuntime({
 			connectionClass: params.appServer.connectionClass,
 			current: binding.connectionScope === "supervision" ? buildCodexAppServerConnectionFingerprint(params.appServer, params.params.agentDir) : params.appServerRuntimeFingerprint,
 			binding: binding.appServerRuntimeFingerprint
-		})) {
-			embeddedAgentLog.debug("codex app-server runtime identity changed; starting a new thread", {
-				threadId: binding.threadId,
-				connectionClass: params.appServer.connectionClass
-			});
-			await clearCurrentBinding("rotating a stale thread binding");
-		}
+		})) rotateStaleBinding(binding, "runtime identity", { connectionClass: params.appServer.connectionClass });
 		if (binding?.threadId && shouldRotateCodexGpt56MultiAgentBinding({
 			bindingModel: binding.model,
 			requestedModel: params.params.modelId
@@ -1992,7 +1996,7 @@ async function startOrResumeThread(input) {
 				bindingModel: binding.model,
 				requestedModel: params.params.modelId
 			});
-			await clearCurrentBinding("rotating a GPT-5.6 multi-agent thread binding");
+			stageBindingReplacement("rotating a GPT-5.6 multi-agent thread binding");
 		}
 		selectionBinding = binding;
 		let preserveExistingBinding = transientDelegationRestriction || !ringZeroActive && params.nativeProviderWebSearchSupport === "unknown" && !binding?.threadId;
@@ -2020,12 +2024,11 @@ async function startOrResumeThread(input) {
 		const webSearchBindingChanged = binding?.threadId && binding.webSearchThreadConfigFingerprint !== webSearchThreadConfigFingerprint;
 		const explicitTransientWebSearchRestriction = params.webSearchAllowed === false && params.persistentWebSearchAllowed !== false && transientWebSearchRestriction;
 		const unknownProviderWebSearchSupport = params.nativeProviderWebSearchSupport === "unknown";
-		if (binding?.threadId && (params.configuredMcpOwnershipVersion === 1 && (binding.configuredMcpOwnershipVersion !== 1 || binding.dynamicToolsFingerprint === void 0 || binding.mcpServersFingerprint !== void 0 || binding.userMcpServersFingerprint !== void 0) || params.configuredMcpOwnershipVersion !== 1 && binding.configuredMcpOwnershipVersion === 1) && binding?.threadId) {
+		const configuredMcpOwnershipChanged = binding?.threadId && (params.configuredMcpOwnershipVersion === 1 && (binding.configuredMcpOwnershipVersion !== 1 || binding.dynamicToolsFingerprint === void 0 || binding.mcpServersFingerprint !== void 0 || binding.userMcpServersFingerprint !== void 0) || params.configuredMcpOwnershipVersion !== 1 && binding.configuredMcpOwnershipVersion === 1);
+		if (configuredMcpOwnershipChanged && binding?.threadId) {
 			const predecessorBinding = binding;
-			assertCodexBindingMayBeReplaced(predecessorBinding, "changing configured MCP ownership", expectedOwnership);
+			stageBindingReplacement("changing configured MCP ownership");
 			embeddedAgentLog.debug("codex app-server configured MCP ownership changed; starting a new thread", { threadId: predecessorBinding.threadId });
-			replacementPredecessor = predecessorBinding;
-			binding = void 0;
 			preserveExistingBinding = false;
 		}
 		if (binding?.threadId && params.mcpServersFingerprintEvaluated === true && binding.mcpServersFingerprint !== params.mcpServersFingerprint) {
@@ -2033,10 +2036,7 @@ async function startOrResumeThread(input) {
 			if (!ringZeroActive && (transientNativeToolRestriction || webSearchBindingChanged && (explicitTransientWebSearchRestriction || unknownProviderWebSearchSupport))) {
 				embeddedAgentLog.debug("codex app-server MCP config changed during transient restricted turn; starting transient thread", { threadId: binding.threadId });
 				preserveExistingBinding = true;
-			} else {
-				embeddedAgentLog.debug("codex app-server MCP config changed; starting a new thread", { threadId: binding.threadId });
-				await clearCurrentBinding("rotating a stale thread binding");
-			}
+			} else rotateStaleBinding(binding, "MCP config");
 			binding = void 0;
 		}
 		const deferLegacyWebSearchRotationToTransientNativeSurface = params.nativeCodeModeEnabled === false && binding?.webSearchThreadConfigFingerprint === void 0 && !persistentWebSearchRestriction;
@@ -2045,10 +2045,7 @@ async function startOrResumeThread(input) {
 			if (!ringZeroActive && transientWebSearchRestriction) {
 				embeddedAgentLog.debug("codex app-server tool surface restricted for turn; starting transient thread", { threadId: binding.threadId });
 				preserveExistingBinding = true;
-			} else {
-				embeddedAgentLog.debug("codex app-server web search config changed; starting a new thread", { threadId: binding.threadId });
-				await clearCurrentBinding("rotating a stale thread binding");
-			}
+			} else rotateStaleBinding(binding, "web search config");
 			binding = void 0;
 		}
 		if (binding?.threadId && transientNativeToolRestriction && !ringZeroActive) {
@@ -2064,8 +2061,7 @@ async function startOrResumeThread(input) {
 		}
 		if (binding?.threadId && (binding.contextEngine || contextEngineBinding)) {
 			if (!contextEngineBinding || !isContextEngineBindingCompatible(binding.contextEngine, contextEngineBinding)) {
-				embeddedAgentLog.debug("codex app-server context-engine binding changed; starting a new thread", {
-					threadId: binding.threadId,
+				rotateStaleBinding(binding, "context-engine binding", {
 					engineId: contextEngineBinding?.engineId,
 					previousEngineId: binding.contextEngine?.engineId,
 					epoch: contextEngineBinding?.projection?.epoch,
@@ -2075,7 +2071,6 @@ async function startOrResumeThread(input) {
 					policyFingerprint: contextEngineBinding?.policyFingerprint,
 					previousPolicyFingerprint: binding.contextEngine?.policyFingerprint
 				});
-				await clearCurrentBinding("rotating a stale thread binding");
 				rotatedContextEngineBinding = true;
 			}
 		}
@@ -2083,14 +2078,8 @@ async function startOrResumeThread(input) {
 			previous: binding.userMcpServersFingerprint,
 			next: userMcpServersFingerprint,
 			nextLegacy: legacyUserMcpServersFingerprint
-		})) {
-			embeddedAgentLog.debug("codex app-server user MCP config changed; starting a new thread", { threadId: binding.threadId });
-			await clearCurrentBinding("rotating a stale thread binding");
-		}
-		if (binding?.threadId && (binding.networkProxyConfigFingerprint !== networkProxyConfigFingerprint || binding.networkProxyProfileName !== params.appServer.networkProxy?.profileName)) {
-			embeddedAgentLog.debug("codex app-server network proxy config changed; starting a new thread", { threadId: binding.threadId });
-			await clearCurrentBinding("rotating a stale thread binding");
-		}
+		})) rotateStaleBinding(binding, "user MCP config");
+		if (binding?.threadId && (binding.networkProxyConfigFingerprint !== networkProxyConfigFingerprint || binding.networkProxyProfileName !== params.appServer.networkProxy?.profileName)) rotateStaleBinding(binding, "network proxy config");
 		if (binding?.threadId) {
 			if (isCodexPluginThreadBindingStale({
 				codexPluginsEnabled: params.pluginThreadConfig?.enabled ?? false,
@@ -2098,16 +2087,10 @@ async function startOrResumeThread(input) {
 				bindingInputFingerprint: binding.pluginAppsInputFingerprint,
 				currentInputFingerprint: params.pluginThreadConfig?.inputFingerprint,
 				hasBindingPolicyContext: Boolean(binding.pluginAppPolicyContext)
-			})) {
-				embeddedAgentLog.debug("codex app-server plugin app config changed; starting a new thread", { threadId: binding.threadId });
-				await clearCurrentBinding("rotating a stale thread binding");
-			}
+			})) rotateStaleBinding(binding, "plugin app config");
 		}
 		if (binding?.threadId) {
-			if (binding.dynamicToolsFingerprint && params.dynamicTools.length > 0 && binding.dynamicToolsContainDeferred !== dynamicToolsContainDeferred && (binding.dynamicToolsContainDeferred !== void 0 || !dynamicToolsContainDeferred)) {
-				embeddedAgentLog.debug("codex app-server dynamic tool loading changed; starting a new thread", { threadId: binding.threadId });
-				await clearCurrentBinding("rotating a stale thread binding");
-			}
+			if (binding.dynamicToolsFingerprint && params.dynamicTools.length > 0 && binding.dynamicToolsContainDeferred !== dynamicToolsContainDeferred && (binding.dynamicToolsContainDeferred !== void 0 || !dynamicToolsContainDeferred)) rotateStaleBinding(binding, "dynamic tool loading");
 		}
 		if (binding?.threadId) {
 			if (binding.dynamicToolsFingerprint && !areCodexDynamicToolFingerprintsCompatible({
@@ -2121,10 +2104,7 @@ async function startOrResumeThread(input) {
 					nextHasDynamicTools: params.dynamicTools.length > 0
 				});
 				if (preserveExistingBinding) embeddedAgentLog.debug("codex app-server dynamic tools unavailable for turn; starting transient thread", { threadId: binding.threadId });
-				else {
-					embeddedAgentLog.debug("codex app-server dynamic tool catalog changed; starting a new thread", { threadId: binding.threadId });
-					await clearCurrentBinding("rotating a stale thread binding");
-				}
+				else rotateStaleBinding(binding, "dynamic tool catalog");
 			} else {
 				const requestContext = await prepareRequestContext();
 				const warmReuse = await tryReuseCodexLiveThread({
@@ -2137,13 +2117,13 @@ async function startOrResumeThread(input) {
 				if (warmReuse.kind === "ready") return publishCodexThreadInferenceBinding(params, warmReuse.binding, true);
 				if (incognito || warmReuse.kind === "rotate") {
 					throwIfAborted();
-					await clearCurrentBinding(incognito ? "rotating an unavailable ephemeral thread binding" : "rotating a stale plugin app binding");
+					stageBindingReplacement(incognito ? "rotating an unavailable ephemeral thread binding" : "rotating a stale plugin app binding");
 				} else {
 					const resumeBinding = binding;
 					const resumed = await resumeExistingCodexThread(params, {
 						...requestContext,
 						binding: resumeBinding,
-						clearCurrentBinding,
+						stageBindingReplacement,
 						prebuiltFinalConfigPatch: warmReuse.prebuiltFinalConfigPatch,
 						prebuiltPluginThreadConfig,
 						buildLoadedPluginThreadConfig,
@@ -2158,7 +2138,7 @@ async function startOrResumeThread(input) {
 		}
 		assertCodexBindingMayBeReplaced(binding, "starting a fresh native thread", expectedOwnership);
 		const requestContext = await prepareRequestContext();
-		if (initialBoundThreadId && !preserveExistingBinding && !replacementPredecessor) await releaseRetainedThread(initialBoundThreadId);
+		if (initialBoundThreadId && !preserveExistingBinding && !configuredMcpOwnershipChanged) await releaseRetainedThread(initialBoundThreadId);
 		const started = await startFreshCodexThread(params, {
 			...requestContext,
 			prebuiltPluginThreadConfig,
@@ -2166,7 +2146,7 @@ async function startOrResumeThread(input) {
 			rotatedContextEngineBinding,
 			replacementPredecessor
 		});
-		if (replacementPredecessor) await releaseRetainedThread(replacementPredecessor.threadId, replacementPredecessor.clientId);
+		if (replacementPredecessor && !preserveExistingBinding && configuredMcpOwnershipChanged) await releaseRetainedThread(replacementPredecessor.threadId, replacementPredecessor.clientId);
 		return publishCodexThreadInferenceBinding(params, started);
 	});
 }
@@ -2249,11 +2229,7 @@ function buildTurnStartParams(params, options) {
 		agentDir: params.agentDir,
 		config: params.config
 	});
-	const collaborationMode = modelSelection ? buildTurnCollaborationMode(params, {
-		model: modelSelection.model,
-		turnScopedDeveloperInstructions: options.turnScopedDeveloperInstructions,
-		memoryCollaborationInstructions: options.memoryCollaborationInstructions
-	}) : void 0;
+	const collaborationMode = modelSelection ? buildTurnCollaborationMode(params, { model: modelSelection.model }) : void 0;
 	if (collaborationMode && options.parentLocalEgress) collaborationMode.settings.developer_instructions = null;
 	const useThreadPermissionProfile = options.appServer.networkProxy && !options.sandboxPolicy;
 	const currentSender = params.trigger === "user" ? readCodexCurrentSender(params) : void 0;
@@ -2299,7 +2275,7 @@ function buildTurnStartParams(params, options) {
 			effort: collaborationMode.settings.reasoning_effort,
 			collaborationMode
 		} : {},
-		...options.environmentSelection ? { environments: options.environmentSelection } : {}
+		...params.requireWorkspaceOnly === true ? { environments: [] } : options.environmentSelection ? { environments: options.environmentSelection } : {}
 	};
 }
 function buildCodexTemporalAdditionalContext(params, options) {
@@ -2322,34 +2298,15 @@ function buildTurnCollaborationMode(params, options = {}) {
 				modelId: model,
 				supportedReasoningEfforts: readCodexSupportedReasoningEfforts(params.model?.compat)
 			}),
-			developer_instructions: buildTurnScopedCollaborationInstructions(params, options)
+			developer_instructions: params.trigger === "cron" ? buildCronCollaborationInstructions() : null
 		}
 	};
 }
 function buildCodexParentLocalInstructions(params, options = {}) {
-	const contextInstructions = joinPresentSections(options.turnScopedDeveloperInstructions, options.skillsInstructions, options.memoryCollaborationInstructions);
+	const contextInstructions = joinPresentSections(options.personaInstructions, options.skillsInstructions, options.memoryInstructions);
 	if (params.trigger === "cron") return joinPresentSections(buildCronCollaborationInstructions(), contextInstructions);
 	return contextInstructions || null;
 }
-function buildTurnScopedCollaborationInstructions(params, options) {
-	const instructions = buildCodexParentLocalInstructions(params, options);
-	return instructions && params.trigger !== "cron" ? joinPresentSections(buildDefaultCollaborationInstructions(), instructions) : instructions;
-}
-function buildDefaultCollaborationInstructions() {
-	return [
-		"# Collaboration Mode: Default",
-		"",
-		"You are now in Default mode. Any previous instructions for other modes (e.g. Plan mode) are no longer active.",
-		"",
-		"Your active mode changes only when new developer instructions with a different `<collaboration_mode>...</collaboration_mode>` change it; user requests or tool descriptions do not change mode by themselves. Known mode names are Default and Plan.",
-		"",
-		"## request_user_input availability",
-		"",
-		"Use the `request_user_input` tool only when it is listed in the available tools for this turn.",
-		"",
-		"In Default mode, strongly prefer making reasonable assumptions and executing the user's request rather than stopping to ask questions. When a missing preference, constraint, or clarification warrants a question, use `request_user_input_async` if it is available and continue independent work. Answers arrive as ordinary user messages. A suggested or preselected answer is not consent; wait for explicit approval before dependent actions that require it. If neither question tool is available, ask a concise plain-text question. Never write a multiple choice question as a textual assistant message."
-	].join("\n");
-}
 function buildCronCollaborationInstructions() {
 	return [
 		"This is an OpenClaw cron automation turn. Apply these instructions only to this scheduled job; ordinary chat turns should stay in Codex Default mode.",
@@ -2359,4 +2316,4 @@ function buildCronCollaborationInstructions() {
 	].join("\n\n");
 }
 //#endregion
-export { resolveCodexAppServerReasoningEffort as S, readCodexMcpToolUiVisibility as _, buildTurnStartParams as a, isContextEngineBindingCompatible as b, assertScheduledCodexAppAuthorityRuntime as c, buildScheduledCodexAppServerConnectionIdentity as d, captureScheduledCodexAppAuthority as f, readCodexMcpToolConnectorId as g, resolveScheduledCodexAppCreatorCaptureDecision as h, buildTurnCollaborationMode as i, buildLegacyScheduledCodexAppRecoveryPrompt as l, readCurrentCodexScheduledAppPolicy as m, buildCodexParentLocalInstructions as n, buildCodexUserInput as o, intersectCodexPluginThreadConfigWithScheduledAuthority as p, buildCodexTemporalAdditionalContext as r, startOrResumeThread as s, buildCodexHistoryProvenancePrefix as t, buildScheduledCodexAppAuthorityInputFingerprint as u, isCodexAppServerProfilerEnabled as v, readCodexSupportedReasoningEfforts as x, buildContextEngineBinding as y };
+export { buildContextEngineBinding as _, buildTurnStartParams as a, resolveCodexAppServerReasoningEffort as b, assertScheduledCodexAppAuthorityRuntime as c, buildScheduledCodexAppServerConnectionIdentity as d, captureScheduledCodexAppAuthority as f, isCodexAppServerProfilerEnabled as g, resolveScheduledCodexAppCreatorCaptureDecision as h, buildTurnCollaborationMode as i, buildLegacyScheduledCodexAppRecoveryPrompt as l, readCurrentCodexScheduledAppPolicy as m, buildCodexParentLocalInstructions as n, buildCodexUserInput as o, intersectCodexPluginThreadConfigWithScheduledAuthority as p, buildCodexTemporalAdditionalContext as r, startOrResumeThread as s, buildCodexHistoryProvenancePrefix as t, buildScheduledCodexAppAuthorityInputFingerprint as u, isContextEngineBindingCompatible as v, readCodexSupportedReasoningEfforts as y };