@openclaw/codex 2026.9.5 → 2026.9.7

package/dist/.setup/thread-lifecycle-DPflntEJ.mjs

@@ -0,0 +1,2362 @@
+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 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-DJIgqgMw.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 { 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-DqyTMYug.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-N0JpgSzF.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-DOP-cW5j.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-B_bRnMGN.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-DTd-DtkX.mjs";
+import { t as resumeCodexAppServerThread } from "./thread-resume-CdDaoc7T.mjs";
+import { c as withExclusiveCodexAppServerThread, r as retainCodexAppServerBindingSubscription, t as isSameCodexAppServerThreadOwner } from "./thread-ownership-roNP0l1c.mjs";
+import "./transcript-mirror-kxmCYsuF.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 { 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 { 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";
+//#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 [
+		"multi_agent_v1send_input",
+		"send_message",
+		"followup_task",
+		...namespace ? [`${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/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;
+}
+function readCurrentToolPolicy(config, appId, toolName, metadata, fallbackApprovalMode = "auto") {
+	const apps = asOptionalRecord(config.apps);
+	const app = asOptionalRecord(apps?.[appId]);
+	const defaults = asOptionalRecord(apps?.["_default"]);
+	const tools = asOptionalRecord(app?.tools);
+	const tool = asOptionalRecord(tools?.[toolName] ?? (metadata?.title !== void 0 ? tools?.[metadata.title] : void 0));
+	const toolApprovalMode = normalizeAppToolApprovalMode(tool?.approval_mode);
+	let approvalMode = toolApprovalMode ?? normalizeAppToolApprovalMode(app?.default_tools_approval_mode) ?? normalizeAppToolApprovalMode(defaults?.default_tools_approval_mode) ?? fallbackApprovalMode;
+	if (!toolApprovalMode) {
+		const links = asOptionalRecord(app?.links);
+		if (metadata?.requiresExplicitLinkId) for (const link of Object.values(links ?? {})) {
+			const linkMode = normalizeAppToolApprovalMode(asOptionalRecord(link)?.default_tools_approval_mode);
+			if (linkMode) approvalMode = intersectToolApprovalMode(approvalMode, linkMode);
+		}
+		else if (metadata?.linkId) approvalMode = normalizeAppToolApprovalMode(asOptionalRecord(links?.[metadata.linkId])?.default_tools_approval_mode) ?? approvalMode;
+	}
+	const defaultToolsEnabled = app?.default_tools_enabled;
+	return {
+		enabled: (app ? app.enabled !== false : defaults?.enabled !== false) && (typeof tool?.enabled === "boolean" ? tool.enabled : typeof defaultToolsEnabled === "boolean" ? defaultToolsEnabled : appToolHintsAllowed(metadata, {
+			allowDestructiveActions: (app?.destructive_enabled ?? defaults?.destructive_enabled) !== false,
+			allowOpenWorld: (app?.open_world_enabled ?? defaults?.open_world_enabled) !== false
+		})),
+		approvalMode
+	};
+}
+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 === "approve") return current;
+	if (current === "approve") return captured;
+	return "prompt";
+}
+//#endregion
+//#region extensions/codex/src/app-server/scheduled-app-authority.ts
+const CODEX_SCHEDULED_APP_AUTHORITY_NAMESPACE = "codex.apps";
+const CODEX_APPS_MCP_SERVER = "codex_apps";
+const MCP_STATUS_PAGE_SIZE = 100;
+const MCP_STATUS_MAX_PAGES = 100;
+const CODEX_APP_AUTHORITY_CAPTURE_TIMEOUT_MS = 6e4;
+const CODEX_APP_AUTHORITY_CAPTURE_MIN_TIMEOUT_MS = 100;
+/** Hashes stable configured endpoint identity without retaining credentials or endpoint details. */
+function buildScheduledCodexAppServerConnectionIdentity(appServer) {
+	const start = appServer.start;
+	return crypto.createHash("sha256").update("openclaw:codex:scheduled-app-server:v1\0").update(JSON.stringify({
+		transport: start.transport,
+		command: start.command,
+		commandSource: start.commandSource ?? null,
+		args: start.args,
+		cwd: start.cwd ?? null,
+		url: start.url ?? null,
+		homeScope: start.homeScope ?? null,
+		connectionClass: appServer.connectionClass,
+		remoteWorkspaceRoot: appServer.remoteWorkspaceRoot ?? null
+	})).digest("hex");
+}
+function resolveScheduledCodexAppCreatorCaptureDecision(params) {
+	if (!params.appsMayBeVisible) return {
+		required: false,
+		supported: false
+	};
+	const unavailableReason = params.authenticatedScheduledMode ? "A scheduled Codex continuation cannot create new app-authorized automations. Recreate it from a fresh authenticated owner turn; no automation changes were saved." : params.usesSupervisionConnection ? "Codex apps are visible through a supervised connection that cannot capture creator authority. Use an isolated prepared-profile Codex creator turn; no automation changes were saved." : params.homeScope === "user" ? "Codex apps are visible through a user-home runtime that cannot capture isolated creator authority. Use an agent-scoped prepared-profile Codex creator turn; no automation changes were saved." : !params.hasPreparedAccountIdentity && !params.hasConfiguredAppServerIdentity ? "Codex app authority requires either a prepared ChatGPT profile or an isolated configured app-server identity. Reauthenticate the selected Codex profile or configured app-server, then retry; no automation changes were saved." : void 0;
+	return {
+		required: true,
+		supported: !unavailableReason,
+		...unavailableReason ? { unavailableReason } : {}
+	};
+}
+function normalizeApprovalMode(value) {
+	return value === "allow" || value === "deny" || value === "auto" || value === "ask" ? value : void 0;
+}
+function defaultApprovalMode(entry) {
+	return entry.destructiveApprovalMode ?? (entry.allowDestructiveActions ? "allow" : "deny");
+}
+function parseScheduledCodexAppAuthority(authority) {
+	if (!authority || authority.runtimeId !== "codex") return;
+	if (authority.version !== 1) throw new Error("Unsupported Codex scheduled authority version; reauthorize this automation.");
+	if (authority.namespace !== CODEX_SCHEDULED_APP_AUTHORITY_NAMESPACE) throw new Error(`Unsupported Codex scheduled authority namespace ${authority.namespace}; reauthorize this automation.`);
+	const payload = asOptionalRecord(authority.payload);
+	const auth = asOptionalRecord(payload?.auth);
+	const profileId = normalizeOptionalString(auth?.profileId);
+	const connectionFingerprint = normalizeOptionalString(auth?.connectionFingerprint);
+	const managedRequirementsFingerprint = normalizeOptionalString(auth?.managedRequirementsFingerprint);
+	const accountId = normalizeOptionalString(auth?.accountId);
+	const parsedAuth = auth?.kind === "configured-app-server" && connectionFingerprint && managedRequirementsFingerprint ? {
+		kind: "configured-app-server",
+		connectionFingerprint,
+		managedRequirementsFingerprint
+	} : auth?.kind === void 0 && profileId && accountId ? {
+		profileId,
+		accountId
+	} : void 0;
+	if (payload?.version !== 1 || !parsedAuth || !Array.isArray(payload.apps)) throw new Error("Stored Codex app authority is invalid; reauthorize this automation.");
+	const seen = /* @__PURE__ */ new Set();
+	return {
+		version: 1,
+		auth: parsedAuth,
+		apps: payload.apps.map((raw) => {
+			const app = asOptionalRecord(raw);
+			const id = normalizeOptionalString(app?.id);
+			const destructiveApprovalMode = normalizeApprovalMode(app?.destructiveApprovalMode);
+			const rawTools = asOptionalRecord(app?.tools);
+			if (!id || seen.has(id) || typeof app?.allowDestructiveActions !== "boolean" || typeof app.allowOpenWorld !== "boolean" || !destructiveApprovalMode || !rawTools) throw new Error("Stored Codex app authority is invalid; reauthorize this automation.");
+			seen.add(id);
+			const tools = {};
+			for (const [name, rawMode] of Object.entries(rawTools)) {
+				const toolName = normalizeOptionalString(name);
+				const mode = normalizeAppToolApprovalMode(rawMode);
+				if (!toolName || !mode) throw new Error("Stored Codex app authority is invalid; reauthorize this automation.");
+				tools[toolName] = mode;
+			}
+			return {
+				id,
+				allowDestructiveActions: app.allowDestructiveActions,
+				allowOpenWorld: app.allowOpenWorld,
+				destructiveApprovalMode,
+				tools
+			};
+		})
+	};
+}
+async function readCodexScheduledAppToolsByApp(params) {
+	const toolsByApp = /* @__PURE__ */ new Map();
+	const seenCursors = /* @__PURE__ */ new Set();
+	let cursor;
+	for (let page = 0; page < MCP_STATUS_MAX_PAGES; page += 1) {
+		const response = await params.request("mcpServerStatus/list", {
+			...params.threadId ? { threadId: params.threadId } : {},
+			detail: "toolsAndAuthOnly",
+			limit: MCP_STATUS_PAGE_SIZE,
+			...cursor ? { cursor } : {}
+		});
+		if (!isJsonObject(response) || !Array.isArray(response.data)) throw new Error("Codex mcpServerStatus/list returned invalid scheduled app inventory");
+		for (const status of response.data) {
+			if (!isJsonObject(status) || !isJsonObject(status.tools)) throw new Error("Codex scheduled app inventory contained an invalid server status");
+			if (status.name !== CODEX_APPS_MCP_SERVER) continue;
+			for (const [toolName, tool] of Object.entries(status.tools)) {
+				const connectorId = readCodexMcpToolConnectorId(tool);
+				if (connectorId) {
+					const tools = toolsByApp.get(connectorId) ?? /* @__PURE__ */ new Map();
+					const metadata = asOptionalRecord(tool);
+					const appMetadata = asOptionalRecord(metadata?._meta);
+					const annotations = asOptionalRecord(metadata?.annotations);
+					tools.set(toolName, {
+						title: typeof metadata?.title === "string" ? metadata.title : void 0,
+						linkId: typeof appMetadata?.link_id === "string" && appMetadata.link_id.trim() ? appMetadata.link_id : void 0,
+						requiresExplicitLinkId: asOptionalRecord(appMetadata?.["_codex_apps"])?.requires_explicit_link_id === true,
+						destructiveHint: annotations?.destructiveHint === false ? false : void 0,
+						openWorldHint: annotations?.openWorldHint === false ? false : void 0
+					});
+					toolsByApp.set(connectorId, tools);
+				}
+			}
+		}
+		if (response.nextCursor !== void 0 && response.nextCursor !== null && typeof response.nextCursor !== "string") throw new Error("Codex scheduled app inventory returned an invalid pagination cursor");
+		cursor = response.nextCursor;
+		if (!cursor) return toolsByApp;
+		if (seenCursors.has(cursor)) throw new Error("Codex app connector inventory repeated its pagination cursor");
+		seenCursors.add(cursor);
+	}
+	throw new Error("Codex app connector inventory exceeded its bounded page limit");
+}
+/** Reads current account policy and connector-backed tool metadata under one caller deadline. */
+async function readCurrentCodexScheduledAppPolicy(params) {
+	const [configResponse, toolsByApp] = await Promise.all([params.request("config/read", {
+		includeLayers: false,
+		...params.configCwd ? { cwd: params.configCwd } : {}
+	}), readCodexScheduledAppToolsByApp(params)]);
+	if (!isJsonObject(configResponse)) throw new Error("Codex config/read returned an invalid scheduled app policy response");
+	return {
+		config: isJsonObject(configResponse.config) ? configResponse.config : {},
+		toolsByApp
+	};
+}
+/** Captures only apps callable on the exact active Codex client/thread. */
+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 boundedClient = { request: ((method, requestParams) => {
+		const remainingTimeoutMs = deadlineMs - Date.now();
+		if (remainingTimeoutMs <= 0) throw new CodexScheduledAppAuthorityCaptureTimeoutError();
+		return params.client.request(method, requestParams, {
+			timeoutMs: remainingTimeoutMs,
+			signal: params.signal
+		});
+	}) };
+	let installed;
+	let currentPolicy;
+	let auth;
+	const creatorAuth = params.auth;
+	try {
+		[installed, currentPolicy, auth] = await withAbortableTimeout({
+			promise: Promise.all([
+				boundedClient.request("app/installed", {
+					threadId: params.threadId,
+					forceRefresh: false
+				}),
+				readCurrentCodexScheduledAppPolicy({
+					request: (method, requestParams) => boundedClient.request(method, requestParams),
+					threadId: params.threadId,
+					configCwd: params.configCwd
+				}),
+				creatorAuth.kind === "prepared-profile" ? Promise.resolve({
+					profileId: creatorAuth.profileId,
+					accountId: creatorAuth.accountId
+				}) : readCodexManagedRequirementsFingerprint(boundedClient, params.signal).then((managedRequirementsFingerprint) => ({
+					kind: creatorAuth.kind,
+					connectionFingerprint: creatorAuth.connectionFingerprint,
+					managedRequirementsFingerprint
+				}))
+			]),
+			timeoutMs,
+			signal: params.signal,
+			timeoutMessage: "Codex scheduled app authority capture deadline elapsed",
+			createTimeoutError: () => new CodexScheduledAppAuthorityCaptureTimeoutError()
+		});
+	} catch (error) {
+		if (params.signal?.aborted || !(error instanceof CodexScheduledAppAuthorityCaptureTimeoutError) && !isCodexAppServerRequestTimeoutError(error)) throw error;
+		throw new Error(`Codex app authority capture exceeded its ${timeoutMs} ms total budget. No automation changes were saved; retry after Codex app inventory is responsive.`, { cause: error });
+	}
+	const callableIds = new Set(installed.apps.filter((app) => app.enabled && app.callable).map((app) => app.id));
+	const apps = Object.entries(params.policyContext.apps).filter(([id]) => callableIds.has(id) && currentPolicy.toolsByApp.has(id)).map(([id, policy]) => ({
+		id,
+		allowDestructiveActions: policy.allowDestructiveActions,
+		allowOpenWorld: policy.allowOpenWorld !== false,
+		destructiveApprovalMode: defaultApprovalMode(policy),
+		tools: Object.fromEntries([...currentPolicy.toolsByApp.get(id)?.keys() ?? []].toSorted().map((toolName) => [toolName, readCurrentToolPolicy(currentPolicy.config, id, toolName, currentPolicy.toolsByApp.get(id)?.get(toolName), appApprovalCeiling(defaultApprovalMode(policy))).approvalMode]))
+	})).toSorted((left, right) => left.id.localeCompare(right.id));
+	if (apps.length === 0) return;
+	return {
+		version: 1,
+		runtimeId: "codex",
+		namespace: CODEX_SCHEDULED_APP_AUTHORITY_NAMESPACE,
+		payload: {
+			version: 1,
+			auth,
+			apps
+		}
+	};
+}
+var CodexScheduledAppAuthorityCaptureTimeoutError = class extends Error {
+	constructor() {
+		super("Codex scheduled app authority capture deadline elapsed");
+		this.name = "CodexScheduledAppAuthorityCaptureTimeoutError";
+	}
+};
+const APPROVAL_RANK = {
+	deny: 0,
+	ask: 1,
+	auto: 2,
+	allow: 3
+};
+function stricterApprovalMode(left, right) {
+	return APPROVAL_RANK[left] <= APPROVAL_RANK[right] ? left : right;
+}
+function appApprovalCeiling(mode) {
+	if (mode === "allow") return "approve";
+	return mode === "ask" ? "prompt" : "auto";
+}
+/** Intersects a stored app-ID cap with current policy without admitting new apps. */
+function intersectCodexPluginThreadConfigWithScheduledAuthority(config, authority, currentPolicy = {
+	config: {},
+	toolsByApp: /* @__PURE__ */ new Map()
+}) {
+	const scheduled = parseScheduledCodexAppAuthority(authority);
+	if (!scheduled) return config;
+	const omittedAppIds = scheduled.apps.map((app) => app.id).filter((id) => {
+		const currentTools = currentPolicy.toolsByApp.get(id);
+		return !Object.hasOwn(config.policyContext.apps, id) || !currentTools || currentTools.size === 0;
+	}).toSorted();
+	if (omittedAppIds.length > 0) {
+		const visibleIds = omittedAppIds.slice(0, 10).join(", ");
+		const remaining = omittedAppIds.length - Math.min(omittedAppIds.length, 10);
+		throw new AgentHarnessPreflightError(`Scheduled Codex apps are unavailable under the current policy or account: ${visibleIds}${remaining > 0 ? ` (and ${remaining} more)` : ""}. Restore access or reauthorize the automation from a fresh authenticated Codex owner turn.`);
+	}
+	const capturedById = new Map(scheduled.apps.map((app) => [app.id, app]));
+	const apps = {};
+	for (const [id, current] of Object.entries(config.policyContext.apps)) {
+		const captured = capturedById.get(id);
+		if (!captured) continue;
+		apps[id] = {
+			...current,
+			allowDestructiveActions: current.allowDestructiveActions && captured.allowDestructiveActions,
+			allowOpenWorld: current.allowOpenWorld !== false && captured.allowOpenWorld,
+			destructiveApprovalMode: stricterApprovalMode(defaultApprovalMode(current), captured.destructiveApprovalMode)
+		};
+	}
+	const pluginAppIds = Object.fromEntries(Object.entries(config.policyContext.pluginAppIds).map(([key, ids]) => [key, ids.filter((id) => Object.hasOwn(apps, id))]).filter(([, ids]) => ids.length > 0));
+	const policyContext = buildPluginAppPolicyContext(apps, pluginAppIds);
+	const configPatch = disableUnlistedCodexApps(buildCodexPluginAppsConfigPatchFromPolicyContext(policyContext), currentPolicy.config);
+	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;
+		if (currentApp.destructiveApprovalMode === "ask") Object.assign(appPatch, buildCodexAppApprovalOverrides(currentPolicy.config, {
+			id: appId,
+			approvalOverrideToolConfigKeys: []
+		}));
+		const storedAppCeiling = appApprovalCeiling(captured.destructiveApprovalMode);
+		const currentAppCeiling = appApprovalCeiling(defaultApprovalMode(currentApp));
+		const tools = currentPolicy.toolsByApp.get(appId) ?? /* @__PURE__ */ new Map();
+		appPatch.tools = Object.fromEntries([...tools.keys()].toSorted().map((toolName) => {
+			const capturedMode = captured.tools[toolName] ?? storedAppCeiling;
+			const currentToolPolicy = readCurrentToolPolicy(currentPolicy.config, appId, toolName, tools.get(toolName), currentAppCeiling);
+			return [toolName, {
+				enabled: currentToolPolicy.enabled && appToolHintsAllowed(tools.get(toolName), currentApp),
+				approval_mode: intersectToolApprovalMode(intersectToolApprovalMode(capturedMode, storedAppCeiling), intersectToolApprovalMode(currentToolPolicy.approvalMode, currentAppCeiling))
+			}];
+		}));
+	}
+	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,
+		configPatch,
+		provisionalAppIds: Object.keys(apps).toSorted(),
+		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;
+}
+function assertScheduledCodexAppAuthorityRuntime(connection, params) {
+	const scheduledAuth = parseScheduledCodexAppAuthority(params.scheduledRuntimeAuthority)?.auth;
+	if (!scheduledAuth) return;
+	if (params.trigger !== "cron" || connection.usesSupervisionConnection || connection.appServer.start.homeScope === "user") throw new AgentHarnessPreflightError("This automation's Codex app authority requires an isolated scheduled runtime. Reauthorize it from a supported Codex creator turn.");
+	if (scheduledAuth.kind === "configured-app-server") {
+		if (buildScheduledCodexAppServerConnectionIdentity(connection.appServer) !== scheduledAuth.connectionFingerprint) throw new AgentHarnessPreflightError("This automation was authorized for a different configured Codex app-server. Restore that connection or reauthorize the automation from a fresh owner turn.");
+		return;
+	}
+	const prepared = connection.startupPreparedAuth;
+	if (prepared?.kind !== "profile" || prepared.profileId !== scheduledAuth.profileId || prepared.snapshot?.loginParams.type !== "chatgptAuthTokens" || prepared.snapshot.chatgptAccountId !== scheduledAuth.accountId) throw new AgentHarnessPreflightError(`This automation was authorized for Codex profile ${scheduledAuth.profileId}, but that exact prepared account is not active. Restore the profile or reauthorize the automation from a fresh owner turn.`);
+}
+function buildLegacyScheduledCodexAppRecoveryPrompt(params) {
+	if (params.trigger !== "cron" || !params.scheduledRuntimeAuthorityRecoveryRequired || params.scheduledRuntimeAuthority) return;
+	return "Scheduled Codex app access is unavailable because this automation predates runtime-specific app authority capture. Tell the operator to recreate or reauthorize it from a fresh authenticated Codex owner turn; do not claim an app action succeeded.";
+}
+/** Makes stored-cap identity part of thread reuse admission, including cap removal. */
+function buildScheduledCodexAppAuthorityInputFingerprint(baseFingerprint, authority) {
+	const scheduled = parseScheduledCodexAppAuthority(authority);
+	if (!scheduled) return baseFingerprint;
+	return crypto.createHash("sha256").update(stringifyCodexPolicy({
+		version: 1,
+		namespace: CODEX_SCHEDULED_APP_AUTHORITY_NAMESPACE,
+		baseFingerprint,
+		authority: scheduled
+	})).digest("hex");
+}
+//#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);
+	let didLog = false;
+	return {
+		measure: timing.measure,
+		measureSync: timing.measureSync,
+		mark(name) {
+			timing.measureSync(name, () => void 0);
+		},
+		logSummary(params) {
+			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 shouldWarn = totalMs >= totalThresholdMs || spans.some((span) => span.durationMs >= stageThresholdMs);
+			if (!shouldWarn && !log.isEnabled?.("trace")) return;
+			didLog = true;
+			const message = `[trace:codex-app-server] thread lifecycle: runId=${params.runId} sessionId=${params.sessionId} sessionKey=${params.sessionKey ?? "unknown"} action=${params.action} totalMs=${totalMs} stages=${formatStageTimings(spans)}`;
+			const meta = {
+				runId: params.runId,
+				sessionId: params.sessionId,
+				sessionKey: params.sessionKey,
+				action: params.action,
+				threadId: params.threadId,
+				totalMs,
+				spans
+			};
+			if (shouldWarn) log.warn(message, meta);
+			else log.trace(message, meta);
+		}
+	};
+}
+//#endregion
+//#region extensions/codex/src/app-server/thread-lifecycle-preflight.ts
+function assertCodexThreadInferenceAuthority(params, modelPolicyEnforced) {
+	if (params.inferenceRoute && modelPolicyEnforced) return;
+	const host = params.params.hostCapabilities;
+	const unavailable = () => new AgentHarnessPreflightError("This Codex connection cannot enforce your operator role's model policy. Use an OpenClaw-managed connection with an owned inference route; no turn was sent.");
+	if (!host.retainSourceAuthority) throw unavailable();
+	const source = host.retainSourceAuthority();
+	if (source === void 0) return;
+	try {
+		source.assertCurrent();
+		if (source.modelPolicyRequired !== false) throw unavailable();
+	} finally {
+		source.release();
+	}
+}
+/** Preserve the selected provider when only its physical thread must be replaced. */
+async function prepareCodexThreadRequestContext(params, options) {
+	const startModelSelection = resolveCodexAppServerThreadModelSelection({
+		homeScope: params.appServer.start.homeScope,
+		provider: params.params.provider,
+		model: params.runtimeModelId ?? params.params.modelId,
+		binding: options.selectionBinding,
+		authProfileId: params.params.authProfileId,
+		authProfileStore: params.params.authProfileStore,
+		agentDir: params.params.agentDir,
+		config: params.params.config
+	});
+	const source = params.params.hostCapabilities.retainSourceAuthority?.();
+	const modelPolicyEnforced = params.nativeModelAdmission === void 0 || options.preflight.nativeModelInputTools !== void 0;
+	let inference;
+	try {
+		source?.assertCurrent();
+		inference = await prepareCodexInferenceThreadConfig({
+			...params,
+			config: options.config,
+			binding: options.binding,
+			clientId: options.clientId,
+			operatorBacked: source !== void 0,
+			modelPolicyEnforced,
+			modelProvider: options.binding?.preserveNativeModel || options.binding?.connectionScope === "supervision" ? options.binding.modelProvider : startModelSelection.modelProvider,
+			effectiveConfig: options.preflight.effectiveConfig,
+			assertCurrent: () => {
+				options.assertCurrent();
+				source?.assertCurrent();
+			}
+		});
+	} finally {
+		source?.release();
+	}
+	params.config = inference?.config ?? options.config;
+	params.inferenceRoute = inference?.route;
+	params.inferenceProviderRoutes = inference?.providers;
+	params.assertCurrent = () => {
+		options.throwIfAborted();
+		options.assertCurrent();
+		assertCodexThreadInferenceAuthority(params, modelPolicyEnforced);
+	};
+	params.assertCurrent();
+	return {
+		...options.preflight,
+		bindingIdentity: options.bindingIdentity,
+		startModelSelection,
+		startModelProvider: startModelSelection.modelProvider,
+		normalizeBindingModelProvider: (authProfileId, modelProvider) => normalizeCodexAppServerBindingModelProvider({
+			authProfileId,
+			modelProvider,
+			authProfileStore: params.params.authProfileStore,
+			agentDir: params.params.agentDir,
+			config: params.params.config
+		}),
+		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;
+}
+function resolveCodexThreadAgentDir(params) {
+	const agentId = resolveSessionAgentIdsStrict({
+		config: params.params.config,
+		sessionKey: params.params.sessionKey,
+		agentId: params.agentId ?? params.params.agentId
+	}).sessionAgentId;
+	return params.agentDir ?? params.params.agentDir ?? resolveAgentDir$1(params.params.config ?? {}, agentId);
+}
+function buildCodexThreadBindingPolicy(params, preflight) {
+	return {
+		dynamicToolsFingerprint: preflight.dynamicToolsFingerprint,
+		dynamicToolsContainDeferred: preflight.dynamicToolsContainDeferred,
+		nativeSkillIsolationFingerprint: preflight.nativeSkillIsolationFingerprint,
+		userMcpServersFingerprint: preflight.userMcpServersFingerprint,
+		configuredMcpOwnershipVersion: params.configuredMcpOwnershipVersion,
+		networkProxyProfileName: params.appServer.networkProxy?.profileName,
+		networkProxyConfigFingerprint: preflight.networkProxyConfigFingerprint,
+		contextEngine: preflight.contextEngineBinding,
+		environmentSelectionFingerprint: preflight.environmentSelectionFingerprint
+	};
+}
+async function prepareCodexThreadFinalConfigPatch(params, nativeModelInputTools, binding) {
+	return await params.buildFinalConfigPatch?.({
+		...binding ? {
+			action: "resume",
+			binding
+		} : { action: "start" },
+		...nativeModelInputTools ? { nativeModelInputTools } : {}
+	}) ?? {
+		configPatch: params.finalConfigPatch,
+		nativeHookRelayGeneration: params.nativeHookRelayGeneration
+	};
+}
+async function prepareCodexThreadLifecyclePreflight(params) {
+	let effectiveConfig = await assertCodexModelBackedReviewerEffectiveConfig({
+		client: params.client,
+		approvalsReviewer: params.appServer.approvalsReviewer,
+		cwd: params.cwd,
+		signal: params.signal
+	});
+	const nativeHooksRequired = params.nativeHookRelayRequired || params.nativeModelAdmission === "required";
+	let modelAdmissionAvailable = params.nativeModelAdmission !== void 0 && (params.nativeModelAdmission !== "disabled" || nativeHooksRequired);
+	if (nativeHooksRequired || modelAdmissionAvailable) try {
+		await assertCodexNativeHookRelayAllowed(params.client, params.signal);
+	} catch (error) {
+		if (nativeHooksRequired || !(error instanceof CodexManagedHooksOnlyError)) throw error;
+		modelAdmissionAvailable = false;
+	}
+	const lifecycleTiming = createCodexThreadLifecycleTimingTracker({
+		...params.timing,
+		enabled: params.timing?.enabled ?? isCodexAppServerProfilerEnabled(params.params.config)
+	});
+	const legacyDynamicToolsFingerprint = lifecycleTiming.measureSync("legacy-dynamic-tools-fingerprint", () => codexLegacyDynamicToolsFingerprint(params.dynamicTools));
+	const dynamicToolsFingerprint = lifecycleTiming.measureSync("dynamic-tools-fingerprint", () => hashCodexAppServerBindingFingerprint(legacyDynamicToolsFingerprint));
+	const dynamicToolsContainDeferred = flattenCodexDynamicToolFunctions(params.dynamicTools).some((tool) => tool.deferLoading === true);
+	const webSearchPlan = lifecycleTiming.measureSync("web-search-plan", () => resolveCodexWebSearchPlan({
+		config: params.params.config,
+		disableTools: params.params.disableTools,
+		nativeToolSurfaceEnabled: params.nativeCodeModeEnabled,
+		nativeProviderWebSearchSupport: params.nativeProviderWebSearchSupport,
+		webSearchAllowed: params.webSearchAllowed
+	}));
+	const webSearchThreadConfigFingerprint = fingerprintJsonObject(webSearchPlan.threadConfig);
+	const networkProxyConfigFingerprint = params.appServer.networkProxy?.configFingerprint;
+	const contextEngineBinding = lifecycleTiming.measureSync("context-engine-binding", () => buildContextEngineBinding(params.params, params.contextEngineProjection));
+	const userMcpServersConfigPatch = params.userMcpServersEnabled === false ? void 0 : await buildCodexUserMcpServersThreadConfigPatchForRun({
+		run: params.params,
+		cwd: params.cwd,
+		agentId: params.agentId ?? params.params.agentId,
+		allowLiteralOAuthProjection: params.appServer.connectionClass !== "remote",
+		warn: (message) => embeddedAgentLog.warn(message),
+		onServerUnavailable: (serverName, error) => embeddedAgentLog.warn("skipping unavailable MCP OAuth server", {
+			serverName,
+			error: formatErrorMessage(error)
+		})
+	});
+	const nativeSkillIsolation = await lifecycleTiming.measure("native-skill-isolation", () => resolveCodexNativeSkillIsolation({
+		client: params.client,
+		codexHome: params.appServer.start.codexHome ?? params.appServer.start.env?.CODEX_HOME,
+		cwd: params.cwd,
+		home: params.appServer.start.env?.HOME,
+		signal: params.signal,
+		userProfile: params.appServer.start.env?.USERPROFILE
+	}));
+	const nativeSkillIsolationFingerprint = nativeSkillIsolation ? fingerprintJsonObject({
+		version: 1,
+		disabledUserSkillPaths: nativeSkillIsolation.disabledUserSkillPaths
+	}) : void 0;
+	const legacyUserMcpServersFingerprint = legacyFingerprintUserMcpServersConfigPatch(userMcpServersConfigPatch);
+	const userMcpServersFingerprint = fingerprintUserMcpServersConfigPatch(userMcpServersConfigPatch);
+	const environmentSelectionFingerprint = fingerprintEnvironmentSelection(params.environmentSelection);
+	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 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 }));
+	params.config = mergeCodexNativeProjectDocThreadConfig(params.config, effectiveConfig);
+	if (params.shellEnvironment) 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,
+		requiredNativeShell: params.nativeCodeModeEnabled !== false,
+		additionalDeniedFeatures: imageGenerationDenied ? ["image_generation"] : void 0,
+		allowedManagedRequirementsFingerprint: readScheduledCodexAppManagedRequirementsFingerprint(params.params.scheduledRuntimeAuthority),
+		allowConfiguredManagedHooks
+	}, params.signal));
+	const features = effectiveConfig?.config.features;
+	if (params.nativeCodeModeEnabled !== false && isJsonObject(features) && features.shell_tool === false && !CODEX_SESSION_OVERRIDABLE_LAYER_TYPES.has(effectiveConfig?.origins?.["features.shell_tool"]?.name.type ?? "")) throw new Error("Codex native code mode requires shell_tool, but the effective shell setting cannot be overridden. Ask your administrator to allow the shell, or select a tool policy that disables native code mode; no automation authority was captured.");
+	const ringZeroConfigFingerprint = ringZeroActive ? fingerprintJsonObject({
+		version: 1,
+		baseInstructions: "",
+		config: buildCodexRingZeroThreadConfigPatch(params.params, true, restrictedToolSurfaceInheritedMcpServerNames)
+	}) : void 0;
+	const ringZeroClientInstanceId = ringZeroActive ? getCodexAppServerClientInstanceId(params.client) : void 0;
+	return {
+		nativeModelInputTools: nativeHooksRequired || modelAdmissionAvailable ? resolveCodexNativeModelInputTools(effectiveConfig.config) : void 0,
+		effectiveConfig,
+		contextEngineBinding,
+		dynamicToolsContainDeferred,
+		dynamicToolsFingerprint,
+		environmentSelectionFingerprint,
+		hostSystemAgentActive,
+		legacyDynamicToolsFingerprint,
+		legacyUserMcpServersFingerprint,
+		lifecycleTiming,
+		nativeSkillIsolation,
+		nativeSkillIsolationFingerprint,
+		networkProxyConfigFingerprint,
+		ringZeroActive,
+		ringZeroClientInstanceId,
+		ringZeroConfigFingerprint,
+		restrictedToolSurface,
+		restrictedToolSurfaceInheritedMcpServerNames,
+		userMcpServersConfigPatch,
+		userMcpServersFingerprint,
+		webSearchThreadConfigFingerprint
+	};
+}
+//#endregion
+//#region extensions/codex/src/app-server/thread-lifecycle-io.ts
+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;
+	let acceptedConfiguration;
+	let disposeConfiguration;
+	let resumeReservation;
+	let ordinaryAppConfigChanged = false;
+	let policyOutcome = "not-written";
+	const abandonClient = params.abandonClient ?? (() => closeCodexStartupClientBestEffort(params.client));
+	try {
+		const configuration = await context.prepareResume();
+		const assertHandoffCurrent = configuration.assertConfigured;
+		disposeConfiguration = configuration.dispose;
+		await context.releaseRetainedThread(configuration.assertCurrent);
+		configuration.assertCurrent();
+		const clientBoundThread = ringZeroClientInstanceId !== void 0 || resumeBinding.ringZeroClientInstanceId !== void 0 || resumeBinding.ringZeroConfigFingerprint !== void 0 || context.ringZeroActive;
+		const sharedEntry = getCurrentSharedClientEntry(params.client);
+		if (configuration.settledSystemError && !clientBoundThread && resumeBinding.connectionScope !== "supervision" && (!sharedEntry || sharedEntry.activeLeases <= 1 && sharedEntry.pendingAcquires === 0) && !hasCodexAppServerSiblingThreadWork(params.client, resumeBinding.threadId) && !hasCodexAppServerSiblingRouteWork(params.client, resumeBinding.threadId)) {
+			await abandonClient();
+			throw new CodexThreadClientReplacementError();
+		}
+		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 requestModelProvider = typeof resumeParams.modelProvider === "string" && resumeParams.modelProvider.trim() ? resumeParams.modelProvider : void 0;
+		throwIfAborted();
+		resumeReservation = params.reserveResumeThread?.(resumeBinding.threadId);
+		const response = await lifecycleTiming.measure("thread-resume-request", () => resumeCodexAppServerThread({
+			client: params.client,
+			abandonClient,
+			request: resumeParams,
+			signal: params.signal,
+			assertCurrent: () => {
+				configuration.assertCurrent();
+				assertCodexInferenceRouteConfig(params.client, params.inferenceRoute, resumeParams.config, requestModelProvider ?? (resumeBinding.preserveNativeModel ? configuration.modelProvider ?? void 0 : void 0), params.inferenceProviderRoutes);
+			}
+		}));
+		acceptedConfiguration = configuration;
+		assertCodexThreadAcceptsDirectInput(response.thread);
+		configuration.assertConfigured();
+		if (requestModelProvider && response.modelProvider !== requestModelProvider) throw new Error("Codex resumed a different model provider than the one selected for this turn");
+		const loadedPluginThreadConfig = await context.buildLoadedPluginThreadConfig?.(resumeBinding);
+		if (loadedPluginThreadConfig && loadedPluginThreadConfig.fingerprint !== (pluginThreadConfig?.fingerprint ?? resumeBinding.pluginAppsFingerprint)) {
+			ordinaryAppConfigChanged = resumeBinding.connectionScope !== "supervision" && !resumeBinding.pendingResumeConfiguration;
+			throw new Error("Codex thread app policy changed; a fresh thread configuration is required");
+		}
+		const provisionalAppIds = loadedPluginThreadConfig?.provisionalAppIds ?? pluginThreadConfig?.provisionalAppIds ?? [];
+		await attestCodexThreadToolSurface({
+			client: params.client,
+			threadId: response.thread.id,
+			appIds: provisionalAppIds,
+			signal: params.signal,
+			threadConfig: resumeParams.config,
+			restrictedToolSurface,
+			lifecycleTiming,
+			assertCurrent: assertHandoffCurrent
+		});
+		throwIfAborted();
+		await refreshCodexThreadPolicy({
+			client: params.client,
+			threadId: resumeBinding.threadId,
+			developerInstructions: resumeParams.developerInstructions,
+			timeoutMs: params.appServer.requestTimeoutMs,
+			signal: params.signal,
+			assertCurrent: assertHandoffCurrent
+		});
+		policyOutcome = "acknowledged";
+		assertHandoffCurrent();
+		const resumePatch = {
+			clientId: resolveCodexAppServerClientInstanceId(params.client),
+			pendingResumeConfiguration: void 0,
+			...resumeBinding.agentWorkspaceDeveloperInstructions === void 0 && params.agentWorkspaceDeveloperInstructions !== void 0 ? { agentWorkspaceDeveloperInstructions: params.agentWorkspaceDeveloperInstructions } : {},
+			cwd: params.cwd,
+			rolloutPath: resolveCodexThreadRolloutPath(response.thread) ?? resumeBinding.rolloutPath,
+			authProfileId,
+			model: resumeParams.model ?? response.model ?? params.params.modelId,
+			preserveNativeModel: resumeBinding.preserveNativeModel === true ? true : void 0,
+			modelProvider: normalizeBindingModelProvider(authProfileId, response.modelProvider ?? requestModelProvider ?? startModelProvider),
+			...buildCodexThreadBindingPolicy(params, context),
+			webSearchThreadConfigFingerprint,
+			mcpServersFingerprint: params.mcpServersFingerprintEvaluated === true ? params.mcpServersFingerprint : resumeBinding.mcpServersFingerprint,
+			ringZeroConfigFingerprint,
+			ringZeroClientInstanceId,
+			nativeToolPolicyRestricted: restrictedToolSurface ? true : void 0,
+			nativeHookRelayGeneration: finalConfigPatch.nativeHookRelayGeneration ?? resumeBinding.nativeHookRelayGeneration,
+			appServerRuntimeFingerprint: resumeBinding.connectionScope === "supervision" ? buildCodexAppServerConnectionFingerprint(params.appServer, params.params.agentDir) : params.appServerRuntimeFingerprint,
+			pluginAppsFingerprint: pluginThreadConfig?.fingerprint ?? resumeBinding.pluginAppsFingerprint,
+			pluginAppsInputFingerprint: pluginThreadConfig?.inputFingerprint ?? resumeBinding.pluginAppsInputFingerprint,
+			pluginAppPolicyContext: pluginThreadConfig?.policyContext ?? resumeBinding.pluginAppPolicyContext
+		};
+		if (!await lifecycleTiming.measure("thread-resume-write-binding", () => params.bindingStore.mutate(bindingIdentity, {
+			kind: "patch",
+			threadId: resumeBinding.threadId,
+			patch: resumePatch
+		}, assertHandoffCurrent))) 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"
+		});
+		const activeTurnIds = readActiveCodexTurnIdsFromResume(response);
+		return {
+			...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),
+			lifecycle: {
+				action: "resumed",
+				...activeTurnIds.length ? { activeTurnIds } : {}
+			}
+		};
+	} catch (error) {
+		resumeReservation?.release();
+		if (!acceptedConfiguration && (!(error instanceof CodexAppServerRpcError) || error.method === "thread/read" && !isCodexThreadReadMissingError(error, resumeBinding.threadId) || isCodexAppServerOverloadError(error))) throw error;
+		if (acceptedConfiguration) {
+			const handoffError = error instanceof CodexThreadPolicyHandoffError || error instanceof CodexAppServerUnsafeSubscriptionError ? error : new CodexThreadPolicyHandoffError(policyOutcome, error);
+			const subscriptionReleased = await unsubscribeCodexThreadBestEffort(params.client, {
+				threadId: resumeBinding.threadId,
+				timeoutMs: CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS,
+				assertCurrent: acceptedConfiguration.assertCurrent
+			}).catch(() => false);
+			if (!subscriptionReleased || handoffError instanceof CodexThreadPolicyHandoffError && handoffError.outcome === "unknown") {
+				if (resumeBinding.connectionScope === "supervision") await retireUnsafeCodexTurnClientBestEffort(params.client, "session policy handoff");
+				else try {
+					await abandonClient();
+				} catch (cause) {
+					throw new CodexThreadPolicyHandoffError(handoffError instanceof CodexThreadPolicyHandoffError ? handoffError.outcome : policyOutcome, new AggregateError([handoffError, cause], "Codex thread/resume client could not be retired"));
+				}
+			}
+			if (!ordinaryAppConfigChanged || !subscriptionReleased) throw handoffError;
+			acceptedConfiguration.assertConfigured();
+		}
+		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");
+	} finally {
+		disposeConfiguration?.();
+	}
+}
+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 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 startParams = lifecycleTiming.measureSync("thread-start-params", () => buildThreadStartParams(params.params, {
+		...params,
+		config,
+		model: startModelSelection.model,
+		modelProvider: startModelProvider,
+		hostSystemAgentActive,
+		restrictedToolSurfaceInheritedMcpServerNames
+	}));
+	const requestModelProvider = typeof startParams.modelProvider === "string" && startParams.modelProvider.trim() ? startParams.modelProvider : void 0;
+	const assertCurrent = () => {
+		throwIfAborted();
+		params.params.hostCapabilities.assertActive();
+		params.assertCurrent?.();
+	};
+	const assertInferenceCurrent = () => {
+		assertCurrent();
+		assertCodexInferenceRouteConfig(params.client, params.inferenceRoute, startParams.config, requestModelProvider, params.inferenceProviderRoutes);
+	};
+	const threadStartResponse = await lifecycleTiming.measure("thread-start-request", async () => {
+		try {
+			assertCurrent();
+			return await params.client.request("thread/start", startParams, {
+				signal: params.signal,
+				assertCurrent: assertInferenceCurrent
+			});
+		} catch (error) {
+			if (error instanceof CodexAppServerRpcError) throw new CodexThreadStartRequestError(error);
+			throw error;
+		}
+	});
+	const response = assertCodexThreadStartResponse(threadStartResponse);
+	const provisionalAppIds = pluginThreadConfig?.provisionalAppIds;
+	const rejectUncommittedThread = async (cause) => {
+		if (!await discardUnattestedCodexPluginThread({
+			client: params.client,
+			threadId: response.thread.id,
+			ephemeral: startParams.ephemeral === true
+		})) {
+			await (params.abandonClient ?? (() => closeCodexStartupClientBestEffort(params.client)))();
+			throw new CodexAppServerUnsafeSubscriptionError("Codex uncommitted thread cleanup failed", { cause });
+		}
+		throw cause;
+	};
+	try {
+		await attestCodexThreadToolSurface({
+			client: params.client,
+			threadId: response.thread.id,
+			appIds: provisionalAppIds ?? [],
+			signal: params.signal,
+			threadConfig: startParams.config,
+			restrictedToolSurface,
+			lifecycleTiming,
+			assertCurrent
+		});
+		assertCurrent();
+	} catch (error) {
+		return await rejectUncommittedThread(error);
+	}
+	const rolloutPath = resolveCodexThreadRolloutPath(response.thread);
+	const modelProvider = resolveCodexAppServerModelProvider({
+		homeScope: params.appServer.start.homeScope,
+		provider: params.params.provider,
+		authProfileId: params.params.authProfileId,
+		authProfileStore: params.params.authProfileStore,
+		agentDir: params.params.agentDir,
+		config: params.params.config
+	});
+	const bindingModelProvider = normalizeBindingModelProvider(params.params.authProfileId, response.modelProvider ?? requestModelProvider ?? startModelProvider ?? modelProvider);
+	const nextMcpServersFingerprint = params.mcpServersFingerprintEvaluated === true ? params.mcpServersFingerprint : void 0;
+	const startedBinding = {
+		threadId: response.thread.id,
+		...clientId ? { clientId } : {},
+		cwd: params.cwd,
+		...rolloutPath ? { rolloutPath } : {},
+		authProfileId: params.params.authProfileId,
+		agentWorkspaceDeveloperInstructions: params.agentWorkspaceDeveloperInstructions,
+		model: response.model ?? startParams.model ?? params.params.modelId,
+		modelProvider: bindingModelProvider,
+		...buildCodexThreadBindingPolicy(params, context),
+		mcpServersFingerprint: nextMcpServersFingerprint,
+		ringZeroConfigFingerprint,
+		ringZeroClientInstanceId,
+		nativeHookRelayGeneration: finalConfigPatch.nativeHookRelayGeneration,
+		appServerRuntimeFingerprint: params.appServerRuntimeFingerprint,
+		pluginAppsFingerprint: pluginThreadConfig?.fingerprint,
+		pluginAppsInputFingerprint: pluginThreadConfig?.inputFingerprint,
+		pluginAppPolicyContext: pluginThreadConfig?.policyContext
+	};
+	if (!preserveExistingBinding) {
+		const nextBinding = {
+			...startedBinding,
+			webSearchThreadConfigFingerprint,
+			nativeToolPolicyRestricted: restrictedToolSurface ? true : void 0
+		};
+		const managedSourceHomeId = codexCatalogHomeId(resolveCodexAppServerLocalHomeDir(params.appServer.start, resolveCodexThreadAgentDir(params)));
+		let committed;
+		try {
+			await lifecycleTiming.measure("thread-start-mark-managed", () => markStartedCodexManagedThread(params.bindingStore.managedThreads, {
+				sourceHomeId: managedSourceHomeId,
+				threadId: response.thread.id,
+				...rolloutPath ? { rolloutPath } : {}
+			}));
+			committed = await lifecycleTiming.measure("thread-start-write-binding", () => params.bindingStore.mutate(bindingIdentity, replacementPredecessor ? {
+				kind: "replace-thread",
+				expectedThreadId: replacementPredecessor.threadId,
+				binding: nextBinding
+			} : {
+				kind: "set",
+				if: { kind: "absent" },
+				binding: nextBinding
+			}, assertCurrent));
+		} 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"
+	});
+	return {
+		...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) } : {},
+		lifecycle: {
+			action: "started",
+			...preserveExistingBinding ? { preserveExistingBinding: true } : {},
+			...rotatedContextEngineBinding ? { rotatedContextEngineBinding: true } : {}
+		}
+	};
+}
+//#endregion
+//#region extensions/codex/src/app-server/thread-lifecycle-warm.ts
+/** Preserves the caller's abort reason across thread ownership transitions. */
+function throwIfCodexThreadLifecycleAborted(signal) {
+	if (!signal?.aborted) return;
+	const reason = signal.reason;
+	if (reason instanceof Error) throw reason;
+	const error = new Error(typeof reason === "string" && reason.length > 0 ? reason : "codex app-server thread lifecycle aborted");
+	error.name = "AbortError";
+	throw error;
+}
+/** Releases consumed subscription ownership or retires an unsafe client. */
+async function releaseCodexConsumedLiveThread(options) {
+	if (await options.lifecycleTiming.measure("retained-thread-unsubscribe", () => unsubscribeCodexThreadBestEffort(options.client, {
+		threadId: options.threadId,
+		timeoutMs: 5e3,
+		assertCurrent: options.assertCurrent
+	}))) return;
+	return await abandonCodexLiveThreadRelease(options, options.cause);
+}
+async function abandonCodexLiveThreadRelease(options, cause) {
+	options.assertCurrent?.();
+	await (options.abandonClient ?? (() => closeCodexStartupClientBestEffort(options.client)))();
+	throw new CodexAppServerUnsafeSubscriptionError(`Codex retained thread subscription could not be released: ${options.threadId}`, cause !== void 0 ? { cause } : void 0);
+}
+/** 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));
+	} catch (error) {
+		if (isCodexAppServerUnsafeSubscriptionError(error)) throw error;
+		return await abandonCodexLiveThreadRelease(options, error);
+	}
+}
+/** Release follows the physical owner across connection rotation, never a copied thread id. */
+async function releaseCodexBoundLiveThread(options) {
+	const changedClient = options.ownerClientId && options.ownerClientId !== options.clientId;
+	const previous = changedClient ? await retainSharedCodexAppServerClientByInstanceId(options.ownerClientId) : void 0;
+	if (changedClient && !previous) return false;
+	const client = previous?.client ?? options.client;
+	try {
+		if (isCodexAppServerLiveThreadClaimed(client, options.threadId)) throw new Error(`Codex thread ${options.threadId} is claimed by active work; stop it first.`);
+		return await releaseCodexRetainedLiveThread({
+			...options,
+			client,
+			abandonClient: previous ? void 0 : options.abandonClient,
+			assertCurrent: options.assertCurrent ? () => {
+				options.assertCurrent?.();
+				const closed = previous?.client.getCloseError();
+				if (closed) throw closed;
+			} : void 0
+		});
+	} finally {
+		await previous?.release(!isCodexAppServerLiveThreadClaimed(client, options.threadId));
+	}
+}
+/** 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 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) {
+			await params.buildFinalConfigPatch?.({
+				action: "resume",
+				binding,
+				...options.nativeModelInputTools ? { nativeModelInputTools: options.nativeModelInputTools } : {}
+			});
+			throwIfAborted();
+			params.assertCurrent?.();
+			return {
+				kind: "ready",
+				binding: {
+					...binding,
+					lifecycle: { action: "resumed" }
+				}
+			};
+		}
+		return { kind: "rotate" };
+	}
+	if (!binding.clientId || binding.clientId !== clientId || ringZeroActive && !incognito) return { kind: "resume" };
+	const retainedThread = await consumeCodexAppServerLiveThread(params.client, binding.threadId);
+	if (!retainedThread) return { kind: "resume" };
+	const assertWarmOwner = () => {
+		throwIfAborted();
+		if (!isCodexAppServerClientRuntimeLive(params.client)) throw params.client.getCloseError() ?? /* @__PURE__ */ new Error("codex app-server client is closed");
+		try {
+			retainedThread.assertCurrent();
+			params.params.hostCapabilities.assertActive();
+			params.assertCurrent?.();
+		} catch (cause) {
+			throw new AgentHarnessPreflightError("Codex warm thread ownership changed before this turn could run. No turn was sent; reconnect before continuing, or start a new conversation if the original thread was closed.", { cause });
+		}
+	};
+	let ownershipTransferred = false;
+	let preserveSubscription = false;
+	let nativeThread;
+	try {
+		assertWarmOwner();
+		if (binding.preserveNativeModel || binding.connectionScope === "supervision") {
+			try {
+				nativeThread = await assertAdoptedCodexThreadResumeAllowed(params, binding.threadId, options, assertWarmOwner);
+			} catch (error) {
+				assertWarmOwner();
+				preserveSubscription = isSameCodexAppServerThreadOwner(params.bindingStore.read(bindingIdentity), binding);
+				throw error;
+			}
+			assertWarmOwner();
+			if (nativeThread.status?.type === "notLoaded") {
+				preserveSubscription = true;
+				return { kind: "resume" };
+			}
+		}
+		const pluginThreadConfig = await options.buildLoadedPluginThreadConfig(binding);
+		assertWarmOwner();
+		if (pluginThreadConfig && pluginThreadConfig.fingerprint !== binding.pluginAppsFingerprint) return { kind: "rotate" };
+		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 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;
+			throw new CodexIncognitoPolicyChangeError();
+		}
+		if (!incognito && retainedThread.configFingerprint !== liveThreadConfigFingerprint) {
+			preserveSubscription = true;
+			return {
+				kind: "resume",
+				prebuiltFinalConfigPatch
+			};
+		}
+		await attestCodexThreadToolSurface({
+			client: params.client,
+			threadId: binding.threadId,
+			appIds: pluginThreadConfig?.provisionalAppIds ?? [],
+			signal: params.signal,
+			threadConfig: resumeParams.config,
+			restrictedToolSurface,
+			lifecycleTiming,
+			assertCurrent: assertWarmOwner
+		});
+		assertWarmOwner();
+		if (ephemeralPolicy && ephemeralPolicy.skillsInstructions !== params.skillsInstructions) try {
+			await refreshCodexThreadSkillsCatalog({
+				client: params.client,
+				threadId: binding.threadId,
+				skillsInstructions: params.skillsInstructions,
+				timeoutMs: params.appServer.requestTimeoutMs,
+				signal: params.signal,
+				assertCurrent: assertWarmOwner
+			});
+		} catch (error) {
+			preserveSubscription = true;
+			throw error;
+		}
+		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;
+		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");
+		assertWarmOwner();
+		lifecycleTiming.mark("thread-ready");
+		lifecycleTiming.logSummary({
+			runId: params.params.runId,
+			sessionId: params.params.sessionId,
+			sessionKey: params.params.sessionKey,
+			threadId: binding.threadId,
+			action: "resumed"
+		});
+		ownershipTransferred = true;
+		return {
+			kind: "ready",
+			binding: {
+				...binding,
+				...!incognito ? {
+					cwd: params.cwd,
+					model,
+					modelProvider,
+					nativeHookRelayGeneration,
+					environmentSelectionFingerprint
+				} : {},
+				liveThreadConfigFingerprint,
+				liveThreadEphemeralPolicy: ephemeralPolicy && {
+					...ephemeralPolicy,
+					skillsInstructions: params.skillsInstructions
+				},
+				liveThreadOwnership: retainedThread,
+				...!incognito && retainedThread.serviceTier && resumeParams.serviceTier === void 0 ? { clearInheritedServiceTier: true } : {},
+				lifecycle: { action: "resumed" }
+			}
+		};
+	} finally {
+		if (!ownershipTransferred) {
+			let failure;
+			try {
+				if (preserveSubscription) try {
+					assertWarmOwner();
+					preserveSubscription = isSameCodexAppServerThreadOwner(params.bindingStore.read(bindingIdentity), binding);
+				} catch {
+					preserveSubscription = false;
+				}
+				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") };
+				} else await retainedThread.release(binding.threadId);
+			} catch (cause) {
+				failure = { cause };
+			}
+			if (failure) await abandonCodexLiveThreadRelease({
+				client: params.client,
+				abandonClient: params.abandonClient,
+				lifecycleTiming,
+				threadId: binding.threadId
+			}, failure.cause);
+		}
+	}
+}
+//#endregion
+//#region extensions/codex/src/app-server/thread-lifecycle-adoption.ts
+/** All bound preparation follows attach's native-queue-before-binding-lease order. */
+async function withCodexThreadLifecycleBinding(params, run) {
+	const identity = sessionBindingIdentity({
+		sessionId: params.params.sessionId,
+		sessionKey: params.params.sessionKey,
+		agentId: params.agentId ?? params.params.agentId,
+		config: params.params.config
+	});
+	const { binding: snapshot, assertCurrent } = await resolveCodexSessionBinding({
+		reclaimStale: true,
+		bindingStore: params.bindingStore,
+		identity,
+		config: params.params.config,
+		storePath: params.params.sessionTarget?.storePath,
+		assertCurrent: () => {
+			params.params.hostCapabilities.assertActive();
+			params.assertCurrent?.();
+		},
+		signal: params.signal,
+		assertBinding: params.params.expectedSessionRuntimeOwnership ? (binding) => assertCodexSessionRuntimeOwnership(binding, params.params.expectedSessionRuntimeOwnership) : void 0
+	});
+	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 snapshot?.pendingResumeConfiguration ? await withExclusiveCodexAppServerThread({
+		bindingStore: params.bindingStore,
+		identity,
+		threadId: snapshot.threadId,
+		run: runWithLease
+	}) : snapshot ? await withCodexAppServerThreadMutation(snapshot.threadId, runWithLease) : await runWithLease();
+}
+/** Completes manual attachment only under the native queue and exact binding lease. */
+async function resumePendingCodexThread(params, context) {
+	const { binding, contextEngineBinding, lifecycleTiming, restrictedToolSurface } = context;
+	if (isIncognitoSessionKey(params.params.sessionKey) || context.transientRestriction || !restrictedToolSurface && binding.nativeToolPolicyRestricted === true || (contextEngineBinding ? !isContextEngineBindingCompatible(binding.contextEngine, contextEngineBinding) : binding.contextEngine !== void 0) || shouldRotateCodexGpt56MultiAgentBinding({
+		bindingModel: binding.model,
+		requestedModel: params.params.modelId
+	})) throw new Error(`Cannot configure resumed Codex thread ${binding.threadId} under a transient or incompatible session policy. The thread is preserved; retry from its normal session or use /new for the current policy.`);
+	const prebuiltPluginThreadConfig = params.pluginThreadConfig?.enabled ? await lifecycleTiming.measure("plugin-config-build", () => params.pluginThreadConfig?.build()) : void 0;
+	const clientId = resolveCodexAppServerClientInstanceId(params.client);
+	const resumed = await resumeExistingCodexThread(params, {
+		...context,
+		prebuiltPluginThreadConfig,
+		prepareResume: () => preparePendingCodexThreadResume(params, binding, context.dynamicToolsFingerprint),
+		releaseRetainedThread: async (assertCurrent) => {
+			const released = await context.releaseRetainedThread(binding.threadId, assertCurrent);
+			assertCurrent();
+			if (!released || binding.clientId && binding.clientId !== clientId) await releaseCodexConsumedLiveThread({
+				client: params.client,
+				abandonClient: params.abandonClient,
+				lifecycleTiming,
+				threadId: binding.threadId,
+				assertCurrent
+			});
+		}
+	});
+	if (!resumed) throw new Error(`Codex did not configure resumed thread ${binding.threadId}.`);
+	return resumed;
+}
+/** Manual attachment is intent, never evidence that loaded native overrides took effect. */
+async function preparePendingCodexThreadResume(params, binding, dynamicToolsFingerprint) {
+	const fail = (reason) => /* @__PURE__ */ new Error(`Cannot configure resumed Codex thread ${binding.threadId}: ${reason}. The thread is preserved; continue it in native Codex or use /new for the current OpenClaw tools.`);
+	const agentDir = resolveCodexThreadAgentDir(params);
+	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();
+	};
+	assertCurrent();
+	const { thread } = await params.client.request("thread/read", {
+		threadId: binding.threadId,
+		includeTurns: false
+	}, {
+		signal: params.signal,
+		assertCurrent
+	});
+	assertCurrent();
+	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;
+		if (!metadata) throw fail("its native tool catalog could not be read from the selected Codex home");
+		const recordedTools = metadata.dynamic_tools ?? [];
+		if (!Array.isArray(recordedTools) || codexDynamicToolsFingerprint(recordedTools) !== dynamicToolsFingerprint) throw fail("its immutable native tool catalog does not match the current OpenClaw tools");
+		assertCurrent();
+		return {
+			...observation,
+			assertCurrent
+		};
+	} catch (error) {
+		dispose();
+		throw error;
+	}
+}
+/** 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();
+	};
+	assertCurrent();
+	let thread;
+	try {
+		thread = await assertAdoptedCodexThreadResumeAllowed(params, binding.threadId, context, assertCurrent);
+	} finally {
+		assertCurrent();
+	}
+	assertCodexSupervisionThreadLineage(binding, thread);
+	return {
+		...observeCodexThreadConfiguration(params, thread, assertCurrent),
+		assertCurrent
+	};
+}
+function isCodexThreadNonRunning(status) {
+	return status?.type === "idle" || status?.type === "notLoaded" || status?.type === "systemError";
+}
+function observeCodexThreadConfiguration(params, thread, assertCurrent) {
+	if (!isCodexThreadNonRunning(thread.status)) throw new CodexAdoptedThreadActiveError();
+	const settledSystemError = thread.status.type === "systemError";
+	let unloaded = thread.status.type === "notLoaded";
+	const dispose = params.client.addNotificationHandler((notification) => {
+		if (notification.method === "thread/status/changed" && isJsonObject(notification.params) && notification.params.threadId === thread.id && isJsonObject(notification.params.status) && notification.params.status.type === "notLoaded") unloaded = true;
+	});
+	return {
+		modelProvider: thread.modelProvider,
+		dispose,
+		settledSystemError,
+		assertConfigured: () => {
+			assertCurrent();
+			if (!unloaded) throw new Error("Codex did not confirm unloading its previous configuration. The thread is preserved; stop competing native work and reconnect before retrying.");
+		}
+	};
+}
+//#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
+	};
+	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);
+	params.throwIfAborted();
+	const sourceResponse = await params.lifecycleTiming.measure("supervision-source-read", () => params.client.request("thread/read", {
+		threadId: pending.sourceThreadId,
+		includeTurns: true
+	}, requestOptions));
+	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);
+	const history = projectBoundedCodexThreadHistory({
+		thread: sourceThread,
+		throughTurnId: pending.lastTurnId ?? null,
+		importedAt: Date.now(),
+		modelProvider: sourceThread.modelProvider
+	});
+	let bindingCommitted = false;
+	let provisionalCleanupSafe = true;
+	let cleanupExpected = pending;
+	const trackPendingSupervisionArtifacts = async (cleanupThreadIds) => {
+		const expected = pending;
+		pending = withPendingSupervisionCleanup(pending, cleanupThreadIds);
+		let updated;
+		try {
+			updated = await params.bindingStore.mutate(params.bindingIdentity, {
+				kind: "patch-pending-supervision-branch",
+				expected,
+				pending
+			});
+		} catch (error) {
+			try {
+				const current = params.bindingStore.read(params.bindingIdentity);
+				if (matchesPendingSupervisionState(current, pending)) cleanupExpected = pending;
+				else if (matchesPendingSupervisionState(current, expected)) cleanupExpected = expected;
+				else throw new CodexThreadBindingConflictError(pending.sourceThreadId, "verifying supervised Codex cleanup tracking");
+			} catch (verificationError) {
+				provisionalCleanupSafe = false;
+				throw new CodexAppServerUnsafeSubscriptionError(`Codex supervised branch cleanup tracking could not be verified: ${cleanupThreadIds.join(", ")}`, { cause: new AggregateError([error, verificationError], void 0, { cause: error }) });
+			}
+			throw error;
+		}
+		cleanupExpected = updated ? pending : void 0;
+		if (!updated) throw new CodexThreadBindingConflictError(pending.sourceThreadId, "tracking supervised Codex branch cleanup");
+	};
+	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 probeThreadId = requireDistinctSupervisionThreadId({
+			threadId: readSupervisionResponseThreadId(rawProbeResponse),
+			sourceThreadId: pending.sourceThreadId,
+			role: "model probe"
+		});
+		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));
+		} 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 });
+			});
+		}
+		params.throwIfAborted();
+		const nativeModel = requireNonBlankSupervisionValue(probeResponse.model, "native model");
+		const nativeModelProvider = requireNativeSupervisionModelProvider({
+			responseModelProvider: probeResponse.modelProvider,
+			responseThreadModelProvider: probeResponse.thread.modelProvider
+		});
+		const nativeAttempt = {
+			...params.attempt,
+			modelId: nativeModel
+		};
+		const startParams = buildThreadStartParams(nativeAttempt, {
+			...params,
+			model: nativeModel,
+			modelProvider: nativeModelProvider
+		});
+		assertExactSupervisionModelSelection(startParams, {
+			model: nativeModel,
+			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 finalThreadId = requireDistinctSupervisionThreadId({
+			threadId: readSupervisionResponseThreadId(rawStartResponse),
+			sourceThreadId: pending.sourceThreadId,
+			otherThreadId: probeThreadId,
+			role: "canonical branch"
+		});
+		await trackPendingSupervisionArtifacts([finalThreadId]);
+		params.throwIfAborted();
+		const startResponse = assertCodexThreadStartResponse(rawStartResponse);
+		assertExactSupervisionModelSelection(startResponse, {
+			model: nativeModel,
+			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.provisionalAppIds?.length) try {
+			await params.lifecycleTiming.measure("plugin-app-attestation", () => checkCodexThreadAppAvailability({
+				client: params.client,
+				threadId: finalThreadId,
+				appIds: params.provisionalAppIds ?? [],
+				signal: params.signal
+			}));
+		} catch (error) {
+			if (!await discardUnattestedCodexPluginThread({
+				client: params.client,
+				threadId: finalThreadId,
+				ephemeral: startParams.ephemeral === true
+			})) {
+				provisionalCleanupSafe = false;
+				throw new CodexAppServerUnsafeSubscriptionError("Codex supervised plugin app attestation cleanup failed", { cause: error });
+			}
+			await trackPendingSupervisionArtifacts([]);
+			throw error;
+		}
+		if (history.responseItems.length > 0) {
+			await params.lifecycleTiming.measure("supervision-history-inject", () => params.client.request("thread/inject_items", {
+				threadId: finalThreadId,
+				items: history.responseItems
+			}, requestOptions));
+			params.throwIfAborted();
+		}
+		const historyCoveredThrough = (/* @__PURE__ */ new Date()).toISOString();
+		const bindingModelProvider = params.normalizeBindingModelProvider(params.attempt.authProfileId, nativeModelProvider);
+		let committed = false;
+		try {
+			committed = await params.bindingStore.mutate(params.bindingIdentity, {
+				kind: "commit-pending-supervision-branch",
+				expected: pending,
+				threadId: finalThreadId,
+				patch: {
+					...params.bindingPatch,
+					model: nativeModel,
+					modelProvider: bindingModelProvider,
+					historyCoveredThrough
+				}
+			}, params.throwIfAborted);
+		} catch (error) {
+			let current;
+			try {
+				current = params.bindingStore.read(params.bindingIdentity);
+			} catch (readError) {
+				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;
+			else {
+				if (!matchesPendingSupervisionState(current, pending)) {
+					provisionalCleanupSafe = false;
+					throw new CodexAppServerUnsafeSubscriptionError(`Canonical Codex branch binding changed while commit was uncertain: ${finalThreadId}`, { cause: error });
+				}
+				throw error;
+			}
+		}
+		if (!committed) throw new CodexThreadBindingConflictError(pending.sourceThreadId, "committing a supervised Codex branch");
+		bindingCommitted = true;
+		params.lifecycleTiming.mark("thread-ready");
+		params.lifecycleTiming.logSummary({
+			runId: params.attempt.runId,
+			sessionId: params.attempt.sessionId,
+			sessionKey: params.attempt.sessionKey,
+			threadId: finalThreadId,
+			action: "forked"
+		});
+		return {
+			...params.binding,
+			...params.bindingPatch,
+			threadId: finalThreadId,
+			pendingSupervisionBranch: void 0,
+			model: nativeModel,
+			modelProvider: bindingModelProvider,
+			historyCoveredThrough,
+			lifecycle: { action: "forked" }
+		};
+	} catch (error) {
+		if (bindingCommitted) throw error;
+		if (!provisionalCleanupSafe) {
+			await params.abandonClient();
+			throw error;
+		}
+		const cleanup = await cleanPendingSupervisionArtifacts(params.client, pending);
+		const nextPending = withPendingSupervisionCleanup(pending, cleanup.remaining);
+		let cleanupStateError;
+		if (cleanupExpected && !isDeepStrictEqual(cleanupExpected, nextPending)) try {
+			await params.bindingStore.mutate(params.bindingIdentity, {
+				kind: "patch-pending-supervision-branch",
+				expected: cleanupExpected,
+				pending: nextPending
+			});
+		} catch (stateError) {
+			cleanupStateError = stateError;
+		}
+		const unsafeCleanup = cleanup.remaining.length > 0 || isCodexAppServerUnsafeSubscriptionError(error);
+		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 });
+		throw error;
+	}
+}
+function buildPendingSupervisionProbeForkParams(params, pending) {
+	const runtimeConfig = buildCodexRuntimeThreadConfigForRun(params.attempt, params.config, params);
+	return {
+		threadId: pending.sourceThreadId,
+		...pending.lastTurnId ? { lastTurnId: pending.lastTurnId } : {},
+		cwd: params.cwd,
+		approvalPolicy: params.appServer.approvalPolicy,
+		approvalsReviewer: resolveCodexThreadApprovalsReviewer(params.appServer, runtimeConfig),
+		...codexThreadSandboxOrPermissions(params.appServer),
+		...params.appServer.serviceTier !== void 0 ? { serviceTier: params.appServer.serviceTier } : {},
+		config: runtimeConfig,
+		developerInstructions: params.developerInstructions ?? buildDeveloperInstructions(params.attempt, { dynamicTools: params.dynamicTools }),
+		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 {
+		threadId = requireNonBlankSupervisionValue(params.threadId, `${params.role} thread id`);
+	} catch (error) {
+		throw new CodexAppServerUnsafeSubscriptionError(`Codex supervision ${params.role} may have materialized without a safe thread id`, { cause: error });
+	}
+	if (threadId === params.sourceThreadId || threadId === params.otherThreadId) throw new CodexAppServerUnsafeSubscriptionError(`Codex supervision ${params.role} reused an existing thread: ${threadId}`);
+	return threadId;
+}
+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(", ")}`);
+	}
+	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");
+	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) => {
+		const params = {
+			...input,
+			assertCurrent: assert
+		};
+		const expectedOwnership = params.params.expectedSessionRuntimeOwnership;
+		let binding = saved;
+		let selectionBinding = binding;
+		if (hasCodexNativeToolCatalog(binding)) {
+			const nativeCatalog = await loadCodexNativeToolCatalog({
+				client: params.client,
+				binding,
+				appServer: params.appServer,
+				agentDir: resolveCodexThreadAgentDir(params),
+				assertCurrent: () => {
+					params.signal?.throwIfAborted();
+					assert();
+				}
+			});
+			if (!isDeepStrictEqual(params.dynamicTools, nativeCatalog)) throw new Error("Canonical Codex declarations changed after tool preparation; retry the turn on its preserved native thread.");
+		}
+		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;
+		let replacementPredecessor;
+		const initialBoundThreadId = binding?.threadId;
+		const initialBoundClientId = binding?.clientId;
+		const throwIfAborted = () => throwIfCodexThreadLifecycleAborted(params.signal);
+		const prepareRequestContext = async () => {
+			const context = await prepareCodexThreadRequestContext(params, {
+				binding,
+				selectionBinding,
+				bindingIdentity,
+				clientId,
+				config: callerConfig,
+				preflight,
+				assertCurrent: assert,
+				throwIfAborted
+			});
+			params.skillsInstructions = params.inferenceRoute ? void 0 : input.skillsInstructions;
+			return context;
+		};
+		const releaseRetainedThread = (threadId, ownerClientId = initialBoundClientId, assertCurrent) => releaseCodexBoundLiveThread({
+			client: params.client,
+			clientId,
+			ownerClientId,
+			abandonClient: params.abandonClient,
+			lifecycleTiming,
+			threadId,
+			assertCurrent
+		});
+		if (binding?.pendingSupervisionBranch) {
+			const requestContext = await prepareRequestContext();
+			await releaseRetainedThread(binding.threadId);
+			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));
+			return publishCodexThreadInferenceBinding(params, await materializePendingSupervisionBranch({
+				client: params.client,
+				abandonClient: params.abandonClient ?? (() => closeCodexStartupClientBestEffort(params.client)),
+				bindingStore: params.bindingStore,
+				bindingIdentity,
+				binding: pendingBinding,
+				attempt: params.params,
+				cwd: params.cwd,
+				dynamicTools: params.dynamicTools,
+				appServer: params.appServer,
+				developerInstructions: params.developerInstructions,
+				skillsInstructions: params.skillsInstructions,
+				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);
+				},
+				lifecycleTiming,
+				normalizeBindingModelProvider: requestContext.normalizeBindingModelProvider,
+				bindingPatch: {
+					cwd: params.cwd,
+					...clientId ? { clientId } : {},
+					authProfileId: void 0,
+					agentWorkspaceDeveloperInstructions: params.agentWorkspaceDeveloperInstructions,
+					preserveNativeModel: true,
+					...buildCodexThreadBindingPolicy(params, preflight),
+					webSearchThreadConfigFingerprint,
+					mcpServersFingerprint: params.mcpServersFingerprintEvaluated === true ? params.mcpServersFingerprint : pendingBinding.mcpServersFingerprint,
+					nativeHookRelayGeneration: finalConfigPatch.nativeHookRelayGeneration,
+					appServerRuntimeFingerprint: buildCodexAppServerConnectionFingerprint(params.appServer, params.params.agentDir),
+					pluginAppsFingerprint: pluginThreadConfig?.fingerprint,
+					pluginAppsInputFingerprint: pluginThreadConfig?.inputFingerprint,
+					pluginAppPolicyContext: pluginThreadConfig?.policyContext,
+					conversationSourceTransferComplete: true
+				}
+			}));
+		}
+		const clearCurrentBinding = async (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);
+			binding = void 0;
+		};
+		const transientDelegationRestriction = params.params.delegationCapability === "report_only";
+		const persistentWebSearchRestriction = params.webSearchAllowed === false && params.persistentWebSearchAllowed === false;
+		const transientNativeToolRestriction = params.nativeCodeModeEnabled === false && !persistentWebSearchRestriction;
+		const transientWebSearchRestriction = isTransientWebSearchRestriction(params);
+		if (binding?.pendingResumeConfiguration) return publishCodexThreadInferenceBinding(params, await resumePendingCodexThread(params, {
+			...await prepareRequestContext(),
+			binding,
+			clearCurrentBinding,
+			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 && 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");
+		}
+		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");
+		}
+		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");
+		}
+		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,
+				bindingModel: binding.model,
+				requestedModel: params.params.modelId
+			});
+			await clearCurrentBinding("rotating a GPT-5.6 multi-agent thread binding");
+		}
+		selectionBinding = binding;
+		let preserveExistingBinding = transientDelegationRestriction || !ringZeroActive && params.nativeProviderWebSearchSupport === "unknown" && !binding?.threadId;
+		let rotatedContextEngineBinding = false;
+		let prebuiltPluginThreadConfig;
+		const buildLoadedPluginThreadConfig = async (current) => {
+			if (!params.pluginThreadConfig?.requiresCurrentPolicyCheck && !shouldRecheckRecoverablePluginBinding({
+				binding: current,
+				pluginThreadConfig: params.pluginThreadConfig
+			})) return;
+			try {
+				prebuiltPluginThreadConfig = await lifecycleTiming.measure("plugin-config-recovery", () => params.pluginThreadConfig?.build({ threadId: current.threadId }));
+			} catch (error) {
+				throwIfAborted();
+				if (params.pluginThreadConfig?.requiresCurrentPolicyCheck) throw error;
+				embeddedAgentLog.warn("codex app-server plugin app config recovery check failed", {
+					error,
+					threadId: current.threadId
+				});
+				return;
+			}
+			throwIfAborted();
+			return prebuiltPluginThreadConfig;
+		};
+		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 predecessorBinding = binding;
+			assertCodexBindingMayBeReplaced(predecessorBinding, "changing configured MCP ownership", expectedOwnership);
+			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) {
+			assertCodexBindingMayBeReplaced(binding, "changing MCP configuration", expectedOwnership);
+			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");
+			}
+			binding = void 0;
+		}
+		const deferLegacyWebSearchRotationToTransientNativeSurface = params.nativeCodeModeEnabled === false && binding?.webSearchThreadConfigFingerprint === void 0 && !persistentWebSearchRestriction;
+		if (binding?.threadId && webSearchBindingChanged && !deferLegacyWebSearchRotationToTransientNativeSurface) {
+			assertCodexBindingMayBeReplaced(binding, "changing web-search configuration", expectedOwnership);
+			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");
+			}
+			binding = void 0;
+		}
+		if (binding?.threadId && transientNativeToolRestriction && !ringZeroActive) {
+			assertCodexBindingMayBeReplaced(binding, "starting a native-tool-restricted turn", expectedOwnership);
+			embeddedAgentLog.debug("codex app-server native tool surface disabled for turn; starting transient thread", { threadId: binding.threadId });
+			preserveExistingBinding = true;
+			binding = void 0;
+		}
+		if (binding?.threadId && transientDelegationRestriction) {
+			assertCodexBindingMayBeReplaced(binding, "starting a delegation-restricted turn", expectedOwnership);
+			embeddedAgentLog.debug("codex app-server delegation restricted for turn; starting transient thread", { threadId: binding.threadId });
+			binding = void 0;
+		}
+		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,
+					engineId: contextEngineBinding?.engineId,
+					previousEngineId: binding.contextEngine?.engineId,
+					epoch: contextEngineBinding?.projection?.epoch,
+					previousEpoch: binding.contextEngine?.projection?.epoch,
+					fingerprint: contextEngineBinding?.projection?.fingerprint,
+					previousFingerprint: binding.contextEngine?.projection?.fingerprint,
+					policyFingerprint: contextEngineBinding?.policyFingerprint,
+					previousPolicyFingerprint: binding.contextEngine?.policyFingerprint
+				});
+				await clearCurrentBinding("rotating a stale thread binding");
+				rotatedContextEngineBinding = true;
+			}
+		}
+		if (binding?.threadId && !areUserMcpServersFingerprintsCompatible({
+			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");
+		}
+		if (binding?.threadId) {
+			if (isCodexPluginThreadBindingStale({
+				codexPluginsEnabled: params.pluginThreadConfig?.enabled ?? false,
+				bindingFingerprint: binding.pluginAppsFingerprint,
+				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");
+			}
+		}
+		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?.threadId) {
+			if (binding.dynamicToolsFingerprint && !areCodexDynamicToolFingerprintsCompatible({
+				previous: binding.dynamicToolsFingerprint,
+				next: dynamicToolsFingerprint,
+				nextLegacy: legacyDynamicToolsFingerprint
+			})) {
+				assertCodexBindingMayBeReplaced(binding, "changing the dynamic tool catalog", expectedOwnership);
+				preserveExistingBinding = shouldStartTransientNoToolThread({
+					previous: binding.dynamicToolsFingerprint,
+					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 {
+				const requestContext = await prepareRequestContext();
+				const warmReuse = await tryReuseCodexLiveThread({
+					...requestContext,
+					params,
+					binding,
+					clientId,
+					buildLoadedPluginThreadConfig
+				});
+				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");
+				} else {
+					const resumeBinding = binding;
+					const resumed = await resumeExistingCodexThread(params, {
+						...requestContext,
+						binding: resumeBinding,
+						clearCurrentBinding,
+						prebuiltFinalConfigPatch: warmReuse.prebuiltFinalConfigPatch,
+						prebuiltPluginThreadConfig,
+						buildLoadedPluginThreadConfig,
+						prepareResume: () => prepareCodexThreadResume(params, resumeBinding, requestContext),
+						releaseRetainedThread: async (assertCurrent) => {
+							await releaseRetainedThread(resumeBinding.threadId, resumeBinding.clientId, assertCurrent);
+						}
+					});
+					if (resumed) return publishCodexThreadInferenceBinding(params, resumed);
+				}
+			}
+		}
+		assertCodexBindingMayBeReplaced(binding, "starting a fresh native thread", expectedOwnership);
+		const requestContext = await prepareRequestContext();
+		if (initialBoundThreadId && !preserveExistingBinding && !replacementPredecessor) await releaseRetainedThread(initialBoundThreadId);
+		const started = await startFreshCodexThread(params, {
+			...requestContext,
+			prebuiltPluginThreadConfig,
+			preserveExistingBinding,
+			rotatedContextEngineBinding,
+			replacementPredecessor
+		});
+		if (replacementPredecessor) await releaseRetainedThread(replacementPredecessor.threadId, replacementPredecessor.clientId);
+		return publishCodexThreadInferenceBinding(params, started);
+	});
+}
+//#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,
+		turnScopedDeveloperInstructions: options.turnScopedDeveloperInstructions,
+		memoryCollaborationInstructions: options.memoryCollaborationInstructions
+	}) : 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
+		} : {},
+		...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: buildTurnScopedCollaborationInstructions(params, options)
+		}
+	};
+}
+function buildCodexParentLocalInstructions(params, options = {}) {
+	const contextInstructions = joinPresentSections(options.turnScopedDeveloperInstructions, options.skillsInstructions, options.memoryCollaborationInstructions);
+	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.",
+		"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 { 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 };