@openclaw/codex 2026.10.2 → 2026.10.5-beta.2

package/dist/.setup/{thread-lifecycle--EPPTNTe.mjs → thread-lifecycle-run-BWy0LDLB.mjs}

@@ -1,140 +1,50 @@
 import { i as isJsonObject, r as flattenCodexDynamicToolFunctions } from "./protocol-CANUwXJ3.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 matchesPendingSupervisionBranch } from "./session-binding-record-codec-BpH8u_G9.mjs";
+import { m as sessionBindingIdentity, n as assertCodexBindingMayBeReplaced } from "./session-binding-record-DU_0biMD.mjs";
+import { l as fingerprintCodexPolicy } from "./config-security-clxAZYWX.mjs";
+import { f as resolveCodexPluginsPolicy } from "./config-parsing-DsWSCPHO.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-HG_Rr3W_.mjs";
-import { S as retainSharedCodexAppServerClientByInstanceId, d as getCurrentSharedClientEntry } from "./auth-cache-key-BE1HXsNo.mjs";
-import { t as withCodexAppServerThreadMutation } from "./thread-ownership-queue-Dp24d7-F.mjs";
-import { o as isCodexAppServerOverloadError, r as CodexAppServerRpcError, s as isCodexThreadReadMissingError } from "./rpc-error-hmWM21RB.mjs";
+import { d as readCodexEffectiveConfig, s as assertCodexModelBackedReviewerEffectiveConfig, u as CODEX_SESSION_OVERRIDABLE_LAYER_TYPES } from "./config-options-DDzeNQ8m.mjs";
+import { S as retainSharedCodexAppServerClientByInstanceId, d as getCurrentSharedClientEntry } from "./auth-cache-key-tENCQOub.mjs";
+import { t as withCodexAppServerThreadMutation } from "./thread-ownership-queue-CeyYScUC.mjs";
+import { o as isCodexAppServerOverloadError, r as CodexAppServerRpcError, s as isCodexThreadReadMissingError } from "./rpc-error-C98SHchT.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-B9a7HwUV.mjs";
-import { t as buildCodexAppServerConnectionFingerprint } from "./plugin-app-cache-key-BW8rd98k.mjs";
+import { r as withAbortableTimeout } from "./timeout-D0mEWSGG.mjs";
+import { t as projectBoundedCodexThreadHistory } from "./transcript-history-projection-DfKcoZCB.mjs";
+import { a as defaultCodexAppInventoryCache, t as buildCodexAppServerConnectionFingerprint } from "./plugin-app-cache-key-Bg9DbDI6.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 { t as assertCodexSessionRuntimeOwnership } from "./binding-connection-B7HAAZSI.mjs";
+import { c as resolveRecoverableCodexPluginConfigKeys } from "./plugin-inventory-CYgdo14P.mjs";
+import "./config-C1YVVLEA.mjs";
+import { c as resolveCodexContextEngineProjectionMaxChars } from "./context-engine-projection-ps-yn_ci.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-5NUq43f3.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-ChJtGEdJ.mjs";
-import { r as hasCodexAppServerSiblingRouteWork } from "./turn-router-BOKSJmfw.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-DPUGAWP2.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-Bj_Lixmv.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-VtqLex1l.mjs";
-import { t as resumeCodexAppServerThread } from "./thread-resume-buZujRcC.mjs";
-import { c as withExclusiveCodexAppServerThread, r as retainCodexAppServerBindingSubscription, t as isSameCodexAppServerThreadOwner } from "./thread-ownership-T7T_iffm.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-BjiqpbC5.mjs";
+import { C as resolveCodexThreadRolloutPath, F as getCodexAppServerClientInstanceId, L as resolveCodexAppServerClientInstanceId, S as readSupervisionResponseThreadId, c as isCodexAppServerRequestTimeoutError, g as assertCodexThreadStartResponse, m as assertCodexThreadForkResponse, p as assertCodexThreadAcceptsDirectInput, v as assertExactSupervisionModelSelection } from "./client-zrCKOu_E.mjs";
+import { r as hasCodexAppServerSiblingRouteWork } from "./turn-router-D8DLkZgH.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-CxX4cTSi.mjs";
+import { a as buildCodexPluginThreadConfigInputFingerprint, c as buildPluginAppPolicyContext, d as mergeCodexThreadConfigs, i as buildCodexPluginThreadConfig, l as disableUnlistedCodexApps, m as buildCodexAppApprovalOverrides, n as mergeCodexNativeProjectDocThreadConfig, o as buildCodexPluginThreadConfigTimeoutFallback, p as shouldBuildCodexPluginThreadConfig, r as buildCodexPluginAppsConfigPatchFromPolicyContext, u as isCodexPluginThreadBindingStale } from "./project-doc-thread-config-BVcvnps8.mjs";
+import { A as isTransientWebSearchRestriction, C as fingerprintEnvironmentSelection, D as readActiveCodexTurnIdsFromResume, E as legacyFingerprintUserMcpServersConfigPatch, I as isMessageOnlyCodexSourceReply, L as isSystemAgentOnlyCodexDynamicToolAllowlist, M as shouldRotateCodexAppServerBindingForRuntime, N as shouldRotateCodexGpt56MultiAgentBinding, O as shouldStartTransientNoToolThread, S as fingerprintCodexThreadConfig, T as fingerprintUserMcpServersConfigPatch, _ as buildDeveloperInstructions, b as codexDynamicToolsFingerprint, c as codexThreadSandboxOrPermissions, d as readCodexManagedRequirementsFingerprint, f as resolveCodexThreadApprovalsReviewer, g as mergeCodexNativeShellEnvironment, h as resolveCodexWebSearchPlan, i as buildCodexRuntimeThreadConfigForRun, j as shouldRecheckRecoverablePluginBinding, n as buildCodexRingZeroThreadConfigPatch, o as buildThreadResumeParams, p as attestCodexRestrictedToolSurfaceMcpServersDisabled, s as buildThreadStartParams, t as assertCodexManagedRequirementsDoNotOverrideToolPolicy, u as readCodexInheritedMcpServerNames, v as areCodexDynamicToolFingerprintsCompatible, w as fingerprintJsonObject, x as codexLegacyDynamicToolsFingerprint, y as areUserMcpServersFingerprintsCompatible } from "./thread-requests-BgzJwJtS.mjs";
+import { i as resolveCodexSessionBinding, o as hashCodexAppServerBindingFingerprint } from "./session-binding-JEHNMPsr.mjs";
+import { i as resolveCodexAppServerThreadModelSelection, n as resolveCodexAppServerModelProvider } from "./thread-model-selection-DcVebr8N.mjs";
+import { c as withExclusiveCodexAppServerThread, r as retainCodexAppServerBindingSubscription, t as isSameCodexAppServerThreadOwner } from "./thread-ownership-5X4197vk.mjs";
+import { a as refreshCodexThreadInstructions, i as assertCodexSupervisionThreadLineage, n as CodexThreadPolicyHandoffError, o as refreshCodexThreadPolicy, r as assertAdoptedCodexThreadResumeAllowed, t as CodexIncognitoPolicyChangeError } from "./thread-policy-BEecBTJM.mjs";
+import { t as resumeCodexAppServerThread } from "./thread-resume-BXY_6o6Z.mjs";
+import { r as readCodexMcpToolConnectorId } from "./mcp-tool-metadata-DW41snf3.mjs";
+import { n as disableCodexPluginThreadConfig } from "./dynamic-tool-build-BMiiFROa.mjs";
+import { n as CodexManagedHooksOnlyError, r as assertCodexNativeHookRelayAllowed } from "./native-hook-relay-CSZpcjwq.mjs";
+import { t as defaultCodexPluginMetadataCache } from "./plugin-metadata-cache-Bi8TAPwX.mjs";
+import { a as discardUnattestedCodexPluginThread, i as checkCodexThreadAppAvailability, n as resolveCodexNativeSkillIsolation, o as hasCodexNativeToolCatalog, r as attestCodexThreadToolSurface, s as loadCodexNativeToolCatalog, t as applyCodexNativeSkillIsolation } from "./native-skill-isolation-BAatEJZb.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, racePromiseWithAbortSignal } from "openclaw/plugin-sdk/time-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 { resolveAgentDir as resolveAgentDir$1 } from "openclaw/plugin-sdk/agent-runtime";
+import { AgentHarnessPreflightError, embeddedAgentLog, formatErrorMessage, isActiveHarnessContextEngine, isHostScopedAgentToolActive } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { buildCodexUserMcpServersThreadConfigPatchForRun } from "openclaw/plugin-sdk/codex-mcp-projection";
 import { isDiagnosticFlagEnabled } from "openclaw/plugin-sdk/diagnostic-flags";
-//#region extensions/codex/src/app-server/reasoning-effort.ts
-const CODEX_REASONING_EFFORTS = [
-	"minimal",
-	"low",
-	"medium",
-	"high",
-	"xhigh",
-	"max"
-];
-const LEGACY_PRO_REASONING_EFFORTS = [
-	"medium",
-	"high",
-	"xhigh"
-];
-const LEGACY_PRO_MODEL_ID_RE = /^gpt-5\.[45]-pro$/u;
-const MODERN_GPT_5_MODEL_ID_RE = /^gpt-5\.(?:[3-9]|[1-9]\d)(?:$|-)/u;
-/** Read reasoning metadata after the Codex app-server route has been selected. */
-function readCodexSupportedReasoningEfforts(compat) {
-	return compat && "supportedReasoningEfforts" in compat ? compat.supportedReasoningEfforts : void 0;
-}
-function resolveCodexAppServerReasoningEffort(params) {
-	if (params.thinkLevel === "ultra") return "ultra";
-	if (params.thinkLevel === "off") return params.supportedReasoningEfforts?.includes("none") ? "none" : null;
-	if (params.thinkLevel === "adaptive") return null;
-	const modelId = params.modelId.trim().toLowerCase();
-	const supportedReasoningEfforts = params.supportedReasoningEfforts ?? (LEGACY_PRO_MODEL_ID_RE.test(modelId) ? LEGACY_PRO_REASONING_EFFORTS : void 0);
-	if (supportedReasoningEfforts) return selectSupportedReasoningEffort({
-		requested: params.thinkLevel,
-		supportedEfforts: supportedReasoningEfforts.map((effort) => effort.trim().toLowerCase()),
-		effortOrder: CODEX_REASONING_EFFORTS
-	}) ?? null;
-	if (params.thinkLevel === "minimal" && MODERN_GPT_5_MODEL_ID_RE.test(modelId)) return "low";
-	return params.thinkLevel === "max" ? null : params.thinkLevel;
-}
-//#endregion
-//#region extensions/codex/src/app-server/thread-context-engine.ts
-function buildContextEngineBinding(params, projection) {
-	const contextEngine = isActiveHarnessContextEngine(params.contextEngine) ? params.contextEngine : void 0;
-	const engineId = contextEngine?.info?.id?.trim();
-	if (!contextEngine || !engineId) return;
-	return {
-		schemaVersion: 1,
-		engineId,
-		policyFingerprint: JSON.stringify({
-			schemaVersion: 1,
-			engineId,
-			engineVersion: contextEngine.info.version,
-			ownsCompaction: contextEngine.info.ownsCompaction === true,
-			turnMaintenanceMode: contextEngine.info.turnMaintenanceMode,
-			citationsMode: params.config?.memory?.citations,
-			contextTokenBudget: params.contextTokenBudget,
-			projectionMaxChars: resolveCodexContextEngineProjectionMaxChars({ contextTokenBudget: params.contextTokenBudget })
-		}),
-		projection: projection ? {
-			schemaVersion: 1,
-			mode: "thread_bootstrap",
-			epoch: projection.epoch,
-			fingerprint: projection.fingerprint
-		} : void 0
-	};
-}
-function isContextEngineBindingCompatible(previous, next) {
-	return previous?.schemaVersion === next.schemaVersion && previous.engineId === next.engineId && previous.policyFingerprint === next.policyFingerprint && areContextEngineProjectionBindingsCompatible(previous.projection, next.projection);
-}
-function areContextEngineProjectionBindingsCompatible(previous, next) {
-	if (!next) return previous === void 0;
-	return previous?.schemaVersion === next.schemaVersion && previous.mode === next.mode && previous.epoch === next.epoch && previous.fingerprint === next.fingerprint;
-}
-//#endregion
-//#region extensions/codex/src/app-server/native-model-input-tools.ts
-/** Stock native hooks flatten the configured V2 namespace without a delimiter. */
-function resolveCodexNativeModelInputTools(config) {
-	const features = isJsonObject(config.features) ? config.features : void 0;
-	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}spawn_agent`,
-			`${namespace}send_message`,
-			`${namespace}followup_task`
-		] : []
-	];
-}
-//#endregion
-//#region extensions/codex/src/app-server/profiler-flag.ts
-const PROFILER_FLAGS = ["profiler", "codex.profiler"];
-function isCodexAppServerProfilerEnabled(config, env = process.env) {
-	return PROFILER_FLAGS.some((flag) => isDiagnosticFlagEnabled(flag, config, env));
-}
-//#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;
@@ -168,10 +78,8 @@ function appToolHintsAllowed(tool, policy) {
 	return (policy.allowDestructiveActions || tool?.destructiveHint === false) && (policy.allowOpenWorld !== false || tool?.openWorldHint === false);
 }
 function intersectToolApprovalMode(captured, current) {
-	if (captured === current) return captured;
-	if (captured === "prompt" || current === "prompt") return "prompt";
+	if (captured === current || current === "approve") return captured;
 	if (captured === "approve") return current;
-	if (current === "approve") return captured;
 	return "prompt";
 }
 //#endregion
@@ -319,9 +227,9 @@ async function readCurrentCodexScheduledAppPolicy(params) {
 async function captureScheduledCodexAppAuthority(params) {
 	const requestedTimeoutMs = params.timeoutMs ?? CODEX_APP_AUTHORITY_CAPTURE_TIMEOUT_MS;
 	const timeoutMs = Math.min(CODEX_APP_AUTHORITY_CAPTURE_TIMEOUT_MS, Math.max(CODEX_APP_AUTHORITY_CAPTURE_MIN_TIMEOUT_MS, Number.isFinite(requestedTimeoutMs) ? Math.floor(requestedTimeoutMs) : CODEX_APP_AUTHORITY_CAPTURE_TIMEOUT_MS));
-	const deadlineMs = Date.now() + timeoutMs;
+	const deadlineMs = performance.now() + timeoutMs;
 	const boundedClient = { request: ((method, requestParams) => {
-		const remainingTimeoutMs = deadlineMs - Date.now();
+		const remainingTimeoutMs = deadlineMs - performance.now();
 		if (remainingTimeoutMs <= 0) throw new CodexScheduledAppAuthorityCaptureTimeoutError();
 		return params.client.request(method, requestParams, {
 			timeoutMs: remainingTimeoutMs,
@@ -435,9 +343,8 @@ function intersectCodexPluginThreadConfigWithScheduledAuthority(config, authorit
 	const appsPatch = asOptionalRecord(configPatch.apps);
 	for (const [appId, captured] of capturedById) {
 		const appPatch = asOptionalRecord(appsPatch?.[appId]);
-		if (!appPatch || !Object.hasOwn(apps, appId)) continue;
-		const currentApp = apps[appId];
-		if (!currentApp) continue;
+		const currentApp = Object.hasOwn(apps, appId) ? apps[appId] : void 0;
+		if (!appPatch || !currentApp) continue;
 		if (currentApp.destructiveApprovalMode === "ask") Object.assign(appPatch, buildCodexAppApprovalOverrides(currentPolicy.config, {
 			id: appId,
 			approvalOverrideToolConfigKeys: []
@@ -469,7 +376,6 @@ function intersectCodexPluginThreadConfigWithScheduledAuthority(config, authorit
 		policyContext
 	};
 }
-/** Returns the managed-requirements identity captured for a configured app-server job. */
 function readScheduledCodexAppManagedRequirementsFingerprint(authority) {
 	const auth = parseScheduledCodexAppAuthority(authority)?.auth;
 	return auth?.kind === "configured-app-server" ? auth.managedRequirementsFingerprint : void 0;
@@ -501,9 +407,188 @@ function buildScheduledCodexAppAuthorityInputFingerprint(baseFingerprint, author
 	});
 }
 //#endregion
+//#region extensions/codex/src/app-server/plugin-thread-config-deadline.ts
+/** Enforces one bounded startup budget across Codex plugin config discovery. */
+const CODEX_PLUGIN_THREAD_CONFIG_MAX_TIMEOUT_MS = 6e4;
+const CODEX_PLUGIN_THREAD_CONFIG_TIMEOUT_DIVISOR = 4;
+const CODEX_PLUGIN_THREAD_CONFIG_MIN_TIMEOUT_MS = 100;
+var CodexPluginThreadConfigDeadlineError = class extends Error {
+	constructor() {
+		super("Codex plugin thread config deadline elapsed");
+		this.name = "CodexPluginThreadConfigDeadlineError";
+	}
+};
+/** Resolves the plugin policy state reused throughout app-server startup. */
+function resolveCodexPluginThreadConfigStartupPolicy(params) {
+	const pluginThreadConfigRequired = params.hostedAppsSupported === false || Boolean(params.scheduledRuntimeAuthority) || !params.nativeToolSurfaceEnabled || shouldBuildCodexPluginThreadConfig(params.pluginConfig);
+	const pluginThreadConfigPluginConfig = params.hostedAppsSupported !== false && (params.nativeToolSurfaceEnabled || params.scheduledRuntimeAuthority) ? params.pluginConfig : disableCodexPluginThreadConfig(params.pluginConfig);
+	const resolvedPluginPolicy = pluginThreadConfigRequired ? resolveCodexPluginsPolicy(pluginThreadConfigPluginConfig) : void 0;
+	return {
+		pluginThreadConfigRequired,
+		pluginThreadConfigPluginConfig,
+		resolvedPluginPolicy,
+		enabledPluginConfigKeys: resolvedPluginPolicy ? resolvedPluginPolicy.pluginPolicies.filter((plugin) => plugin.enabled).map((plugin) => plugin.configKey).toSorted() : void 0
+	};
+}
+/** Builds plugin config without allowing sequential RPC timeouts to consume the turn. */
+async function buildCodexPluginThreadConfigWithinDeadline(params) {
+	const { requestTimeoutMs, signal, request, failClosedOnTimeout, transform, ...buildParams } = params;
+	signal.throwIfAborted();
+	const timeoutMs = resolveCodexPluginThreadConfigTimeoutMs(requestTimeoutMs);
+	const deadlineMs = performance.now() + timeoutMs;
+	let requestTimedOut = false;
+	const boundedRequest = async (method, requestParams) => {
+		const remainingTimeoutMs = deadlineMs - performance.now();
+		if (requestTimedOut || remainingTimeoutMs <= 0) throw new CodexPluginThreadConfigDeadlineError();
+		try {
+			return await request(method, requestParams, {
+				timeoutMs: remainingTimeoutMs,
+				signal
+			});
+		} catch (error) {
+			requestTimedOut ||= isCodexPluginThreadConfigTimeoutError(error);
+			throw error;
+		}
+	};
+	try {
+		return await withAbortableTimeout({
+			signal,
+			timeoutMs,
+			promise: (async () => {
+				const config = await buildCodexPluginThreadConfig({
+					...buildParams,
+					request: boundedRequest
+				});
+				const result = transform ? await transform(config, boundedRequest) : config;
+				if (requestTimedOut || performance.now() >= deadlineMs) throw new CodexPluginThreadConfigDeadlineError();
+				return result;
+			})(),
+			timeoutMessage: "Codex plugin thread config deadline elapsed",
+			createTimeoutError: () => new CodexPluginThreadConfigDeadlineError()
+		});
+	} catch (error) {
+		if (signal.aborted || !requestTimedOut && !isCodexPluginThreadConfigTimeoutError(error) && performance.now() < deadlineMs) throw error;
+		if (failClosedOnTimeout) throw new AgentHarnessPreflightError(`Codex app policy verification exceeded its ${timeoutMs} ms startup budget. No app tools were executed. Retry after Codex app inventory is responsive.`);
+		return buildCodexPluginThreadConfigTimeoutFallback({
+			pluginConfig: buildParams.pluginConfig,
+			appCacheKey: buildParams.appCacheKey,
+			message: `Codex plugin discovery exceeded its ${timeoutMs} ms startup budget; plugin apps were disabled for this turn.`
+		});
+	}
+}
+/** Captures fingerprint inputs before startup work and binds the provider at admission. */
+function prepareCodexPluginThreadConfigStartupProvider(prepared) {
+	const { startupPolicy, appCacheKey } = prepared;
+	if (!startupPolicy.pluginThreadConfigRequired) return;
+	const { pluginThreadConfigPluginConfig: pluginConfig, resolvedPluginPolicy: policy, enabledPluginConfigKeys } = startupPolicy;
+	const inputFingerprint = buildScheduledCodexAppAuthorityInputFingerprint(buildCodexPluginThreadConfigInputFingerprint({
+		pluginConfig,
+		appCacheKey
+	}), prepared.scheduledRuntimeAuthority);
+	return (params) => {
+		const { client, appCache, metadataCache: configuredMetadataCache, ...buildParams } = params;
+		const metadataCache = configuredMetadataCache ?? defaultCodexPluginMetadataCache;
+		return {
+			enabled: true,
+			requiresCurrentPolicyCheck: Boolean(policy?.enabled || params.scheduledRuntimeAuthority),
+			inputFingerprint,
+			enabledPluginConfigKeys,
+			accountAppRecoveryEnabled: policy?.allowAllPlugins,
+			recoverablePluginConfigKeys: policy ? resolveRecoverableCodexPluginConfigKeys({
+				policy,
+				metadataCache,
+				appCacheKey,
+				configCwd: params.configCwd
+			}) : void 0,
+			build: async (buildOptions) => {
+				const config = await buildCodexPluginThreadConfigWithinDeadline({
+					...buildParams,
+					pluginConfig,
+					appCacheKey,
+					threadId: buildOptions?.threadId,
+					appCache: appCache ?? defaultCodexAppInventoryCache,
+					metadataCache,
+					failClosedOnTimeout: Boolean(params.scheduledRuntimeAuthority),
+					transform: params.scheduledRuntimeAuthority ? async (builtConfig, request) => intersectCodexPluginThreadConfigWithScheduledAuthority(builtConfig, params.scheduledRuntimeAuthority, await readCurrentCodexScheduledAppPolicy({
+						request,
+						configCwd: params.configCwd,
+						threadId: buildOptions?.threadId
+					})) : void 0,
+					request: (method, requestParams, options) => client.request(method, requestParams, options)
+				});
+				return params.scheduledRuntimeAuthority && inputFingerprint ? {
+					...config,
+					inputFingerprint
+				} : config;
+			}
+		};
+	};
+}
+function resolveCodexPluginThreadConfigTimeoutMs(requestTimeoutMs) {
+	return Math.min(CODEX_PLUGIN_THREAD_CONFIG_MAX_TIMEOUT_MS, Math.max(CODEX_PLUGIN_THREAD_CONFIG_MIN_TIMEOUT_MS, Math.floor((Number.isFinite(requestTimeoutMs) && requestTimeoutMs > 0 ? requestTimeoutMs : CODEX_PLUGIN_THREAD_CONFIG_MAX_TIMEOUT_MS * CODEX_PLUGIN_THREAD_CONFIG_TIMEOUT_DIVISOR) / CODEX_PLUGIN_THREAD_CONFIG_TIMEOUT_DIVISOR)));
+}
+function isCodexPluginThreadConfigTimeoutError(error) {
+	return error instanceof CodexPluginThreadConfigDeadlineError || error instanceof Error && "code" in error && error.code === "CODEX_APP_SERVER_LOCAL_REQUEST_CANCELLED" && error.message.endsWith(" timed out");
+}
+//#endregion
+//#region extensions/codex/src/app-server/thread-context-engine.ts
+function buildContextEngineBinding(params, projection) {
+	const contextEngine = isActiveHarnessContextEngine(params.contextEngine) ? params.contextEngine : void 0;
+	const engineId = contextEngine?.info?.id?.trim();
+	if (!contextEngine || !engineId) return;
+	return {
+		schemaVersion: 1,
+		engineId,
+		policyFingerprint: JSON.stringify({
+			schemaVersion: 1,
+			engineId,
+			engineVersion: contextEngine.info.version,
+			ownsCompaction: contextEngine.info.ownsCompaction === true,
+			turnMaintenanceMode: contextEngine.info.turnMaintenanceMode,
+			citationsMode: params.config?.memory?.citations,
+			contextTokenBudget: params.contextTokenBudget,
+			projectionMaxChars: resolveCodexContextEngineProjectionMaxChars({ contextTokenBudget: params.contextTokenBudget })
+		}),
+		projection: projection ? {
+			schemaVersion: 1,
+			mode: "thread_bootstrap",
+			epoch: projection.epoch,
+			fingerprint: projection.fingerprint
+		} : void 0
+	};
+}
+function isContextEngineBindingCompatible(previous, next) {
+	const previousProjection = previous?.projection;
+	const nextProjection = next.projection;
+	return previous?.schemaVersion === next.schemaVersion && previous.engineId === next.engineId && previous.policyFingerprint === next.policyFingerprint && (!nextProjection ? previousProjection === void 0 : previousProjection?.schemaVersion === nextProjection.schemaVersion && previousProjection.mode === nextProjection.mode && previousProjection.epoch === nextProjection.epoch && previousProjection.fingerprint === nextProjection.fingerprint);
+}
+//#endregion
+//#region extensions/codex/src/app-server/native-model-input-tools.ts
+/** Stock native hooks flatten the configured V2 namespace without a delimiter. */
+function resolveCodexNativeModelInputTools(config) {
+	const features = isJsonObject(config.features) ? config.features : void 0;
+	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}spawn_agent`,
+			`${namespace}send_message`,
+			`${namespace}followup_task`
+		] : []
+	];
+}
+//#endregion
+//#region extensions/codex/src/app-server/profiler-flag.ts
+const PROFILER_FLAGS = ["profiler", "codex.profiler"];
+function isCodexAppServerProfilerEnabled(config, env = process.env) {
+	return PROFILER_FLAGS.some((flag) => isDiagnosticFlagEnabled(flag, config, env));
+}
+//#endregion
 //#region extensions/codex/src/app-server/thread-lifecycle-timing.ts
-const CODEX_THREAD_LIFECYCLE_TIMING_WARN_TOTAL_MS = 1e3;
-const CODEX_THREAD_LIFECYCLE_TIMING_WARN_STAGE_MS = 500;
 function createCodexThreadLifecycleTimingTracker(options = {}) {
 	const log = options.log ?? embeddedAgentLog;
 	const timing = createStageTimingTracker(options.now ?? Date.now);
@@ -518,8 +603,8 @@ function createCodexThreadLifecycleTimingTracker(options = {}) {
 			if (didLog) return;
 			const { totalMs, stages: spans } = timing.snapshot();
 			const detailed = options.enabled || log.isEnabled?.("trace");
-			const totalThresholdMs = options.totalThresholdMs ?? (detailed ? CODEX_THREAD_LIFECYCLE_TIMING_WARN_TOTAL_MS : 1e4);
-			const stageThresholdMs = options.stageThresholdMs ?? (detailed ? CODEX_THREAD_LIFECYCLE_TIMING_WARN_STAGE_MS : 5e3);
+			const totalThresholdMs = detailed ? 1e3 : 1e4;
+			const stageThresholdMs = detailed ? 500 : 5e3;
 			const shouldWarn = totalMs >= totalThresholdMs || spans.some((span) => span.durationMs >= stageThresholdMs);
 			if (!shouldWarn && !log.isEnabled?.("trace")) return;
 			didLog = true;
@@ -566,6 +651,7 @@ async function prepareCodexThreadRequestContext(params, options) {
 		agentDir: params.params.agentDir,
 		config: params.params.config
 	});
+	const startModelProvider = startModelSelection.modelProvider;
 	const source = params.params.hostCapabilities.retainSourceAuthority?.();
 	const modelPolicyEnforced = params.nativeModelAdmission === void 0 || options.preflight.nativeModelInputTools !== void 0;
 	let inference;
@@ -601,7 +687,7 @@ async function prepareCodexThreadRequestContext(params, options) {
 		...options.preflight,
 		bindingIdentity: options.bindingIdentity,
 		startModelSelection,
-		startModelProvider: startModelSelection.modelProvider,
+		startModelProvider,
 		normalizeBindingModelProvider: (authProfileId, modelProvider) => normalizeCodexAppServerBindingModelProvider({
 			authProfileId,
 			modelProvider,
@@ -609,6 +695,18 @@ async function prepareCodexThreadRequestContext(params, options) {
 			agentDir: params.params.agentDir,
 			config: params.params.config
 		}),
+		assertInferenceConfig: (config, modelProvider) => assertCodexInferenceRouteConfig(params.client, params.inferenceRoute, config, modelProvider, params.inferenceProviderRoutes),
+		buildResumeParams: (binding, authProfileId, config) => buildThreadResumeParams(params.params, {
+			...params,
+			threadId: binding.threadId,
+			authProfileId,
+			model: startModelSelection.model,
+			modelProvider: startModelProvider,
+			preserveNativeModel: binding.preserveNativeModel === true,
+			config,
+			hostSystemAgentActive: options.preflight.hostSystemAgentActive,
+			restrictedToolSurfaceInheritedMcpServerNames: options.preflight.restrictedToolSurfaceInheritedMcpServerNames
+		}),
 		throwIfAborted: options.throwIfAborted
 	};
 }
@@ -630,7 +728,7 @@ function resolveCodexThreadAgentDir(params) {
 		sessionKey: params.params.sessionKey,
 		agentId: params.agentId ?? params.params.agentId
 	}).sessionAgentId;
-	return params.agentDir ?? params.params.agentDir ?? resolveAgentDir$2(params.params.config ?? {}, agentId);
+	return params.agentDir ?? params.params.agentDir ?? resolveAgentDir$1(params.params.config ?? {}, agentId);
 }
 function buildCodexThreadBindingPolicy(params, preflight) {
 	return {
@@ -652,11 +750,14 @@ async function prepareCodexThreadFinalConfigPatch(params, nativeModelInputTools,
 			binding
 		} : { action: "start" },
 		...nativeModelInputTools ? { nativeModelInputTools } : {}
-	}) ?? {
-		configPatch: params.finalConfigPatch,
-		nativeHookRelayGeneration: params.nativeHookRelayGeneration
+	}, params.client) ?? {
+		configPatch: void 0,
+		nativeHookRelayGeneration: void 0
 	};
 }
+function buildCodexThreadRequestConfig(params, context, pluginConfigPatch, finalConfigPatch) {
+	return applyCodexNativeSkillIsolation(mergeCodexThreadConfigs(params.config, context.userMcpServersConfigPatch, pluginConfigPatch, finalConfigPatch), context.nativeSkillIsolation);
+}
 async function prepareCodexThreadLifecyclePreflight(params) {
 	let effectiveConfig = await assertCodexModelBackedReviewerEffectiveConfig({
 		client: params.client,
@@ -724,7 +825,7 @@ async function prepareCodexThreadLifecyclePreflight(params) {
 	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 }));
 	params.config = mergeCodexNativeProjectDocThreadConfig(params.config, effectiveConfig);
-	if (params.shellEnvironment) params.config = mergeCodexNativeShellEnvironment(params.config, effectiveConfig.config.shell_environment_policy);
+	if (params.shellEnvironment || params.shellGitConfigParameters) params.config = mergeCodexNativeShellEnvironment(params.config, effectiveConfig.config.shell_environment_policy);
 	const restrictedToolSurfaceInheritedMcpServerNames = restrictedToolSurface ? await lifecycleTiming.measure("restricted-tool-surface-mcp-policy", () => readCodexInheritedMcpServerNames(params.client, params.cwd, params.signal, effectiveConfig)) : [];
 	if (restrictedToolSurface || imageGenerationDenied || params.nativeCodeModeEnabled !== false) await lifecycleTiming.measure("tool-policy-config-requirements-read", () => assertCodexManagedRequirementsDoNotOverrideToolPolicy(params.client, {
 		restrictedToolSurface,
@@ -788,7 +889,7 @@ function recordCodexThreadReady(params, context, threadId, action) {
 	});
 }
 async function resumeExistingCodexThread(params, context) {
-	const { binding: resumeBinding, bindingIdentity, startModelSelection, startModelProvider, userMcpServersConfigPatch, dynamicToolsFingerprint, webSearchThreadConfigFingerprint, ringZeroConfigFingerprint, ringZeroClientInstanceId, hostSystemAgentActive, restrictedToolSurface, restrictedToolSurfaceInheritedMcpServerNames, nativeSkillIsolation, lifecycleTiming, normalizeBindingModelProvider, throwIfAborted, stageBindingReplacement } = context;
+	const { binding: resumeBinding, bindingIdentity, startModelProvider, dynamicToolsFingerprint, webSearchThreadConfigFingerprint, ringZeroConfigFingerprint, ringZeroClientInstanceId, restrictedToolSurface, lifecycleTiming, normalizeBindingModelProvider, throwIfAborted, stageBindingReplacement } = context;
 	let acceptedConfiguration;
 	let disposeConfiguration;
 	let resumeReservation;
@@ -810,18 +911,8 @@ async function resumeExistingCodexThread(params, context) {
 		const authProfileId = resumeBinding.connectionScope === "supervision" ? void 0 : params.params.authProfileId ?? resumeBinding.authProfileId;
 		const finalConfigPatch = context.prebuiltFinalConfigPatch ?? await prepareCodexThreadFinalConfigPatch(params, context.nativeModelInputTools, resumeBinding);
 		const pluginThreadConfig = context.prebuiltPluginThreadConfig ?? (params.pluginThreadConfig?.enabled ? await lifecycleTiming.measure("plugin-config-build", () => params.pluginThreadConfig?.build()) : void 0);
-		const resumeConfig = applyCodexNativeSkillIsolation(mergeCodexThreadConfigs(params.config, userMcpServersConfigPatch, pluginThreadConfig?.configPatch, finalConfigPatch.configPatch), nativeSkillIsolation);
-		const resumeParams = lifecycleTiming.measureSync("thread-resume-params", () => buildThreadResumeParams(params.params, {
-			...params,
-			threadId: resumeBinding.threadId,
-			authProfileId,
-			model: startModelSelection.model,
-			modelProvider: startModelProvider,
-			preserveNativeModel: resumeBinding.preserveNativeModel === true,
-			config: resumeConfig,
-			hostSystemAgentActive,
-			restrictedToolSurfaceInheritedMcpServerNames
-		}));
+		const resumeConfig = buildCodexThreadRequestConfig(params, context, pluginThreadConfig?.configPatch, finalConfigPatch.configPatch);
+		const resumeParams = lifecycleTiming.measureSync("thread-resume-params", () => context.buildResumeParams(resumeBinding, authProfileId, resumeConfig));
 		const requestModelProvider = typeof resumeParams.modelProvider === "string" && resumeParams.modelProvider.trim() ? resumeParams.modelProvider : void 0;
 		throwIfAborted();
 		resumeReservation = params.reserveResumeThread?.(resumeBinding.threadId);
@@ -833,7 +924,7 @@ async function resumeExistingCodexThread(params, context) {
 			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);
+				context.assertInferenceConfig(resumeParams.config, requestModelProvider ?? (resumeBinding.preserveNativeModel ? configuration.modelProvider ?? void 0 : void 0));
 			}
 		}));
 		acceptedConfiguration = configuration;
@@ -903,13 +994,11 @@ async function resumeExistingCodexThread(params, context) {
 			...resumeBinding,
 			threadId: response.thread.id,
 			...resumePatch,
-			liveThreadConfigFingerprint: fingerprintCodexThreadConfig({
-				...resumeParams,
-				model: resumeBinding.preserveNativeModel === true ? null : response.model ?? resumeParams.model ?? null,
-				requestedModel: resumeBinding.preserveNativeModel === true ? null : resumeParams.model ?? null,
-				modelProvider: resumeBinding.preserveNativeModel === true ? null : resumePatch.modelProvider ?? null,
-				requestedModelProvider: resumeBinding.preserveNativeModel === true ? null : resumeParams.modelProvider ?? resumePatch.modelProvider ?? null
-			}, authProfileId, dynamicToolsFingerprint),
+			liveThreadConfigFingerprint: fingerprintCodexThreadConfig(resumeParams, authProfileId, dynamicToolsFingerprint, {
+				model: response.model,
+				modelProvider: resumePatch.modelProvider ?? null,
+				preserveNativeModel: resumeBinding.preserveNativeModel
+			}),
 			lifecycle: {
 				action: "resumed",
 				...activeTurnIds.length ? { activeTurnIds } : {}
@@ -946,10 +1035,10 @@ async function resumeExistingCodexThread(params, context) {
 }
 async function startFreshCodexThread(params, context) {
 	const clientId = resolveCodexAppServerClientInstanceId(params.client);
-	const { bindingIdentity, startModelSelection, startModelProvider, userMcpServersConfigPatch, dynamicToolsFingerprint, webSearchThreadConfigFingerprint, ringZeroConfigFingerprint, ringZeroClientInstanceId, contextEngineBinding, hostSystemAgentActive, restrictedToolSurface, restrictedToolSurfaceInheritedMcpServerNames, nativeSkillIsolation, lifecycleTiming, normalizeBindingModelProvider, throwIfAborted, prebuiltPluginThreadConfig, preserveExistingBinding, rotatedContextEngineBinding, replacementPredecessor } = context;
+	const { bindingIdentity, startModelSelection, startModelProvider, dynamicToolsFingerprint, webSearchThreadConfigFingerprint, ringZeroConfigFingerprint, ringZeroClientInstanceId, contextEngineBinding, hostSystemAgentActive, restrictedToolSurface, restrictedToolSurfaceInheritedMcpServerNames, lifecycleTiming, normalizeBindingModelProvider, throwIfAborted, prebuiltPluginThreadConfig, preserveExistingBinding, rotatedContextEngineBinding, replacementPredecessor } = context;
 	const pluginThreadConfig = params.pluginThreadConfig?.enabled ? prebuiltPluginThreadConfig ?? await lifecycleTiming.measure("plugin-config-build", () => params.pluginThreadConfig?.build()) : void 0;
 	const finalConfigPatch = await prepareCodexThreadFinalConfigPatch(params, context.nativeModelInputTools);
-	const config = lifecycleTiming.measureSync("merge-thread-config", () => applyCodexNativeSkillIsolation(mergeCodexThreadConfigs(params.config, userMcpServersConfigPatch, pluginThreadConfig?.configPatch, finalConfigPatch.configPatch), nativeSkillIsolation));
+	const config = lifecycleTiming.measureSync("merge-thread-config", () => buildCodexThreadRequestConfig(params, context, pluginThreadConfig?.configPatch, finalConfigPatch.configPatch));
 	const startParams = lifecycleTiming.measureSync("thread-start-params", () => buildThreadStartParams(params.params, {
 		...params,
 		config,
@@ -966,7 +1055,7 @@ async function startFreshCodexThread(params, context) {
 	};
 	const assertInferenceCurrent = () => {
 		assertCurrent();
-		assertCodexInferenceRouteConfig(params.client, params.inferenceRoute, startParams.config, requestModelProvider, params.inferenceProviderRoutes);
+		context.assertInferenceConfig(startParams.config, requestModelProvider);
 	};
 	const threadStartResponse = await lifecycleTiming.measure("thread-start-request", async () => {
 		try {
@@ -1076,13 +1165,10 @@ async function startFreshCodexThread(params, context) {
 		...startedBinding,
 		modelProvider: response.modelProvider ?? requestModelProvider ?? startModelProvider ?? modelProvider,
 		liveThreadEphemeralPolicy: startParams.ephemeral ? createCodexEphemeralThreadPolicy(params) : void 0,
-		...!preserveExistingBinding ? { liveThreadConfigFingerprint: fingerprintCodexThreadConfig({
-			...startParams,
-			model: response.model ?? startParams.model ?? null,
-			requestedModel: startParams.model ?? null,
-			modelProvider: bindingModelProvider ?? null,
-			requestedModelProvider: startParams.modelProvider ?? bindingModelProvider ?? null
-		}, params.params.authProfileId, dynamicToolsFingerprint) } : {},
+		...!preserveExistingBinding ? { liveThreadConfigFingerprint: fingerprintCodexThreadConfig(startParams, params.params.authProfileId, dynamicToolsFingerprint, {
+			model: response.model,
+			modelProvider: bindingModelProvider ?? null
+		}) } : {},
 		lifecycle: {
 			action: "started",
 			...preserveExistingBinding ? { preserveExistingBinding: true } : {},
@@ -1152,7 +1238,7 @@ async function releaseCodexBoundLiveThread(options) {
 }
 /** Reuses one safely owned, fully matching subscription on its original client. */
 async function tryReuseCodexLiveThread(options) {
-	const { params, binding, bindingIdentity, clientId, dynamicToolsFingerprint, environmentSelectionFingerprint, hostSystemAgentActive, lifecycleTiming, nativeSkillIsolation, ringZeroActive, restrictedToolSurface, restrictedToolSurfaceInheritedMcpServerNames, startModelProvider, startModelSelection, throwIfAborted, userMcpServersConfigPatch } = options;
+	const { params, binding, bindingIdentity, clientId, dynamicToolsFingerprint, environmentSelectionFingerprint, lifecycleTiming, ringZeroActive, restrictedToolSurface, startModelSelection, throwIfAborted } = options;
 	const incognito = isIncognitoSessionKey(params.params.sessionKey);
 	if (incognito && (binding.preserveNativeModel || binding.connectionScope === "supervision")) {
 		if (binding.clientId === clientId && binding.clientId && ((await options.buildLoadedPluginThreadConfig(binding))?.fingerprint ?? binding.pluginAppsFingerprint) === binding.pluginAppsFingerprint) {
@@ -1160,7 +1246,7 @@ async function tryReuseCodexLiveThread(options) {
 				action: "resume",
 				binding,
 				...options.nativeModelInputTools ? { nativeModelInputTools: options.nativeModelInputTools } : {}
-			});
+			}, params.client);
 			throwIfAborted();
 			params.assertCurrent?.();
 			return {
@@ -1212,26 +1298,10 @@ async function tryReuseCodexLiveThread(options) {
 		const prebuiltFinalConfigPatch = await prepareCodexThreadFinalConfigPatch(params, options.nativeModelInputTools, binding);
 		const pluginAppsConfigPatch = pluginThreadConfig?.configPatch ?? (params.pluginThreadConfig?.enabled && binding.pluginAppPolicyContext ? buildCodexPluginAppsConfigPatchFromPolicyContext(binding.pluginAppPolicyContext) : void 0);
 		const resumeAuthProfileId = binding.connectionScope === "supervision" ? void 0 : params.params.authProfileId ?? binding.authProfileId;
-		const resumeConfig = mergeCodexThreadConfigs(params.config, userMcpServersConfigPatch, pluginAppsConfigPatch, prebuiltFinalConfigPatch.configPatch);
-		const resumeParams = lifecycleTiming.measureSync("warm-thread-resume-params", () => buildThreadResumeParams(params.params, {
-			...params,
-			threadId: binding.threadId,
-			authProfileId: resumeAuthProfileId,
-			model: startModelSelection.model,
-			modelProvider: startModelProvider,
-			preserveNativeModel: binding.preserveNativeModel === true,
-			config: applyCodexNativeSkillIsolation(resumeConfig, nativeSkillIsolation),
-			hostSystemAgentActive,
-			restrictedToolSurfaceInheritedMcpServerNames
-		}));
-		assertCodexInferenceRouteConfig(params.client, params.inferenceRoute, resumeParams.config, resumeParams.modelProvider ?? (binding.preserveNativeModel ? nativeThread?.modelProvider?.trim() || binding.modelProvider : void 0), params.inferenceProviderRoutes);
-		const liveThreadConfigFingerprint = incognito ? retainedThread.configFingerprint : fingerprintCodexThreadConfig({
-			...resumeParams,
-			model: binding.preserveNativeModel ? null : binding.model ?? resumeParams.model ?? null,
-			requestedModel: binding.preserveNativeModel ? null : resumeParams.model ?? null,
-			modelProvider: binding.preserveNativeModel ? null : binding.modelProvider ?? resumeParams.modelProvider ?? null,
-			requestedModelProvider: binding.preserveNativeModel ? null : resumeParams.modelProvider ?? binding.modelProvider ?? null
-		}, resumeAuthProfileId, dynamicToolsFingerprint);
+		const resumeConfig = buildCodexThreadRequestConfig(params, options, pluginAppsConfigPatch, prebuiltFinalConfigPatch.configPatch);
+		const resumeParams = lifecycleTiming.measureSync("warm-thread-resume-params", () => options.buildResumeParams(binding, resumeAuthProfileId, resumeConfig));
+		options.assertInferenceConfig(resumeParams.config, resumeParams.modelProvider ?? (binding.preserveNativeModel ? nativeThread?.modelProvider?.trim() || binding.modelProvider : void 0));
+		const liveThreadConfigFingerprint = incognito ? retainedThread.configFingerprint : fingerprintCodexThreadConfig(resumeParams, resumeAuthProfileId, dynamicToolsFingerprint, binding);
 		const ephemeralPolicy = retainedThread.ephemeralPolicy;
 		if (incognito && (!ephemeralPolicy || ephemeralPolicy.developerInstructions !== params.developerInstructions || getCodexInferenceThread(params.client, binding.threadId) !== params.inferenceRoute || [...params.inferenceProviderRoutes?.keys() ?? []].some((provider) => !getCodexInferenceThreadQualification(params.client, binding.threadId)?.hasProvider(provider)))) {
 			preserveSubscription = true;
@@ -1437,7 +1507,6 @@ async function preparePendingCodexThreadResume(params, binding, dynamicToolsFing
 	if (thread.id !== binding.threadId || !isCodexThreadNonRunning(thread.status)) throw fail("the native thread is not idle; wait for its current run to finish");
 	assertCodexThreadAcceptsDirectInput(thread);
 	const observation = observeCodexThreadConfiguration(params, thread, assertCurrent);
-	const dispose = observation.dispose;
 	try {
 		const rolloutPath = thread.path ?? binding.rolloutPath;
 		const metadata = rolloutPath ? await readCodexSessionMeta(path.join(localHome, "sessions"), rolloutPath, binding.threadId) : void 0;
@@ -1450,7 +1519,7 @@ async function preparePendingCodexThreadResume(params, binding, dynamicToolsFing
 			assertCurrent
 		};
 	} catch (error) {
-		dispose();
+		observation.dispose();
 		throw error;
 	}
 }
@@ -1512,16 +1581,11 @@ function withPendingSupervisionCleanup(pending, 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 {
+	for (const threadId of pending.cleanupThreadIds ?? []) 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;
+		if (message.includes("no rollout found for thread id") || message.includes("thread not found") || message.includes("already archived")) continue;
 		await unsubscribeCodexThreadBestEffort(client, {
 			threadId,
 			timeoutMs: CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS
@@ -1530,8 +1594,9 @@ async function archiveSupervisionArtifact(client, threadId) {
 			threadId,
 			error
 		});
-		return false;
+		remaining.push(threadId);
 	}
+	return remaining;
 }
 //#endregion
 //#region extensions/codex/src/app-server/thread-supervision.ts
@@ -1542,6 +1607,15 @@ async function materializePendingSupervisionBranch(params) {
 		assertCurrent: params.throwIfAborted,
 		withCurrent: params.authority?.withCurrent
 	};
+	const requestCreatedThread = (kind, request) => params.lifecycleTiming.measure(kind === "probe" ? "supervision-model-probe-fork" : "supervision-thread-start", async () => {
+		try {
+			return await request();
+		} catch (error) {
+			if (error instanceof CodexAppServerRpcError) throw kind === "probe" ? error : new CodexThreadStartRequestError(error);
+			throw new CodexAppServerUnsafeSubscriptionError(kind === "probe" ? "Codex model test fork may have materialized without a response" : "Canonical Codex branch may have started without a response", { cause: error });
+		}
+	});
+	const attestRestrictedToolSurface = (threadId, config) => params.lifecycleTiming.measure("restricted-tool-surface-mcp-attestation", () => attestCodexRestrictedToolSurfaceMcpServersDisabled(params.client, threadId, config ?? void 0, params.signal));
 	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");
 	pending = await recoverPendingSupervisionArtifacts(params, pending);
@@ -1553,7 +1627,7 @@ async function materializePendingSupervisionBranch(params) {
 	params.throwIfAborted();
 	const sourceThread = sourceResponse.thread;
 	if (sourceThread.id !== pending.sourceThreadId) throw new Error(`Codex supervision source read returned ${sourceThread.id} for ${pending.sourceThreadId}`);
-	assertPendingSupervisionSnapshotUnchanged(sourceThread, pending);
+	if (!pending.lastTurnId && (sourceThread.status?.type === "active" || (sourceThread.turns?.length ?? 0) > 0)) throw new Error("Codex source changed after Continue; reopen the source session before sending a message");
 	const history = projectBoundedCodexThreadHistory({
 		thread: sourceThread,
 		throughTurnId: pending.lastTurnId ?? null,
@@ -1590,35 +1664,27 @@ async function materializePendingSupervisionBranch(params) {
 	};
 	try {
 		const probeParams = buildPendingSupervisionProbeForkParams(params, pending);
-		const rawProbeResponse = await params.lifecycleTiming.measure("supervision-model-probe-fork", async () => {
-			try {
-				return await params.client.request("thread/fork", probeParams, requestOptions);
-			} catch (error) {
-				if (!(error instanceof CodexAppServerRpcError)) throw new CodexAppServerUnsafeSubscriptionError("Codex model probe fork may have materialized without a response", { cause: error });
-				throw error;
-			}
-		});
+		const rawProbeResponse = await requestCreatedThread("probe", () => params.client.request("thread/fork", probeParams, requestOptions));
 		const probeThreadId = requireDistinctSupervisionThreadId({
 			threadId: readSupervisionResponseThreadId(rawProbeResponse),
 			sourceThreadId: pending.sourceThreadId,
-			role: "model probe"
+			role: "model test"
 		});
 		let probeResponse;
 		try {
 			params.throwIfAborted();
 			probeResponse = assertCodexThreadForkResponse(rawProbeResponse);
-			if (params.restrictedToolSurface) await params.lifecycleTiming.measure("restricted-tool-surface-mcp-attestation", () => attestCodexRestrictedToolSurfaceMcpServersDisabled(params.client, probeThreadId, probeParams.config ?? void 0, params.signal));
+			if (params.restrictedToolSurface) await attestRestrictedToolSurface(probeThreadId, probeParams.config);
 		} finally {
 			await unsubscribeCodexAppServerLiveThread(params.client, probeThreadId, CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS).catch((cause) => {
-				throw new CodexAppServerUnsafeSubscriptionError(`Codex model probe subscription could not be released: ${probeThreadId}`, { cause });
+				throw new CodexAppServerUnsafeSubscriptionError(`Codex model test subscription could not be released: ${probeThreadId}`, { cause });
 			});
 		}
 		params.throwIfAborted();
 		const nativeModel = requireNonBlankSupervisionValue(probeResponse.model, "native model");
-		const nativeModelProvider = requireNativeSupervisionModelProvider({
-			responseModelProvider: probeResponse.modelProvider,
-			responseThreadModelProvider: probeResponse.thread.modelProvider
-		});
+		const nativeModelProvider = requireNonBlankSupervisionValue(probeResponse.modelProvider, "native model provider");
+		const threadProvider = probeResponse.thread.modelProvider?.trim();
+		if (threadProvider && threadProvider !== nativeModelProvider) throw new Error(`Codex supervision model provider mismatch: ${nativeModelProvider} != ${threadProvider}`);
 		const nativeAttempt = {
 			...params.attempt,
 			modelId: nativeModel
@@ -1633,14 +1699,7 @@ async function materializePendingSupervisionBranch(params) {
 			modelProvider: nativeModelProvider,
 			operation: "thread/start request"
 		});
-		const rawStartResponse = await params.lifecycleTiming.measure("supervision-thread-start", async () => {
-			try {
-				return await params.client.request("thread/start", startParams, requestOptions);
-			} catch (error) {
-				if (error instanceof CodexAppServerRpcError) throw new CodexThreadStartRequestError(error);
-				throw new CodexAppServerUnsafeSubscriptionError("Canonical Codex branch may have started without a response", { cause: error });
-			}
-		});
+		const rawStartResponse = await requestCreatedThread("canonical", () => params.client.request("thread/start", startParams, requestOptions));
 		const finalThreadId = requireDistinctSupervisionThreadId({
 			threadId: readSupervisionResponseThreadId(rawStartResponse),
 			sourceThreadId: pending.sourceThreadId,
@@ -1655,7 +1714,7 @@ async function materializePendingSupervisionBranch(params) {
 			modelProvider: nativeModelProvider,
 			operation: "thread/start response"
 		});
-		if (params.restrictedToolSurface) await params.lifecycleTiming.measure("restricted-tool-surface-mcp-attestation", () => attestCodexRestrictedToolSurfaceMcpServersDisabled(params.client, finalThreadId, startParams.config, params.signal));
+		if (params.restrictedToolSurface) await attestRestrictedToolSurface(finalThreadId, startParams.config);
 		if (params.provisionalAppIds?.length) try {
 			await params.lifecycleTiming.measure("plugin-app-attestation", () => checkCodexThreadAppAvailability({
 				client: params.client,
@@ -1705,14 +1764,7 @@ async function materializePendingSupervisionBranch(params) {
 				provisionalCleanupSafe = false;
 				throw new CodexAppServerUnsafeSubscriptionError(`Canonical Codex branch binding could not be verified: ${finalThreadId}`, { cause: new AggregateError([error, readError]) });
 			}
-			if (matchesMaterializedSupervisionBranch(current, {
-				sourceThreadId: pending.sourceThreadId,
-				connectionFingerprint,
-				threadId: finalThreadId,
-				model: nativeModel,
-				modelProvider: bindingModelProvider,
-				historyCoveredThrough
-			})) committed = true;
+			if (current?.threadId === finalThreadId && current.connectionScope === "supervision" && current.supervisionSourceThreadId === pending.sourceThreadId && current.appServerRuntimeFingerprint === connectionFingerprint && current.pendingSupervisionBranch === void 0 && current.model === nativeModel && current.modelProvider === bindingModelProvider && current.historyCoveredThrough === historyCoveredThrough) committed = true;
 			else {
 				if (!matchesPendingSupervisionState(current, pending)) {
 					provisionalCleanupSafe = false;
@@ -1747,8 +1799,8 @@ async function materializePendingSupervisionBranch(params) {
 			await params.abandonClient();
 			throw error;
 		}
-		const cleanup = await cleanPendingSupervisionArtifacts(params.client, pending);
-		const nextPending = withPendingSupervisionCleanup(pending, cleanup.remaining);
+		const remaining = await cleanPendingSupervisionArtifacts(params.client, pending);
+		const nextPending = withPendingSupervisionCleanup(pending, remaining);
 		let cleanupStateError;
 		if (cleanupExpected && !isDeepStrictEqual(cleanupExpected, nextPending)) try {
 			await params.bindingStore.mutate(params.bindingIdentity, {
@@ -1759,14 +1811,14 @@ async function materializePendingSupervisionBranch(params) {
 		} catch (stateError) {
 			cleanupStateError = stateError;
 		}
-		const unsafeCleanup = cleanup.remaining.length > 0 || error instanceof CodexAppServerUnsafeSubscriptionError;
+		const unsafeCleanup = 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 });
 			if (unsafeCleanup) throw new CodexAppServerUnsafeSubscriptionError("Codex supervised branch cleanup state could not be recorded", { cause });
 			throw cause;
 		}
-		if (cleanup.remaining.length > 0) throw new CodexAppServerUnsafeSubscriptionError(`Codex supervised branch cleanup remains pending: ${cleanup.remaining.join(", ")}`, { cause: error });
+		if (remaining.length > 0) throw new CodexAppServerUnsafeSubscriptionError(`Codex supervised branch cleanup remains pending: ${remaining.join(", ")}`, { cause: error });
 		throw error;
 	}
 }
@@ -1781,32 +1833,22 @@ function buildPendingSupervisionProbeForkParams(params, pending) {
 		...codexThreadSandboxOrPermissions(params.appServer),
 		...params.appServer.serviceTier !== void 0 ? { serviceTier: params.appServer.serviceTier } : {},
 		config: runtimeConfig,
-		developerInstructions: params.developerInstructions ?? buildDeveloperInstructions(params.attempt, { dynamicTools: params.dynamicTools }),
+		developerInstructions: params.developerInstructions ?? buildDeveloperInstructions(params.attempt, {
+			dynamicTools: params.dynamicTools,
+			nativeCodeModeOnlyEnabled: runtimeConfig["features.code_mode_only"] === true
+		}),
 		ephemeral: true,
 		threadSource: "appServer",
 		excludeTurns: true
 	};
 }
-function assertPendingSupervisionSnapshotUnchanged(thread, pending) {
-	if (pending.lastTurnId) return;
-	if (thread.status?.type === "active" || (thread.turns?.length ?? 0) > 0) throw new Error("Codex source changed after Continue; reopen the source session before sending a message");
-}
 function requireNonBlankSupervisionValue(value, label) {
 	if (typeof value !== "string" || !value.trim()) throw new Error(`Codex supervision ${label} is missing`);
 	return value.trim();
 }
-function requireNativeSupervisionModelProvider(params) {
-	const responseProvider = requireNonBlankSupervisionValue(params.responseModelProvider, "native model provider");
-	const threadProvider = params.responseThreadModelProvider?.trim();
-	if (threadProvider && threadProvider !== responseProvider) throw new Error(`Codex supervision model provider mismatch: ${responseProvider} != ${threadProvider}`);
-	return responseProvider;
-}
 function matchesPendingSupervisionState(binding, expected) {
 	return binding?.connectionScope === "supervision" && binding.supervisionSourceThreadId === expected.sourceThreadId && matchesPendingSupervisionBranch(binding, expected);
 }
-function matchesMaterializedSupervisionBranch(binding, expected) {
-	return binding?.threadId === expected.threadId && binding.connectionScope === "supervision" && binding.supervisionSourceThreadId === expected.sourceThreadId && binding.appServerRuntimeFingerprint === expected.connectionFingerprint && binding.pendingSupervisionBranch === void 0 && binding.model === expected.model && binding.modelProvider === expected.modelProvider && binding.historyCoveredThrough === expected.historyCoveredThrough;
-}
 function requireDistinctSupervisionThreadId(params) {
 	let threadId;
 	try {
@@ -1819,17 +1861,17 @@ function requireDistinctSupervisionThreadId(params) {
 }
 async function recoverPendingSupervisionArtifacts(params, pending) {
 	if (!pending.cleanupThreadIds?.length) return pending;
-	const cleanup = await cleanPendingSupervisionArtifacts(params.client, pending);
-	const next = withPendingSupervisionCleanup(pending, cleanup.remaining);
-	const incomplete = cleanup.remaining.length > 0;
-	if (!incomplete || cleanup.remaining.length !== pending.cleanupThreadIds.length) {
+	const remaining = await cleanPendingSupervisionArtifacts(params.client, pending);
+	const next = withPendingSupervisionCleanup(pending, remaining);
+	const incomplete = remaining.length > 0;
+	if (!incomplete || 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 (incomplete) throw new Error(`Codex supervised branch cleanup must finish before retry: ${cleanup.remaining.join(", ")}`);
+	if (incomplete) throw new Error(`Codex supervised branch cleanup must finish before retry: ${remaining.join(", ")}`);
 	return next;
 }
 //#endregion
@@ -1863,7 +1905,7 @@ async function startOrResumeThread(input) {
 		}
 		const preflight = await prepareCodexThreadLifecyclePreflight(params);
 		const callerConfig = params.config;
-		const { contextEngineBinding, dynamicToolsContainDeferred, dynamicToolsFingerprint, hostSystemAgentActive, legacyDynamicToolsFingerprint, legacyUserMcpServersFingerprint, lifecycleTiming, nativeSkillIsolation, nativeSkillIsolationFingerprint, networkProxyConfigFingerprint, ringZeroActive, ringZeroClientInstanceId, ringZeroConfigFingerprint, restrictedToolSurface, restrictedToolSurfaceInheritedMcpServerNames, userMcpServersConfigPatch, userMcpServersFingerprint, webSearchThreadConfigFingerprint } = preflight;
+		const { contextEngineBinding, dynamicToolsContainDeferred, dynamicToolsFingerprint, hostSystemAgentActive, legacyDynamicToolsFingerprint, legacyUserMcpServersFingerprint, lifecycleTiming, nativeSkillIsolationFingerprint, networkProxyConfigFingerprint, ringZeroActive, ringZeroClientInstanceId, ringZeroConfigFingerprint, restrictedToolSurface, restrictedToolSurfaceInheritedMcpServerNames, userMcpServersFingerprint, webSearchThreadConfigFingerprint } = preflight;
 		let replacementPredecessor;
 		const initialBoundThreadId = binding?.threadId;
 		const initialBoundClientId = binding?.clientId;
@@ -1899,37 +1941,22 @@ async function startOrResumeThread(input) {
 			const pendingBinding = binding;
 			const pluginThreadConfig = params.pluginThreadConfig?.enabled ? await lifecycleTiming.measure("plugin-config-build", () => params.pluginThreadConfig?.build()) : void 0;
 			const finalConfigPatch = await prepareCodexThreadFinalConfigPatch(params, requestContext.nativeModelInputTools);
-			const config = lifecycleTiming.measureSync("merge-thread-config", () => applyCodexNativeSkillIsolation(mergeCodexThreadConfigs(params.config, userMcpServersConfigPatch, pluginThreadConfig?.configPatch, finalConfigPatch.configPatch), nativeSkillIsolation));
+			const config = lifecycleTiming.measureSync("merge-thread-config", () => buildCodexThreadRequestConfig(params, preflight, pluginThreadConfig?.configPatch, finalConfigPatch.configPatch));
 			return publishCodexThreadInferenceBinding(params, await materializePendingSupervisionBranch({
-				client: params.client,
+				...params,
 				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,
-				refreshableInstructions: params.refreshableInstructions,
 				config,
-				nativeCodeModeEnabled: params.nativeCodeModeEnabled,
-				nativeProviderWebSearchSupport: params.nativeProviderWebSearchSupport,
-				nativeCodeModeOnlyEnabled: params.nativeCodeModeOnlyEnabled,
-				webSearchAllowed: params.webSearchAllowed,
 				hostSystemAgentActive,
 				restrictedToolSurface,
 				restrictedToolSurfaceInheritedMcpServerNames,
-				shellEnvironment: params.shellEnvironment,
-				shellPathPrepend: params.shellPathPrepend,
-				disableLoginShell: params.disableLoginShell,
-				environmentSelection: params.environmentSelection,
 				provisionalAppIds: pluginThreadConfig?.provisionalAppIds,
-				signal: params.signal,
 				throwIfAborted: () => {
 					params.assertCurrent?.();
-					assertCodexInferenceRouteConfig(params.client, params.inferenceRoute, config, void 0, params.inferenceProviderRoutes);
+					requestContext.assertInferenceConfig(config);
 				},
 				lifecycleTiming,
 				normalizeBindingModelProvider: requestContext.normalizeBindingModelProvider,
@@ -1977,30 +2004,30 @@ async function startOrResumeThread(input) {
 			releaseRetainedThread: (threadId, assertCurrent) => releaseRetainedThread(threadId, initialBoundClientId, assertCurrent),
 			transientRestriction: transientDelegationRestriction || transientNativeToolRestriction || transientWebSearchRestriction
 		}));
-		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 });
-			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 });
-			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
-		})) rotateStaleBinding(binding, "runtime identity", { connectionClass: params.appServer.connectionClass });
-		if (binding?.threadId && shouldRotateCodexGpt56MultiAgentBinding({
-			bindingModel: binding.model,
-			requestedModel: params.params.modelId
-		})) {
-			embeddedAgentLog.debug("codex app-server GPT-5.6 multi-agent version changed; starting a new thread", {
-				threadId: binding.threadId,
+		if (binding?.threadId) {
+			if (!restrictedToolSurface && binding.nativeToolPolicyRestricted === true) stageBindingReplacement("rotating a host-policy-restricted thread binding");
+			else if (binding.nativeSkillIsolationFingerprint !== nativeSkillIsolationFingerprint) {
+				embeddedAgentLog.debug("codex app-server native skill isolation changed; starting a new thread", { threadId: binding.threadId });
+				stageBindingReplacement("rotating stale native skill isolation");
+			} else if ((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 });
+				stageBindingReplacement("rotating a ring-zero thread binding");
+			} else if (shouldRotateCodexAppServerBindingForRuntime({
+				connectionClass: params.appServer.connectionClass,
+				current: binding.connectionScope === "supervision" ? buildCodexAppServerConnectionFingerprint(params.appServer, params.params.agentDir) : params.appServerRuntimeFingerprint,
+				binding: binding.appServerRuntimeFingerprint
+			})) rotateStaleBinding(binding, "runtime identity", { connectionClass: params.appServer.connectionClass });
+			else if (shouldRotateCodexGpt56MultiAgentBinding({
 				bindingModel: binding.model,
 				requestedModel: params.params.modelId
-			});
-			stageBindingReplacement("rotating a GPT-5.6 multi-agent thread binding");
+			})) {
+				embeddedAgentLog.debug("codex app-server GPT-5.6 multi-agent version changed; starting a new thread", {
+					threadId: binding.threadId,
+					bindingModel: binding.model,
+					requestedModel: params.params.modelId
+				});
+				stageBindingReplacement("rotating a GPT-5.6 multi-agent thread binding");
+			}
 		}
 		selectionBinding = binding;
 		let preserveExistingBinding = transientDelegationRestriction || !ringZeroActive && params.nativeProviderWebSearchSupport === "unknown" && !binding?.threadId;
@@ -2078,23 +2105,21 @@ async function startOrResumeThread(input) {
 				rotatedContextEngineBinding = true;
 			}
 		}
-		if (binding?.threadId && !areUserMcpServersFingerprintsCompatible({
-			previous: binding.userMcpServersFingerprint,
-			next: userMcpServersFingerprint,
-			nextLegacy: legacyUserMcpServersFingerprint
-		})) 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({
+			if (!areUserMcpServersFingerprintsCompatible({
+				previous: binding.userMcpServersFingerprint,
+				next: userMcpServersFingerprint,
+				nextLegacy: legacyUserMcpServersFingerprint
+			})) rotateStaleBinding(binding, "user MCP config");
+			else if (binding.networkProxyConfigFingerprint !== networkProxyConfigFingerprint || binding.networkProxyProfileName !== params.appServer.networkProxy?.profileName) rotateStaleBinding(binding, "network proxy config");
+			else if (isCodexPluginThreadBindingStale({
 				codexPluginsEnabled: params.pluginThreadConfig?.enabled ?? false,
 				bindingFingerprint: binding.pluginAppsFingerprint,
 				bindingInputFingerprint: binding.pluginAppsInputFingerprint,
 				currentInputFingerprint: params.pluginThreadConfig?.inputFingerprint,
 				hasBindingPolicyContext: Boolean(binding.pluginAppPolicyContext)
 			})) rotateStaleBinding(binding, "plugin app config");
-		}
-		if (binding?.threadId) {
-			if (binding.dynamicToolsFingerprint && params.dynamicTools.length > 0 && binding.dynamicToolsContainDeferred !== dynamicToolsContainDeferred && (binding.dynamicToolsContainDeferred !== void 0 || !dynamicToolsContainDeferred)) rotateStaleBinding(binding, "dynamic tool loading");
+			else 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({
@@ -2155,169 +2180,4 @@ async function startOrResumeThread(input) {
 	});
 }
 //#endregion
-//#region extensions/codex/src/app-server/user-input.ts
-function prependHistoryProvenance(input, historyProvenancePrefix) {
-	if (!historyProvenancePrefix) return input;
-	const firstTextIndex = input.findIndex((item) => item.type === "text");
-	if (firstTextIndex === -1) return [{
-		type: "text",
-		text: historyProvenancePrefix,
-		text_elements: []
-	}, ...input];
-	return input.map((item, index) => index === firstTextIndex && item.type === "text" ? {
-		...item,
-		text: `${historyProvenancePrefix}${item.text}`
-	} : item);
-}
-/** Builds ordered Codex user input for both new turns and same-turn steering. */
-function buildCodexUserInput(text, images, contextImageGroups, historyProvenancePrefix) {
-	if (text !== void 0 && contextImageGroups?.length) {
-		let offset = 0;
-		return prependHistoryProvenance([...contextImageGroups.flatMap((group) => {
-			const parts = buildCodexUserInput(text.slice(offset, group.end), group.images);
-			offset = group.end;
-			return parts;
-		}), ...buildCodexUserInput(text.slice(offset), images)], historyProvenancePrefix);
-	}
-	const imageInputs = (images ?? []).map((image) => {
-		const imageUrl = sanitizeInlineImageDataUrl(`data:${image.mimeType};base64,${image.data}`);
-		return imageUrl ? {
-			type: "image",
-			url: imageUrl
-		} : {
-			type: "text",
-			text: invalidInlineImageText("codex user input"),
-			text_elements: []
-		};
-	});
-	return prependHistoryProvenance([...text === void 0 ? [] : [{
-		type: "text",
-		text,
-		text_elements: []
-	}], ...imageInputs], historyProvenancePrefix);
-}
-//#endregion
-//#region extensions/codex/src/app-server/turn-params.ts
-const CODEX_CURRENT_SENDER_FIELD_MAX_CHARS = 256;
-function readCodexCurrentSender(params) {
-	const metadata = asOptionalRecord(asOptionalRecord(params.userTurnTranscriptRecorder?.message)?.["__openclaw"]);
-	const recorded = [
-		normalizeOptionalString(metadata?.["senderId"]),
-		normalizeOptionalString(metadata?.["senderName"]),
-		normalizeOptionalString(metadata?.["senderUsername"])
-	];
-	const [id, name, username] = recorded.some(Boolean) ? recorded : [
-		normalizeOptionalString(params.senderId),
-		normalizeOptionalString(params.senderName),
-		normalizeOptionalString(params.senderUsername)
-	];
-	if (!id && !name && !username) return;
-	const bound = (value) => truncateUtf16Safe(value, CODEX_CURRENT_SENDER_FIELD_MAX_CHARS);
-	return {
-		...id ? { id: bound(id) } : {},
-		...name ? { name: bound(name) } : {},
-		...username ? { username: bound(username) } : {}
-	};
-}
-function buildCodexHistoryProvenancePrefix(params) {
-	const sender = readCodexCurrentSender(params);
-	return sender?.id ? neutralizeCodexExplicitMentionSigils(`[OpenClaw conversation info: sender=${JSON.stringify(sender)}]\n`) : void 0;
-}
-function buildTurnStartParams(params, options) {
-	const modelSelection = options.preserveNativeTurnSettings ? void 0 : resolveCodexAppServerRequestModelSelection({
-		homeScope: options.appServer.start.homeScope,
-		model: options.model ?? params.modelId,
-		modelProvider: options.modelProvider,
-		authProfileId: params.authProfileId,
-		authProfileStore: params.authProfileStore,
-		agentDir: params.agentDir,
-		config: params.config
-	});
-	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;
-	const additionalContext = {
-		...buildCodexTemporalAdditionalContext(params, { sessionStatusAvailable: options.sessionStatusAvailable === true }),
-		openclaw_active_computer: {
-			kind: "application",
-			value: params.hostCapabilities.activeComputerContext?.() ?? "Current active computer: active_node=unknown (host presence unavailable)"
-		},
-		openclaw_source_delivery: {
-			kind: "application",
-			value: ["Current source-delivery policy for this turn (replaces earlier source-delivery guidance):", buildHarnessVisibleReplyGuidance({
-				sourceReplyDeliveryMode: params.sourceReplyDeliveryMode,
-				messageToolAvailable: options.messageToolAvailable === true,
-				requireExplicitMessageTarget: options.requireExplicitMessageTarget
-			})].join("\n")
-		}
-	};
-	if (currentSender) additionalContext.openclaw_current_sender = {
-		kind: "untrusted",
-		value: JSON.stringify({ sender: currentSender })
-	};
-	if (params.permissionChange?.notice) additionalContext.openclaw_permission_change = {
-		kind: "application",
-		value: params.permissionChange.notice
-	};
-	return {
-		threadId: options.threadId,
-		...params.trigger ? { turnTrigger: params.trigger } : {},
-		input: [...buildCodexUserInput(options.promptText ?? params.prompt, params.images, options.contextImageGroups, options.historyProvenancePrefix ?? (params.trigger === "user" ? buildCodexHistoryProvenancePrefix(params) : void 0)), ...options.explicitSkillInputs ?? []],
-		additionalContext,
-		cwd: options.cwd,
-		...options.appServer.sessionRoot ? { runtimeWorkspaceRoots: [options.appServer.sessionRoot] } : {},
-		approvalPolicy: options.appServer.approvalPolicy,
-		approvalsReviewer: options.appServer.approvalsReviewer,
-		...useThreadPermissionProfile ? {} : { sandboxPolicy: options.sandboxPolicy ?? codexSandboxPolicyForTurn(options.appServer.sandbox, options.appServer.sessionRoot ?? options.cwd, options.appServer.start?.args) },
-		...modelSelection ? {
-			model: modelSelection.model,
-			personality: CODEX_NATIVE_PERSONALITY_NONE
-		} : {},
-		...options.appServer.serviceTier !== void 0 ? { serviceTier: options.appServer.serviceTier } : options.clearInheritedServiceTier ? { serviceTier: null } : {},
-		...collaborationMode ? {
-			effort: collaborationMode.settings.reasoning_effort,
-			collaborationMode
-		} : {},
-		...params.requireWorkspaceOnly === true ? { environments: [] } : options.environmentSelection ? { environments: options.environmentSelection } : {}
-	};
-}
-function buildCodexTemporalAdditionalContext(params, options) {
-	return { openclaw_temporal_context: {
-		kind: "application",
-		value: buildTemporalContextText({
-			configuredTimezone: params.config?.agents?.defaults?.userTimezone,
-			sessionStatusAvailable: options.sessionStatusAvailable
-		})
-	} };
-}
-function buildTurnCollaborationMode(params, options = {}) {
-	const model = options.model ?? params.modelId;
-	return {
-		mode: "default",
-		settings: {
-			model,
-			reasoning_effort: resolveCodexAppServerReasoningEffort({
-				thinkLevel: params.thinkLevel,
-				modelId: model,
-				supportedReasoningEfforts: readCodexSupportedReasoningEfforts(params.model?.compat)
-			}),
-			developer_instructions: params.trigger === "cron" ? buildCronCollaborationInstructions() : null
-		}
-	};
-}
-function buildCodexParentLocalInstructions(params, options = {}) {
-	const contextInstructions = joinPresentSections(options.personaInstructions, options.skillsInstructions, options.memoryInstructions);
-	if (params.trigger === "cron") return joinPresentSections(buildCronCollaborationInstructions(), contextInstructions);
-	return contextInstructions || null;
-}
-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.",
-		"Execute the cron payload directly. If it asks you to run an exact command, run that command before doing any investigation, planning, memory review, or workspace bootstrap.",
-		"Use context already provided by the runtime, but do not spend time loading or re-reading workspace bootstrap, memory, or project-doc files before executing the cron payload. Inspect those files only if the payload asks for them or the command fails and they are needed to diagnose it.",
-		"Keep output concise and automation-oriented. Prefer the final command result or a short failure summary over status narration."
-	].join("\n\n");
-}
-//#endregion
-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 };
+export { prepareCodexPluginThreadConfigStartupProvider as a, buildLegacyScheduledCodexAppRecoveryPrompt as c, resolveScheduledCodexAppCreatorCaptureDecision as d, isContextEngineBindingCompatible as i, buildScheduledCodexAppServerConnectionIdentity as l, isCodexAppServerProfilerEnabled as n, resolveCodexPluginThreadConfigStartupPolicy as o, buildContextEngineBinding as r, assertScheduledCodexAppAuthorityRuntime as s, startOrResumeThread as t, captureScheduledCodexAppAuthority as u };