@openclaw/codex 2026.10.2 → 2026.10.5-beta.2

package/dist/.setup/{side-question-oTlegAz3.mjs → side-question-YQ5FObkD.mjs}

@@ -1,39 +1,66 @@
 import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
-import { m as sessionBindingIdentity } from "./session-binding-record-BZB8RgcF.mjs";
-import { c as shouldAutoApproveCodexAppServerApprovals, f as readCodexRequirementsToml, l as withMcpElicitationsApprovalPolicy, n as hasCodexMcpToolApprovalOverrides } from "./config-security-KAPScztc.mjs";
-import { c as isCodexPairedNodeRemoteExecPlacementSandbox, d as readCodexPluginConfig, l as isCodexRemoteExecPlacementSandbox, u as isCodexSandboxExecServerEnabled } from "./config-parsing-BQq-CHTF.mjs";
-import { i as resolveCodexAppServerHomeScope, l as resolveCodexModelBackedReviewerPolicyContext } from "./config-options-HG_Rr3W_.mjs";
-import { n as formatCodexUsageLimitErrorMessage } from "./rate-limits-CMPy24F5.mjs";
-import { i as resolveCodexBindingAppServerConnection, r as requireCodexSupervisionModelSelection } from "./binding-connection-C-08ez1w.mjs";
-import { n as canUseCodexModelBackedApprovalsReviewerForModel, r as resolveOpenClawExecPolicyForCodexAppServer } from "./config-0Gxk3_eq.mjs";
-import { X as readRecentCodexRateLimits, b as withLeasedCodexAppServerClientStartSelectionRetry, c as getLeasedSharedCodexAppServerClient, m as releaseCodexAppServerClientLease, tt as resolveCodexAppServerPreparedAuthHandoff } from "./shared-client-5NUq43f3.mjs";
-import { N as toCodexDynamicToolProtocolResponse, P as resolveCodexToolAbortTerminalReason, T as handleDynamicToolCallWithTimeout, _ as assertCodexTurnStartResponse, a as isCodexAppServerIndeterminateRequestCancellationError, k as resolveDynamicToolCallTimeoutMs, m as assertCodexThreadForkResponse, r as isCodexAppServerApprovalRequest, w as createCodexElicitationResponse, y as readCodexDynamicToolCallParams } from "./client-ChJtGEdJ.mjs";
-import { d as terminateCodexBackgroundTerminals, f as unsubscribeCodexThreadBestEffort, l as retireUnsafeCodexTurnClientBestEffort, s as interruptCodexTurnAndWaitBestEffort } from "./attempt-client-cleanup-DPUGAWP2.mjs";
-import { t as CodexEphemeralTurn } from "./ephemeral-turn-U4th15a6.mjs";
-import { Ct as mergeCodexThreadConfigs, N as resolveCodexNativeHookRelayEvents, O as buildCodexNativeHookRelayConfig, P as resolveCodexNativeHookRelayTtlMs, _ as CODEX_NATIVE_PERSONALITY_NONE, b as resolveCodexAppServerThreadModelSelection, k as buildCodexNativeHookRelayDisabledConfig, m as resolveCodexWebSearchPlan, pt as resolveCodexDynamicToolsLoading, r as buildCodexRuntimeThreadConfig, wt as refreshCodexPluginAppApprovalPolicy } from "./thread-requests-Bj_Lixmv.mjs";
-import { b as resolveCodexAppServerReasoningEffort, o as buildCodexUserInput, r as buildCodexTemporalAdditionalContext, y as readCodexSupportedReasoningEfforts } from "./thread-lifecycle--EPPTNTe.mjs";
-import { r as resolveCodexSessionBinding } from "./session-binding-Ce7BqiPN.mjs";
-import { i as assertCodexSupervisionThreadLineage, n as CodexThreadPolicyHandoffError, o as refreshCodexThreadPolicy } from "./thread-policy-VtqLex1l.mjs";
-import { t as resolveCodexNativeExecutionBlock } from "./sandbox-guard-WqE8yPge.mjs";
-import { a as resolveCodexExternalSandboxPolicyForOpenClawSandbox, c as shouldEnableCodexAppServerNativeToolSurface, l as shouldRequireCodexSandboxExecServerEnvironment, o as resolveCodexMessageToolProvider, s as resolveCodexSandboxEnvironmentSelection, t as buildDynamicTools } from "./dynamic-tool-build-BCi00feJ.mjs";
-import { i as resolveCodexSessionPermissionCwd, n as applyCodexSessionPermissionPolicy, r as resolveCodexEffectiveSessionPermissionPolicy, t as CODEX_SESSION_PERMISSION_EXEC_MODES } from "./session-permission-policy-BxIUJ0Zd.mjs";
-import { a as emitDynamicToolStartedDiagnostic, c as ensureCodexSandboxExecServerEnvironment, i as emitDynamicToolErrorDiagnostic, l as releaseCodexSandboxExecServerEnvironment, m as CodexNativeToolLifecycleProjector, o as emitDynamicToolTerminalDiagnostic, r as routeCodexAppServerElicitationRequest, s as handleCodexAppServerApprovalRequest, t as createCodexDynamicToolBridge, u as createCodexNativePreToolUseFailureBuffer } from "./dynamic-tools-DUv6Sr6h.mjs";
-import { t as resolveCodexAppServerForModelProvider } from "./app-server-policy-Bg4FZw1f.mjs";
-import { n as resolveCodexProviderWebSearchSupportForClient } from "./provider-capabilities-DhkeeHJd.mjs";
+import { m as sessionBindingIdentity } from "./session-binding-record-DU_0biMD.mjs";
+import { c as withMcpElicitationsApprovalPolicy, d as readCodexRequirementsToml, n as hasCodexMcpToolApprovalOverrides, s as shouldAutoApproveCodexAppServerApprovals } from "./config-security-clxAZYWX.mjs";
+import { c as isCodexPairedNodeRemoteExecPlacementSandbox, d as readCodexPluginConfig, l as isCodexRemoteExecPlacementSandbox, u as isCodexSandboxExecServerEnabled } from "./config-parsing-DsWSCPHO.mjs";
+import { i as resolveCodexAppServerHomeScope, l as resolveCodexModelBackedReviewerPolicyContext } from "./config-options-DDzeNQ8m.mjs";
+import { n as formatCodexUsageLimitErrorMessage } from "./rate-limits-CI8pTPqL.mjs";
+import { i as resolveCodexBindingAppServerConnection, r as requireCodexSupervisionModelSelection } from "./binding-connection-B7HAAZSI.mjs";
+import { n as canUseCodexModelBackedApprovalsReviewerForModel, r as resolveOpenClawExecPolicyForCodexAppServer } from "./config-C1YVVLEA.mjs";
+import { X as readRecentCodexRateLimits, b as withLeasedCodexAppServerClientStartSelectionRetry, c as getLeasedSharedCodexAppServerClient, m as releaseCodexAppServerClientLease, tt as resolveCodexAppServerPreparedAuthHandoff } from "./shared-client-BjiqpbC5.mjs";
+import { E as resolveDynamicToolCallTimeoutMs, O as toCodexDynamicToolProtocolResponse, T as handleDynamicToolCallWithTimeout, _ as assertCodexTurnStartResponse, a as isCodexAppServerIndeterminateRequestCancellationError, k as resolveCodexToolAbortTerminalReason, m as assertCodexThreadForkResponse, r as isCodexAppServerApprovalRequest, w as createCodexElicitationResponse, y as readCodexDynamicToolCallParams } from "./client-zrCKOu_E.mjs";
+import { d as terminateCodexBackgroundTerminals, f as unsubscribeCodexThreadBestEffort, l as retireUnsafeCodexTurnClientBestEffort, s as interruptCodexTurnAndWaitBestEffort } from "./attempt-client-cleanup-CxX4cTSi.mjs";
+import { t as CodexEphemeralTurn } from "./ephemeral-turn-Dk0wWoqi.mjs";
+import { d as mergeCodexThreadConfigs, f as refreshCodexPluginAppApprovalPolicy } from "./project-doc-thread-config-BVcvnps8.mjs";
+import { n as resolveCodexAppServerReasoningEffort, t as readCodexSupportedReasoningEfforts } from "./reasoning-effort-CS9kKWB9.mjs";
+import { h as resolveCodexWebSearchPlan, r as buildCodexRuntimeThreadConfig, z as resolveCodexDynamicToolsLoading } from "./thread-requests-BgzJwJtS.mjs";
+import { i as resolveCodexSessionBinding } from "./session-binding-JEHNMPsr.mjs";
+import { i as resolveCodexAppServerThreadModelSelection, t as CODEX_NATIVE_PERSONALITY_NONE } from "./thread-model-selection-DcVebr8N.mjs";
+import { t as resolveCodexNativeExecutionBlock } from "./sandbox-guard-DIImwCy1.mjs";
+import { i as assertCodexSupervisionThreadLineage, n as CodexThreadPolicyHandoffError, o as refreshCodexThreadPolicy } from "./thread-policy-BEecBTJM.mjs";
+import { o as runCodexCleanupStep } from "./run-attempt-lifecycle-KN4oh-7O.mjs";
+import { a as resolveCodexExternalSandboxPolicyForOpenClawSandbox, c as shouldEnableCodexAppServerNativeToolSurface, l as shouldRequireCodexSandboxExecServerEnvironment, o as resolveCodexMessageToolProvider, s as resolveCodexSandboxEnvironmentSelection, t as buildDynamicTools } from "./dynamic-tool-build-BMiiFROa.mjs";
+import { a as buildCodexNativeHookRelayDisabledConfig, i as buildCodexNativeHookRelayConfig, l as resolveCodexNativeHookRelayEvents, u as resolveCodexNativeHookRelayTtlMs } from "./native-hook-relay-CSZpcjwq.mjs";
+import { i as resolveCodexSessionPermissionCwd, n as applyCodexSessionPermissionPolicy, r as resolveCodexEffectiveSessionPermissionPolicy, t as CODEX_SESSION_PERMISSION_EXEC_MODES } from "./session-permission-policy-CD2MAWU8.mjs";
+import { a as handleCodexAppServerApprovalRequest, c as createCodexNativePreToolUseFailureBuffer, d as buildCodexTemporalAdditionalContext, g as buildCodexUserInput, i as createCodexDynamicToolDiagnostics, o as ensureCodexSandboxExecServerEnvironment, r as routeCodexAppServerElicitationRequest, s as releaseCodexSandboxExecServerEnvironment, t as createCodexDynamicToolBridge, y as CodexNativeToolLifecycleProjector } from "./dynamic-tools-DPPHrGKB.mjs";
+import { t as resolveCodexAppServerForModelProvider } from "./app-server-policy-D_zv8J7V.mjs";
+import { n as resolveCodexProviderWebSearchSupportForClient } from "./provider-capabilities-DtJKxDf6.mjs";
 import { readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { randomUUID } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
 import { resolveSessionAgentIdsStrict } from "openclaw/plugin-sdk/agent-scope-runtime";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
-import { buildAgentHookContextChannelFields, embeddedAgentLog, formatErrorMessage as formatErrorMessage$1, resolveSandboxContext, runAgentCleanupStep } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { resolveAgentWorkspaceDir } from "openclaw/plugin-sdk/agent-runtime";
+import { buildAgentHookContextChannelFields, embeddedAgentLog, formatErrorMessage as formatErrorMessage$1, resolveSandboxContext } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { loadExecApprovals } from "openclaw/plugin-sdk/exec-approvals-runtime";
 import { loadCodexBundleMcpApprovalConfig, resolveCodexMcpToolOverridesForAgent } from "openclaw/plugin-sdk/codex-mcp-projection";
 import { registerNativeHookRelayForBundledRuntime } from "openclaw/plugin-sdk/native-hook-relay-runtime";
 //#region extensions/codex/src/app-server/side-question-cleanup.ts
 async function cleanupCodexSideQuestion(client, params) {
+	const cleanupThread = async () => {
+		if (!params.threadId) return;
+		if (params.interrupt && params.turnId !== void 0) {
+			if (!await interruptCodexTurnAndWaitBestEffort(client, {
+				threadId: params.threadId,
+				turnId: params.turnId,
+				timeoutMs: params.timeoutMs
+			})) {
+				await retireUnsafeCodexTurnClientBestEffort(client, "side turn interrupt");
+				throw new Error("Codex /btw cleanup could not confirm the side turn stopped; background terminals may still be running.");
+			}
+		}
+		if (params.terminateBackgroundTerminals && params.turnId !== void 0) try {
+			await terminateCodexBackgroundTerminals(client, params.threadId);
+		} catch (error) {
+			await retireUnsafeCodexTurnClientBestEffort(client, "side background terminals");
+			throw error;
+		}
+		if (!await unsubscribeCodexThreadBestEffort(client, {
+			threadId: params.threadId,
+			timeoutMs: params.timeoutMs
+		})) await retireUnsafeCodexTurnClientBestEffort(client, "side thread unsubscribe");
+	};
 	const errors = [];
-	for (const cleanup of [() => cleanupCodexSideThread(client, params), ...params.afterThreadCleanup]) try {
+	for (const cleanup of [cleanupThread, ...params.afterThreadCleanup]) try {
 		const pending = cleanup();
 		if (pending) await pending;
 	} catch (error) {
@@ -44,29 +71,6 @@ async function cleanupCodexSideQuestion(client, params) {
 	if (errors.length === 1) throw errors[0];
 	throw new AggregateError(errors, errors.map(formatErrorMessage).join("; "), { cause: errors[0] });
 }
-async function cleanupCodexSideThread(client, params) {
-	if (!params.threadId) return;
-	if (params.interrupt && params.turnId !== void 0) {
-		if (!await interruptCodexTurnAndWaitBestEffort(client, {
-			threadId: params.threadId,
-			turnId: params.turnId,
-			timeoutMs: params.timeoutMs
-		})) {
-			await retireUnsafeCodexTurnClientBestEffort(client, "side turn interrupt");
-			throw new Error("Codex /btw cleanup could not confirm the side turn stopped; background terminals may still be running.");
-		}
-	}
-	if (params.terminateBackgroundTerminals && params.turnId !== void 0) try {
-		await terminateCodexBackgroundTerminals(client, params.threadId);
-	} catch (error) {
-		await retireUnsafeCodexTurnClientBestEffort(client, "side background terminals");
-		throw error;
-	}
-	if (!await unsubscribeCodexThreadBestEffort(client, {
-		threadId: params.threadId,
-		timeoutMs: params.timeoutMs
-	})) await retireUnsafeCodexTurnClientBestEffort(client, "side thread unsubscribe");
-}
 //#endregion
 //#region extensions/codex/src/app-server/side-question-instructions.ts
 const SIDE_DEVELOPER_INSTRUCTIONS = `You are in a side conversation, not the main thread.
@@ -386,6 +390,63 @@ async function runCodexAppServerSideQuestion(params, options) {
 		sandboxEnvironment = environment;
 		sandboxEnvironmentClient = targetClient;
 	};
+	async function createCodexSideToolBridge(nativeProviderWebSearchSupport) {
+		const resolvedWorkspace = effectiveParams.workspaceDir ?? cwd;
+		const sandboxSessionKey = sideRunParams.sandboxSessionKey?.trim() || sideRunParams.sessionKey?.trim() || sideRunParams.sessionId || sessionAgentId;
+		const sandbox = sideRunParams.sandbox !== void 0 ? sideRunParams.sandbox : await resolveSandboxContext({
+			config: sideRunParams.config,
+			sessionKey: sandboxSessionKey,
+			workspaceDir: cwd
+		});
+		let webSearchAllowed = false;
+		const tools = await buildDynamicTools({
+			params: sideRunParams,
+			resolvedWorkspace,
+			effectiveWorkspace: cwd,
+			sandboxSessionKey,
+			sandbox,
+			nativeToolSurfaceEnabled,
+			nativeProviderWebSearchSupport,
+			sessionPermissionPolicy,
+			runAbortController,
+			sessionAgentId,
+			policyAgentId: sessionAgentId,
+			pluginConfig,
+			onYieldDetected: () => {},
+			onWebSearchPolicyResolved: (allowed) => {
+				webSearchAllowed = allowed;
+			}
+		});
+		const requestedWebSearchPlan = resolveCodexWebSearchPlan({
+			config: sideRunParams.config,
+			nativeToolSurfaceEnabled,
+			nativeProviderWebSearchSupport,
+			webSearchAllowed
+		});
+		const webSearchPlan = requestedWebSearchPlan.kind === "managed" ? resolveCodexWebSearchPlan({
+			config: sideRunParams.config,
+			webSearchAllowed: false
+		}) : requestedWebSearchPlan;
+		const exposedTools = tools.filter((tool) => tool.name !== "web_search" && tool.name !== "computer");
+		return {
+			toolBridge: createCodexDynamicToolBridge({
+				tools: exposedTools,
+				signal: runAbortController.signal,
+				loading: resolveCodexDynamicToolsLoading(pluginConfig),
+				hookContext: {
+					agentId: sessionAgentId,
+					config: sideRunParams.config,
+					contextWindowTokens: sideRunParams.model.contextWindow,
+					sessionId: sideRunParams.sessionId,
+					sessionKey: sideRunParams.sessionKey,
+					runId: sideRunParams.runId,
+					currentChannelProvider: resolveCodexMessageToolProvider(sideRunParams),
+					...buildAgentHookContextChannelFields(sideRunParams)
+				}
+			}),
+			webSearchPlan
+		};
+	}
 	try {
 		assertCurrent();
 		const autoApproveMcpTools = shouldAutoApproveCodexAppServerApprovals(appServer);
@@ -399,7 +460,7 @@ async function runCodexAppServerSideQuestion(params, options) {
 		});
 		const approvalPolicy = Object.keys(binding.pluginAppPolicyContext?.apps ?? {}).length > 0 || hasCodexMcpToolApprovalOverrides(params.cfg?.mcp?.servers, Object.keys(projectedMcpServers), projectedMcpServers) ? withMcpElicitationsApprovalPolicy(appServer.approvalPolicy) : appServer.approvalPolicy;
 		const sandbox = appServer.sandbox;
-		const nativeProviderWebSearchSupport = resolveCodexWebSearchPlan({
+		const { toolBridge, webSearchPlan } = await createCodexSideToolBridge(resolveCodexWebSearchPlan({
 			config: params.cfg,
 			nativeToolSurfaceEnabled
 		}).kind === "native-hosted" ? await resolveCodexProviderWebSearchSupportForClient({
@@ -407,18 +468,7 @@ async function runCodexAppServerSideQuestion(params, options) {
 			timeoutMs: appServer.requestTimeoutMs,
 			modelProviderOverride: modelSelection.modelProvider,
 			signal: runAbortController.signal
-		}) : "unsupported";
-		const { toolBridge, webSearchPlan } = await createCodexSideToolBridge({
-			params: sideRunParams,
-			cwd,
-			resolvedWorkspace: effectiveParams.workspaceDir ?? cwd,
-			pluginConfig,
-			sessionAgentId,
-			nativeToolSurfaceEnabled,
-			nativeProviderWebSearchSupport,
-			sessionPermissionPolicy,
-			runAbortController
-		});
+		}) : "unsupported");
 		const handleServerRequest = async (request, _scope, requestSignal, setExecutionTimeoutMs) => {
 			const signal = AbortSignal.any([requestSignal, runAbortController.signal]);
 			if (signal.aborted || !childThreadId || !turnId) return;
@@ -458,14 +508,14 @@ async function runCodexAppServerSideQuestion(params, options) {
 			});
 			setExecutionTimeoutMs?.(timeoutMs);
 			const toolStartedAt = Date.now();
-			const diagnosticContext = {
+			const diagnostics = createCodexDynamicToolDiagnostics({
 				call,
 				agentId: sessionAgentId,
 				runId: sideRunParams.runId,
 				sessionId: params.sessionId,
 				sessionKey: params.sessionKey
-			};
-			emitDynamicToolStartedDiagnostic(diagnosticContext);
+			});
+			diagnostics.started();
 			const toolCall = handleDynamicToolCallWithTimeout({
 				call,
 				toolBridge,
@@ -476,18 +526,10 @@ async function runCodexAppServerSideQuestion(params, options) {
 			activeDynamicToolCalls.add(toolCall);
 			try {
 				const response = await toolCall;
-				emitDynamicToolTerminalDiagnostic({
-					...diagnosticContext,
-					response,
-					durationMs: Math.max(0, Date.now() - toolStartedAt)
-				});
+				diagnostics.terminal(response, Math.max(0, Date.now() - toolStartedAt));
 				return toCodexDynamicToolProtocolResponse(response);
 			} catch (error) {
-				emitDynamicToolErrorDiagnostic({
-					...diagnosticContext,
-					durationMs: Math.max(0, Date.now() - toolStartedAt),
-					terminalReason: signal.aborted ? resolveCodexToolAbortTerminalReason(signal) : "failed"
-				});
+				diagnostics.error(Math.max(0, Date.now() - toolStartedAt), signal.aborted ? resolveCodexToolAbortTerminalReason(signal) : "failed");
 				throw error;
 			} finally {
 				activeDynamicToolCalls.delete(toolCall);
@@ -752,76 +794,13 @@ async function runCodexAppServerSideQuestion(params, options) {
 				releaseSandboxEnvironment,
 				() => releaseCodexAppServerClientLease(clientLease),
 				() => nativeHookRelay?.unregister(),
-				() => runAgentCleanupStep({
-					runId: sideRunParams.runId,
-					sessionId: sideRunParams.sessionId,
-					step: "codex-side-native-hook-relay-release",
-					log: embeddedAgentLog,
-					cleanup: async () => {
-						await nativeHookRelay?.drain();
-					}
+				() => runCodexCleanupStep(sideRunParams, "codex-side-native-hook-relay-release", async () => {
+					await nativeHookRelay?.drain();
 				})
 			]
 		});
 	}
 }
-async function createCodexSideToolBridge(input) {
-	const { params } = input;
-	const sandboxSessionKey = params.sandboxSessionKey?.trim() || params.sessionKey?.trim() || params.sessionId || input.sessionAgentId;
-	const sandbox = params.sandbox !== void 0 ? params.sandbox : await resolveSandboxContext({
-		config: params.config,
-		sessionKey: sandboxSessionKey,
-		workspaceDir: input.cwd
-	});
-	let webSearchAllowed = false;
-	const tools = await buildDynamicTools({
-		params,
-		resolvedWorkspace: input.resolvedWorkspace,
-		effectiveWorkspace: input.cwd,
-		sandboxSessionKey,
-		sandbox,
-		nativeToolSurfaceEnabled: input.nativeToolSurfaceEnabled,
-		nativeProviderWebSearchSupport: input.nativeProviderWebSearchSupport,
-		sessionPermissionPolicy: input.sessionPermissionPolicy,
-		runAbortController: input.runAbortController,
-		sessionAgentId: input.sessionAgentId,
-		policyAgentId: input.sessionAgentId,
-		pluginConfig: input.pluginConfig,
-		onYieldDetected: () => {},
-		onWebSearchPolicyResolved: (allowed) => {
-			webSearchAllowed = allowed;
-		}
-	});
-	const requestedWebSearchPlan = resolveCodexWebSearchPlan({
-		config: params.config,
-		nativeToolSurfaceEnabled: input.nativeToolSurfaceEnabled,
-		nativeProviderWebSearchSupport: input.nativeProviderWebSearchSupport,
-		webSearchAllowed
-	});
-	const webSearchPlan = requestedWebSearchPlan.kind === "managed" ? resolveCodexWebSearchPlan({
-		config: params.config,
-		webSearchAllowed: false
-	}) : requestedWebSearchPlan;
-	const exposedTools = tools.filter((tool) => tool.name !== "web_search" && tool.name !== "computer");
-	return {
-		toolBridge: createCodexDynamicToolBridge({
-			tools: exposedTools,
-			signal: input.runAbortController.signal,
-			loading: resolveCodexDynamicToolsLoading(input.pluginConfig),
-			hookContext: {
-				agentId: input.sessionAgentId,
-				config: params.config,
-				contextWindowTokens: params.model.contextWindow,
-				sessionId: params.sessionId,
-				sessionKey: params.sessionKey,
-				runId: params.runId,
-				currentChannelProvider: resolveCodexMessageToolProvider(params),
-				...buildAgentHookContextChannelFields(params)
-			}
-		}),
-		webSearchPlan
-	};
-}
 async function forkCodexSideThread(client, params, options) {
 	try {
 		return await client.request("thread/fork", params, options);

package/dist/.setup/{source-1cabQi3x.mjs → source-Ce3XIIsU.mjs}

@@ -1,8 +1,8 @@
-import { a as defaultCodexAppInventoryCache, r as buildCodexPluginAppCacheKey } from "./plugin-app-cache-key-BW8rd98k.mjs";
-import { a as withCodexAppServerJsonClient } from "./request-CZkKkN6c.mjs";
-import { a as pluginReadParams, i as marketplaceRef, l as CODEX_PLUGINS_MARKETPLACE_NAME, n as isOpenAiCuratedMarketplaceName } from "./plugin-inventory-Bf0_piTw.mjs";
-import "./config-0Gxk3_eq.mjs";
-import { t as __exportAll } from "./session-binding-sidecars-BrdV95Fg.mjs";
+import { a as defaultCodexAppInventoryCache, r as buildCodexPluginAppCacheKey } from "./plugin-app-cache-key-Bg9DbDI6.mjs";
+import { a as withCodexAppServerJsonClient } from "./request-6piO0U_P.mjs";
+import { a as marketplaceRef, o as pluginReadParams, r as isOpenAiCuratedMarketplaceName, u as CODEX_PLUGINS_MARKETPLACE_NAME } from "./plugin-inventory-CYgdo14P.mjs";
+import "./config-C1YVVLEA.mjs";
+import { t as __exportAll } from "./session-binding-sidecars-DD-enC8w.mjs";
 import { asNonArrayRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import path from "node:path";
 import os from "node:os";
@@ -88,19 +88,16 @@ async function discoverCodexMemoryFile(candidate) {
 }
 async function discoverCodexMemorySources(codexHome) {
 	const memoriesDir = path.join(codexHome, "memories");
-	return (await Promise.all([{
+	const candidates = [{
 		id: "memory:codex:MEMORY.md",
 		label: "Codex consolidated memory",
-		name: "MEMORY.md"
+		path: path.join(memoriesDir, "MEMORY.md")
 	}, {
 		id: "memory:codex:memory_summary.md",
 		label: "Codex memory summary",
-		name: "memory_summary.md"
-	}].map(async (candidate) => await discoverCodexMemoryFile({
-		id: candidate.id,
-		label: candidate.label,
-		path: path.join(memoriesDir, candidate.name)
-	})))).filter((entry) => entry !== void 0);
+		path: path.join(memoriesDir, "memory_summary.md")
+	}];
+	return (await Promise.all(candidates.map(discoverCodexMemoryFile))).filter((entry) => entry !== void 0);
 }
 //#endregion
 //#region extensions/codex/src/migration/source.ts
@@ -284,23 +281,15 @@ async function withPluginMigrationEligibility(params) {
 	const installedAppsById = new Map(snapshot.installedApps.map((app) => [app.id, app]));
 	for (const { plugin, apps: declaredApps } of pending) {
 		const apps = declaredApps.map((app) => sourcePluginAppFactWithInventory(app, appInfoById.get(app.id), installedAppsById.get(app.id)));
-		const blockCode = migrationBlockCodeForApps(apps);
-		if (!blockCode) {
-			evaluated.push({
-				...plugin,
-				apps,
-				migratable: true
-			});
-			continue;
-		}
-		evaluated.push({
+		const block = appInventoryMigrationBlock(plugin, apps);
+		evaluated.push(block ? {
 			...plugin,
 			migratable: false,
-			migrationBlock: {
-				code: blockCode,
-				apps
-			},
-			message: appInventoryBlockMessage(plugin, apps, blockCode)
+			...block
+		} : {
+			...plugin,
+			apps,
+			migratable: true
 		});
 	}
 	return evaluated;
@@ -330,37 +319,29 @@ async function refreshSourceAppInventory(options) {
 }
 function sourcePluginAppFactWithInventory(app, info, installedApp) {
 	if (!installedApp) return app;
-	if (!info) return installedApp.enabled ? {
-		...app,
-		isAccessible: false,
-		isEnabled: true
-	} : {
-		...app,
-		isEnabled: false
-	};
-	if (!installedApp.enabled) return {
-		...app,
-		isAccessible: true,
-		isEnabled: false
-	};
+	const fact = { ...app };
+	if (info) fact.isAccessible = !installedApp.enabled || installedApp.callable;
+	else if (installedApp.enabled) fact.isAccessible = false;
+	fact.isEnabled = installedApp.enabled;
+	if (info && installedApp.enabled && !installedApp.callable) fact.isCallable = false;
+	return fact;
+}
+function appInventoryMigrationBlock(plugin, apps) {
+	const inaccessible = apps.find((app) => app.isAccessible === false);
+	const disabled = apps.find((app) => app.isEnabled === false);
+	const missing = apps.find((app) => app.isAccessible === void 0 || app.isEnabled === void 0);
+	const blocking = inaccessible ?? disabled ?? missing;
+	if (!blocking) return;
+	const code = inaccessible ? "app_inaccessible" : disabled ? "app_disabled" : "app_missing";
+	const status = inaccessible ? apps.some((app) => app.isCallable === false) ? "not callable" : "inaccessible" : disabled ? "disabled" : "missing";
 	return {
-		...app,
-		isAccessible: installedApp.callable,
-		isEnabled: installedApp.enabled,
-		...!installedApp.callable ? { isCallable: false } : {}
+		migrationBlock: {
+			code,
+			apps
+		},
+		message: `Codex plugin "${plugin.pluginName ?? plugin.name}" owns app "${blocking.name}" but the source app inventory reports it is ${status}; authenticate or enable the app in Codex before migrating it to OpenClaw.`
 	};
 }
-function migrationBlockCodeForApps(apps) {
-	if (apps.some((app) => app.isAccessible === false)) return "app_inaccessible";
-	if (apps.some((app) => app.isEnabled === false)) return "app_disabled";
-	if (apps.some((app) => app.isAccessible === void 0 || app.isEnabled === void 0)) return "app_missing";
-}
-function appInventoryBlockMessage(plugin, apps, code) {
-	const status = code === "app_inaccessible" ? apps.some((app) => app.isCallable === false) ? "not callable" : "inaccessible" : code === "app_disabled" ? "disabled" : "missing";
-	const blocking = apps.find((app) => code === "app_inaccessible" ? app.isAccessible === false : code === "app_disabled" ? app.isEnabled === false : app.isAccessible === void 0 || app.isEnabled === void 0) ?? apps[0];
-	const appLabel = blocking ? ` app "${blocking.name}"` : " an owned app";
-	return `Codex plugin "${plugin.pluginName ?? plugin.name}" owns${appLabel} but the source app inventory reports it is ${status}; authenticate or enable the app in Codex before migrating it to OpenClaw.`;
-}
 function codexPluginMigrationSubscriptionWarning() {
 	return "Codex app-backed plugin migration requires the Codex app-server source account to be logged in with a ChatGPT subscription account. Log in to the Codex app with subscription auth; OpenClaw auth or API-key auth does not satisfy Codex app connector access.";
 }

package/dist/.setup/thread-archive-guard-LKdwQKyr.mjs

@@ -0,0 +1,56 @@
+import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
+import { normalizeBoundedOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/codex/src/app-server/thread-archive-guard.ts
+const DESCENDANT_PAGE_LIMIT = 100;
+const MAX_DESCENDANT_PAGES = 100;
+const MAX_THREAD_ID_LENGTH = 256;
+const MAX_CURSOR_LENGTH = 4096;
+function readNextCursor(value) {
+	if (value === void 0 || value === null) return;
+	if (typeof value !== "string" || !value.trim() || value.length > MAX_CURSOR_LENGTH) throw new Error("Codex app-server returned an invalid descendant-list cursor");
+	return value;
+}
+/**
+* Native archive includes the spawned subtree. Enumerate that same subtree first so an
+* OpenClaw-owned descendant cannot be stopped as an undocumented side effect.
+*/
+async function assertCodexArchiveDescendantsUnowned(params) {
+	const ancestorThreadId = normalizeBoundedOptionalString(params.threadId, MAX_THREAD_ID_LENGTH);
+	if (!ancestorThreadId) throw new Error("cannot verify Codex archive descendants for an invalid thread id");
+	const seenThreadIds = /* @__PURE__ */ new Set([ancestorThreadId]);
+	let pageIndex = 0;
+	for (const archived of [false, true]) {
+		const seenCursors = /* @__PURE__ */ new Set();
+		let cursor;
+		do {
+			if (pageIndex++ >= MAX_DESCENDANT_PAGES) throw new Error("Codex descendant enumeration exceeded its safety limit");
+			const response = await params.listPage({
+				ancestorThreadId,
+				archived,
+				limit: DESCENDANT_PAGE_LIMIT,
+				sortKey: "created_at",
+				sortDirection: "desc",
+				useStateDbOnly: true,
+				...cursor ? { cursor } : {}
+			});
+			if (!isJsonObject(response) || !Array.isArray(response.data)) throw new Error("Codex app-server returned an invalid descendant-list response");
+			if (response.data.length > DESCENDANT_PAGE_LIMIT) throw new Error("Codex app-server exceeded the descendant-list page limit");
+			for (const value of response.data) {
+				if (!isJsonObject(value)) throw new Error("Codex app-server returned an invalid descendant thread");
+				const descendantThreadId = normalizeBoundedOptionalString(value.id, MAX_THREAD_ID_LENGTH);
+				if (!descendantThreadId) throw new Error("Codex app-server returned a descendant without a valid thread id");
+				if (seenThreadIds.has(descendantThreadId)) throw new Error("Codex app-server returned a cyclic descendant thread list");
+				seenThreadIds.add(descendantThreadId);
+				await params.assertDescendantIdle(descendantThreadId);
+				if (await params.bindingStore.hasOtherThreadOwner(descendantThreadId)) throw new Error("cannot archive a Codex thread while a spawned descendant is owned by an OpenClaw session");
+			}
+			cursor = readNextCursor(response.nextCursor);
+			if (cursor) {
+				if (seenCursors.has(cursor)) throw new Error("Codex app-server returned a repeated descendant-list cursor");
+				seenCursors.add(cursor);
+			}
+		} while (cursor);
+	}
+}
+//#endregion
+export { assertCodexArchiveDescendantsUnowned as t };