@openclaw/codex 2026.5.16-beta.1 → 2026.5.16-beta.3

package/dist/{run-attempt-frGYsF9Y.js → run-attempt-B3nk5oT1.js}

@@ -1,28 +1,48 @@
-import { l as resolveCodexPluginsPolicy, o as readCodexPluginConfig, s as resolveCodexAppServerRuntimeOptions, u as withMcpElicitationsApprovalPolicy } from "./config-0rd3LnKg.js";
-import { a as readCodexDynamicToolCallParams, c as readCodexTurn, i as assertCodexTurnStartResponse } from "./protocol-validators-CSY0BFBo.js";
+import { c as resolveCodexAppServerRuntimeOptions, d as withMcpElicitationsApprovalPolicy, i as isCodexAppServerApprovalPolicyAllowedByRequirements, s as readCodexPluginConfig, u as resolveCodexPluginsPolicy } from "./config-3ATInASk.js";
+import { a as readCodexDynamicToolCallParams, c as readCodexTurn, i as assertCodexTurnStartResponse } from "./protocol-validators-BGBspNmF.js";
 import { t as isJsonObject } from "./protocol-C9UWI98H.js";
-import { i as isCodexAppServerConnectionClosedError, r as isCodexAppServerApprovalRequest } from "./client-CoctX13d.js";
-import { n as buildCodexPluginAppCacheKey, r as CODEX_CONTROL_METHODS } from "./request-CKYiRqsN.js";
+import { i as isCodexAppServerConnectionClosedError, r as isCodexAppServerApprovalRequest } from "./client-CA7amCZ8.js";
+import { n as buildCodexPluginAppCacheKey, r as CODEX_CONTROL_METHODS } from "./request-Czoa60Nt.js";
 import { d as resolveCodexUsageLimitResetAtMs, f as shouldRefreshCodexRateLimitsForUsageLimitMessage, r as formatCodexDisplayText, u as formatCodexUsageLimitErrorMessage } from "./command-formatters-BRW7_Nu7.js";
-import { c as resolveCodexAppServerAuthAccountCacheKey, d as resolveCodexAppServerEnvApiKeyCacheKey, l as resolveCodexAppServerAuthProfileId, n as clearSharedCodexAppServerClientIfCurrent, s as refreshCodexAppServerAuthTokens, u as resolveCodexAppServerAuthProfileIdForAgent } from "./shared-client-BwUqd3lh.js";
-import { i as readCodexAppServerBinding, t as clearCodexAppServerBinding } from "./session-binding-CMTXuyoz.js";
-import { a as defaultCodexAppInventoryCache } from "./plugin-activation-aQOmRQwA.js";
-import { _ as resolveCodexContextEngineProjectionReserveTokens, b as normalizeCodexDynamicToolName, d as buildCodexPluginThreadConfig, f as buildCodexPluginThreadConfigInputFingerprint, g as resolveCodexContextEngineProjectionMaxChars, h as projectContextEngineAssemblyForCodex, m as shouldBuildCodexPluginThreadConfig, o as buildTurnStartParams, p as mergeCodexThreadConfigs, r as buildDeveloperInstructions, s as codexDynamicToolsFingerprint, t as areCodexDynamicToolFingerprintsCompatible, u as startOrResumeThread, v as createCodexDynamicToolBridge, y as filterCodexDynamicTools } from "./thread-lifecycle-BzY-GLGu.js";
-import { t as defaultCodexAppServerClientFactory } from "./client-factory-Be6RD28K.js";
-import { n as handleCodexAppServerElicitationRequest, r as handleCodexAppServerApprovalRequest, t as filterToolsForVisionInputs } from "./vision-tools-CyhFwJIY.js";
-import { t as ensureCodexComputerUse } from "./computer-use-DsJxRRtm.js";
+import { c as resolveCodexAppServerAuthAccountCacheKey, d as resolveCodexAppServerEnvApiKeyCacheKey, l as resolveCodexAppServerAuthProfileId, n as clearSharedCodexAppServerClientIfCurrent, s as refreshCodexAppServerAuthTokens, u as resolveCodexAppServerAuthProfileIdForAgent } from "./shared-client-CnbrvEfV.js";
+import { i as readCodexAppServerBinding, t as clearCodexAppServerBinding } from "./session-binding-DbdVqMzW.js";
+import { a as defaultCodexAppInventoryCache } from "./plugin-activation-BDU4e-NA.js";
+import { S as normalizeCodexDynamicToolName, _ as projectContextEngineAssemblyForCodex, b as createCodexDynamicToolBridge, c as codexDynamicToolsFingerprint, f as startOrResumeThread, g as shouldBuildCodexPluginThreadConfig, h as mergeCodexThreadConfigs, i as buildDeveloperInstructions, l as isContextEngineBindingCompatible, m as buildCodexPluginThreadConfigInputFingerprint, p as buildCodexPluginThreadConfig, r as buildContextEngineBinding, s as buildTurnStartParams, t as areCodexDynamicToolFingerprintsCompatible, v as resolveCodexContextEngineProjectionMaxChars, x as filterCodexDynamicTools, y as resolveCodexContextEngineProjectionReserveTokens } from "./thread-lifecycle-D2sxRPdz.js";
+import { t as defaultCodexAppServerClientFactory } from "./client-factory-DwzPofwS.js";
+import { n as handleCodexAppServerElicitationRequest, r as handleCodexAppServerApprovalRequest, t as filterToolsForVisionInputs } from "./vision-tools-Cm_YicZb.js";
+import { t as ensureCodexComputerUse } from "./computer-use-BX02ojP4.js";
 import { n as rememberCodexRateLimits, t as readRecentCodexRateLimits } from "./rate-limit-cache-dvhq-4pi.js";
 import { createHash } from "node:crypto";
 import nodeFs from "node:fs";
-import { TOOL_PROGRESS_OUTPUT_MAX_CHARS, acquireSessionWriteLock, appendSessionTranscriptMessage, assembleHarnessContextEngine, bootstrapHarnessContextEngine, buildEmbeddedAttemptToolRunContext, buildHarnessContextEngineRuntimeContext, buildHarnessContextEngineRuntimeContextFromUsage, classifyAgentHarnessTerminalOutcome, clearActiveEmbeddedRun, embeddedAgentLog, emitAgentEvent, emitSessionTranscriptUpdate, finalizeHarnessContextEngineTurn, formatErrorMessage, formatToolAggregate, formatToolProgressOutput, inferToolMetaFromArgs, isActiveHarnessContextEngine, isSubagentSessionKey, loadCodexBundleMcpThreadConfig, normalizeAgentRuntimeTools, normalizeUsage, registerNativeHookRelay, resolveAgentHarnessBeforePromptBuildResult, resolveAttemptSpawnWorkspaceDir, resolveBootstrapContextForRun, resolveContextEngineOwnerPluginId, resolveModelAuthMode, resolveSandboxContext, resolveSessionAgentIds, resolveSessionWriteLockAcquireTimeoutMs, resolveUserPath, runAgentCleanupStep, runAgentHarnessAfterCompactionHook, runAgentHarnessAfterToolCallHook, runAgentHarnessAgentEndHook, runAgentHarnessBeforeCompactionHook, runAgentHarnessBeforeMessageWriteHook, runAgentHarnessLlmInputHook, runAgentHarnessLlmOutputHook, runHarnessContextEngineMaintenance, setActiveEmbeddedRun, supportsModelTools } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { TOOL_PROGRESS_OUTPUT_MAX_CHARS, acquireSessionWriteLock, appendSessionTranscriptMessage, assembleHarnessContextEngine, bootstrapHarnessContextEngine, buildEmbeddedAttemptToolRunContext, buildHarnessContextEngineRuntimeContext, buildHarnessContextEngineRuntimeContextFromUsage, classifyAgentHarnessTerminalOutcome, clearActiveEmbeddedRun, embeddedAgentLog, emitAgentEvent, emitSessionTranscriptUpdate, finalizeHarnessContextEngineTurn, formatErrorMessage, formatToolAggregate, formatToolProgressOutput, hasBeforeToolCallPolicy, inferToolMetaFromArgs, isActiveHarnessContextEngine, isSubagentSessionKey, loadCodexBundleMcpThreadConfig, normalizeAgentRuntimeTools, normalizeUsage, registerNativeHookRelay, resolveAgentHarnessBeforePromptBuildResult, resolveAttemptSpawnWorkspaceDir, resolveBootstrapContextForRun, resolveContextEngineOwnerPluginId, resolveModelAuthMode, resolveSandboxContext, resolveSessionAgentIds, resolveSessionWriteLockAcquireTimeoutMs, resolveUserPath, runAgentCleanupStep, runAgentHarnessAfterCompactionHook, runAgentHarnessAfterToolCallHook, runAgentHarnessAgentEndHook, runAgentHarnessBeforeCompactionHook, runAgentHarnessBeforeMessageWriteHook, runAgentHarnessLlmInputHook, runAgentHarnessLlmOutputHook, runHarnessContextEngineMaintenance, setActiveEmbeddedRun, supportsModelTools } from "openclaw/plugin-sdk/agent-harness-runtime";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { markAuthProfileBlockedUntil, resolveAgentDir as resolveAgentDir$1 } from "openclaw/plugin-sdk/agent-runtime";
 import { appendRegularFile, pathExists } from "openclaw/plugin-sdk/security-runtime";
+import { redactSensitiveFieldValue, redactToolPayloadText } from "openclaw/plugin-sdk/logging-core";
 import { emitTrustedDiagnosticEvent } from "openclaw/plugin-sdk/diagnostic-runtime";
 import { createRunningTaskRun, finalizeTaskRunByRunId, recordTaskRunProgressByRunId } from "openclaw/plugin-sdk/codex-native-task-runtime";
 import { buildSessionContext, migrateSessionEntries, parseSessionEntries } from "@earendil-works/pi-coding-agent";
-import { redactSensitiveFieldValue, redactToolPayloadText } from "openclaw/plugin-sdk/logging-core";
+//#region extensions/codex/src/app-server/local-runtime-attribution.ts
+const OPENAI_PROVIDER_ID = "openai";
+const OPENAI_RESPONSES_API = "openai-responses";
+const OPENAI_CODEX_PROVIDER_ID = "openai-codex";
+const OPENAI_CODEX_RESPONSES_API = "openai-codex-responses";
+function normalizeRuntimeId(value) {
+	return value?.trim().toLowerCase() ?? "";
+}
+function resolveCodexLocalRuntimeAttribution(params) {
+	const authProfileProvider = normalizeRuntimeId(params.runtimePlan?.auth?.authProfileProviderForAuth);
+	if (normalizeRuntimeId(params.runtimePlan?.observability.harnessId) === "codex" && authProfileProvider !== OPENAI_PROVIDER_ID && normalizeRuntimeId(params.model.provider) === OPENAI_PROVIDER_ID && normalizeRuntimeId(params.model.api) === OPENAI_RESPONSES_API) return {
+		provider: OPENAI_CODEX_PROVIDER_ID,
+		api: OPENAI_CODEX_RESPONSES_API
+	};
+	return {
+		provider: params.provider,
+		api: params.model.api
+	};
+}
+//#endregion
 //#region extensions/codex/src/app-server/native-subagent-task-mirror.ts
 const CODEX_NATIVE_SUBAGENT_RUNTIME = "subagent";
 const CODEX_NATIVE_SUBAGENT_TASK_KIND = "codex-native";
@@ -860,6 +880,7 @@ var CodexAppServerEventProjector = class {
 				data: {
 					phase: "end",
 					backend: "codex-app-server",
+					completed: true,
 					threadId: this.threadId,
 					turnId: this.turnId,
 					itemId
@@ -1017,8 +1038,14 @@ var CodexAppServerEventProjector = class {
 		const text = extractRawAssistantText(item);
 		if (!text) return;
 		const itemId = readString$2(item, "id") ?? `raw-assistant-${this.assistantItemOrder.length + 1}`;
+		const phase = readString$2(item, "phase");
+		if (phase) this.assistantPhaseByItem.set(itemId, phase);
 		this.rememberAssistantItem(itemId);
 		this.assistantTextByItem.set(itemId, text);
+		if (phase === "commentary") this.emitCommentaryProgress({
+			itemId,
+			text
+		});
 	}
 	recordNativeGeneratedMedia(item) {
 		if (item?.type !== "imageGeneration") return;
@@ -1327,6 +1354,7 @@ var CodexAppServerEventProjector = class {
 		return await readCodexMirroredSessionHistoryMessages(this.params.sessionFile) ?? [];
 	}
 	createAssistantMessage(text) {
+		const attribution = resolveCodexLocalRuntimeAttribution(this.params);
 		const usage = this.tokenUsage ? {
 			input: this.tokenUsage.input ?? 0,
 			output: this.tokenUsage.output ?? 0,
@@ -1341,8 +1369,8 @@ var CodexAppServerEventProjector = class {
 				type: "text",
 				text
 			}],
-			api: this.params.model.api ?? "openai-codex-responses",
-			provider: this.params.provider,
+			api: attribution.api ?? "openai-codex-responses",
+			provider: attribution.provider,
 			model: this.params.modelId,
 			usage,
 			stopReason: this.aborted ? "aborted" : this.promptError ? "error" : "stop",
@@ -1351,14 +1379,15 @@ var CodexAppServerEventProjector = class {
 		};
 	}
 	createAssistantMirrorMessage(title, text) {
+		const attribution = resolveCodexLocalRuntimeAttribution(this.params);
 		return {
 			role: "assistant",
 			content: [{
 				type: "text",
 				text: `${title}:\n${text}`
 			}],
-			api: this.params.model.api ?? "openai-codex-responses",
-			provider: this.params.provider,
+			api: attribution.api ?? "openai-codex-responses",
+			provider: attribution.provider,
 			model: this.params.modelId,
 			usage: ZERO_USAGE,
 			stopReason: "stop",
@@ -1367,6 +1396,7 @@ var CodexAppServerEventProjector = class {
 	}
 	createToolCallMessage(params) {
 		const args = normalizeToolTranscriptArguments(params.arguments);
+		const attribution = resolveCodexLocalRuntimeAttribution(this.params);
 		return {
 			role: "assistant",
 			content: [{
@@ -1376,8 +1406,8 @@ var CodexAppServerEventProjector = class {
 				arguments: args,
 				input: args
 			}],
-			api: this.params.model.api ?? "openai-codex-responses",
-			provider: this.params.provider,
+			api: attribution.api ?? "openai-codex-responses",
+			provider: attribution.provider,
 			model: this.params.modelId,
 			usage: ZERO_USAGE,
 			stopReason: "toolUse",
@@ -1732,22 +1762,40 @@ const CODEX_HOOK_EVENT_BY_NATIVE_EVENT = {
 	permission_request: "PermissionRequest",
 	before_agent_finalize: "Stop"
 };
+const CODEX_HOOK_KEY_LABEL_BY_NATIVE_EVENT = {
+	pre_tool_use: "pre_tool_use",
+	post_tool_use: "post_tool_use",
+	permission_request: "permission_request",
+	before_agent_finalize: "stop"
+};
+const CODEX_SESSION_FLAGS_HOOK_SOURCE_PATHS = ["/<session-flags>/config.toml", "<session-flags>/config.toml"];
 function buildCodexNativeHookRelayConfig(params) {
 	const events = params.events?.length ? params.events : CODEX_NATIVE_HOOK_RELAY_EVENTS;
 	const config = { "features.hooks": true };
+	const hookState = {};
 	for (const event of events) {
 		const codexEvent = CODEX_HOOK_EVENT_BY_NATIVE_EVENT[event];
-		config[`hooks.${codexEvent}`] = [{
-			matcher: null,
-			hooks: [{
-				type: "command",
-				command: params.relay.commandForEvent(event),
-				timeout: normalizeHookTimeoutSec(params.hookTimeoutSec),
-				async: false,
+		const command = params.relay.commandForEvent(event);
+		const timeout = normalizeHookTimeoutSec(params.hookTimeoutSec);
+		config[`hooks.${codexEvent}`] = [{ hooks: [{
+			type: "command",
+			command,
+			timeout,
+			async: false,
+			statusMessage: "OpenClaw native hook relay"
+		}] }];
+		const state = {
+			enabled: true,
+			trusted_hash: codexCommandHookTrustedHash({
+				event,
+				command,
+				timeout,
 				statusMessage: "OpenClaw native hook relay"
-			}]
-		}];
+			})
+		};
+		for (const sourcePath of CODEX_SESSION_FLAGS_HOOK_SOURCE_PATHS) hookState[`${sourcePath}:${CODEX_HOOK_KEY_LABEL_BY_NATIVE_EVENT[event]}:0:0`] = state;
 	}
+	config["hooks.state"] = hookState;
 	return config;
 }
 function buildCodexNativeHookRelayDisabledConfig() {
@@ -1762,6 +1810,26 @@ function buildCodexNativeHookRelayDisabledConfig() {
 function normalizeHookTimeoutSec(value) {
 	return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.ceil(value) : 5;
 }
+function codexCommandHookTrustedHash(params) {
+	const identity = {
+		event_name: CODEX_HOOK_KEY_LABEL_BY_NATIVE_EVENT[params.event],
+		hooks: [{
+			async: false,
+			command: params.command,
+			statusMessage: params.statusMessage,
+			timeout: params.timeout,
+			type: "command"
+		}]
+	};
+	return `sha256:${createHash("sha256").update(JSON.stringify(sortJsonValue(identity))).digest("hex")}`;
+}
+function sortJsonValue(value) {
+	if (!value || typeof value !== "object") return value;
+	if (Array.isArray(value)) return value.map(sortJsonValue);
+	const sorted = {};
+	for (const key of Object.keys(value).toSorted()) sorted[key] = sortJsonValue(value[key]);
+	return sorted;
+}
 //#endregion
 //#region extensions/codex/src/app-server/trajectory.ts
 const SENSITIVE_FIELD_RE = /(?:authorization|cookie|credential|key|password|passwd|secret|token)/iu;
@@ -1844,6 +1912,7 @@ function createCodexTrajectoryRecorder(params) {
 	});
 	let queue = Promise.resolve();
 	let seq = 0;
+	const attribution = resolveCodexLocalRuntimeAttribution(params.attempt);
 	return {
 		filePath,
 		recordEvent: (type, data) => {
@@ -1860,9 +1929,9 @@ function createCodexTrajectoryRecorder(params) {
 				sessionKey: params.attempt.sessionKey,
 				runId: params.attempt.runId,
 				workspaceDir: params.cwd,
-				provider: params.attempt.provider,
+				provider: attribution.provider,
 				modelId: params.attempt.modelId,
-				modelApi: params.attempt.model.api,
+				modelApi: attribution.api,
 				data: data ? sanitizeValue(data) : void 0
 			});
 			if (!line) return;
@@ -2148,6 +2217,7 @@ const CODEX_TURN_ASSISTANT_COMPLETION_IDLE_TIMEOUT_MS = 1e4;
 const CODEX_TURN_TERMINAL_IDLE_TIMEOUT_MS = 30 * 6e4;
 const CODEX_NATIVE_HOOK_RELAY_MIN_TTL_MS = 30 * 6e4;
 const CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS = 5 * 6e4;
+const CODEX_NATIVE_HOOK_RELAY_RENEW_INTERVAL_MS = 6e4;
 const CODEX_STEER_ALL_DEBOUNCE_MS = 500;
 const LOG_FIELD_MAX_LENGTH = 160;
 const CODEX_NATIVE_PROJECT_DOC_BASENAMES = new Set(["agents.md"]);
@@ -2315,6 +2385,22 @@ function restrictCodexAppServerSandboxForOpenClawSandbox(appServer, sandbox) {
 		sandbox: "workspace-write"
 	};
 }
+function resolveCodexAppServerForOpenClawToolPolicy(params) {
+	if (!params.shouldPromote || !params.canUseUntrustedApprovalPolicy || params.appServer.approvalPolicy !== "never") return params.appServer;
+	const explicitMode = params.pluginConfig.appServer?.mode !== void 0 || isCodexAppServerPolicyMode(params.env.OPENCLAW_CODEX_APP_SERVER_MODE);
+	const explicitApprovalPolicy = params.pluginConfig.appServer?.approvalPolicy !== void 0 || isCodexAppServerApprovalPolicy(params.env.OPENCLAW_CODEX_APP_SERVER_APPROVAL_POLICY);
+	if (explicitMode || explicitApprovalPolicy) return params.appServer;
+	return {
+		...params.appServer,
+		approvalPolicy: "untrusted"
+	};
+}
+function isCodexAppServerPolicyMode(value) {
+	return value === "guardian" || value === "yolo";
+}
+function isCodexAppServerApprovalPolicy(value) {
+	return value === "never" || value === "on-request" || value === "on-failure" || value === "untrusted";
+}
 async function runCodexAppServerAttempt(params, options = {}) {
 	const attemptStartedAt = Date.now();
 	const attemptClientFactory = options.clientFactory ?? defaultCodexAppServerClientFactory;
@@ -2330,7 +2416,13 @@ async function runCodexAppServerAttempt(params, options = {}) {
 	});
 	const effectiveWorkspace = sandbox?.enabled ? sandbox.workspaceAccess === "rw" ? resolvedWorkspace : sandbox.workspaceDir : resolvedWorkspace;
 	await fs.mkdir(effectiveWorkspace, { recursive: true });
-	const appServer = restrictCodexAppServerSandboxForOpenClawSandbox(configuredAppServer, sandbox);
+	const appServer = resolveCodexAppServerForOpenClawToolPolicy({
+		appServer: restrictCodexAppServerSandboxForOpenClawSandbox(configuredAppServer, sandbox),
+		pluginConfig,
+		env: process.env,
+		shouldPromote: hasBeforeToolCallPolicy(),
+		canUseUntrustedApprovalPolicy: configuredAppServer.start.transport !== "stdio" || isCodexAppServerApprovalPolicyAllowedByRequirements("untrusted")
+	});
 	let pluginAppServer = appServer;
 	const nativeHookRelayEvents = resolveCodexNativeHookRelayEvents({
 		configuredEvents: options.nativeHookRelay?.events,
@@ -2364,6 +2456,17 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		sessionKey: sandboxSessionKey,
 		...startupAuthProfileId ? { authProfileId: startupAuthProfileId } : {}
 	};
+	let activeSessionId = params.sessionId;
+	let activeSessionFile = params.sessionFile;
+	const buildActiveRunAttemptParams = () => ({
+		...runtimeParams,
+		sessionId: activeSessionId,
+		sessionFile: activeSessionFile
+	});
+	const adoptContextEngineCompactionTranscript = (compactResult) => {
+		if (compactResult.result?.sessionId) activeSessionId = compactResult.result.sessionId;
+		if (compactResult.result?.sessionFile) activeSessionFile = compactResult.result.sessionFile;
+	};
 	const startupAuthAccountCacheKey = await resolveCodexAppServerAuthAccountCacheKey({
 		authProfileId: startupAuthProfileId,
 		authProfileStore: params.authProfileStore,
@@ -2406,8 +2509,8 @@ async function runCodexAppServerAttempt(params, options = {}) {
 			runId: params.runId
 		}
 	});
-	const hadSessionFile = await pathExists(params.sessionFile);
-	let historyMessages = await readMirroredSessionHistoryMessages(params.sessionFile) ?? [];
+	const hadSessionFile = await pathExists(activeSessionFile);
+	let historyMessages = await readMirroredSessionHistoryMessages(activeSessionFile) ?? [];
 	const hookContextWindowFields = {
 		...params.contextWindowInfo?.tokens ? { contextTokenBudget: params.contextWindowInfo.tokens } : params.contextTokenBudget ? { contextTokenBudget: params.contextTokenBudget } : {},
 		...params.contextWindowInfo?.source ? { contextWindowSource: params.contextWindowInfo.source } : {},
@@ -2424,27 +2527,28 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		channelId: params.messageChannel ?? params.messageProvider ?? void 0,
 		...hookContextWindowFields
 	};
+	const activeContextEnginePluginId = activeContextEngine ? resolveContextEngineOwnerPluginId(activeContextEngine) : void 0;
+	const buildActiveContextEngineRuntimeContext = () => buildHarnessContextEngineRuntimeContext({
+		attempt: buildActiveRunAttemptParams(),
+		workspaceDir: effectiveWorkspace,
+		agentDir,
+		activeAgentId: sessionAgentId,
+		contextEnginePluginId: activeContextEnginePluginId,
+		tokenBudget: params.contextTokenBudget
+	});
 	if (activeContextEngine) {
-		const activeContextEnginePluginId = resolveContextEngineOwnerPluginId(activeContextEngine);
 		await bootstrapHarnessContextEngine({
 			hadSessionFile,
 			contextEngine: activeContextEngine,
-			sessionId: params.sessionId,
+			sessionId: activeSessionId,
 			sessionKey: sandboxSessionKey,
-			sessionFile: params.sessionFile,
-			runtimeContext: buildHarnessContextEngineRuntimeContext({
-				attempt: runtimeParams,
-				workspaceDir: effectiveWorkspace,
-				agentDir,
-				activeAgentId: sessionAgentId,
-				contextEnginePluginId: activeContextEnginePluginId,
-				tokenBudget: params.contextTokenBudget
-			}),
+			sessionFile: activeSessionFile,
+			runtimeContext: buildActiveContextEngineRuntimeContext(),
 			runMaintenance: runHarnessContextEngineMaintenance,
 			config: params.config,
 			warn: (message) => embeddedAgentLog.warn(message)
 		});
-		historyMessages = await readMirroredSessionHistoryMessages(params.sessionFile) ?? historyMessages;
+		historyMessages = await readMirroredSessionHistoryMessages(activeSessionFile) ?? historyMessages;
 	}
 	const baseDeveloperInstructions = buildDeveloperInstructions(params);
 	const workspaceBootstrapContext = await buildCodexWorkspaceBootstrapContext({
@@ -2458,10 +2562,18 @@ async function runCodexAppServerAttempt(params, options = {}) {
 	let promptText = params.prompt;
 	let developerInstructions = joinPresentSections(baseDeveloperInstructions, workspaceBootstrapInstructions);
 	let prePromptMessageCount = historyMessages.length;
-	if (activeContextEngine) try {
+	let contextEngineProjection;
+	const resetCodexPromptInputs = () => {
+		promptText = params.prompt;
+		developerInstructions = joinPresentSections(baseDeveloperInstructions, workspaceBootstrapInstructions);
+		prePromptMessageCount = historyMessages.length;
+		contextEngineProjection = void 0;
+	};
+	const applyActiveContextEngineProjection = async (decisionStartupBinding) => {
+		if (!activeContextEngine) return;
 		const assembled = await assembleHarnessContextEngine({
 			contextEngine: activeContextEngine,
-			sessionId: params.sessionId,
+			sessionId: activeSessionId,
 			sessionKey: sandboxSessionKey,
 			messages: historyMessages,
 			tokenBudget: params.contextTokenBudget,
@@ -2471,6 +2583,7 @@ async function runCodexAppServerAttempt(params, options = {}) {
 			prompt: params.prompt
 		});
 		if (!assembled) throw new Error("context engine assemble returned no result");
+		contextEngineProjection = readContextEngineThreadBootstrapProjection(assembled.contextProjection);
 		const projection = projectContextEngineAssemblyForCodex({
 			assembledMessages: assembled.messages,
 			originalHistoryMessages: historyMessages,
@@ -2479,11 +2592,41 @@ async function runCodexAppServerAttempt(params, options = {}) {
 			maxRenderedContextChars: resolveCodexContextEngineProjectionMaxChars({
 				contextTokenBudget: params.contextTokenBudget,
 				reserveTokens: resolveCodexContextEngineProjectionReserveTokens({ config: params.config })
-			})
+			}),
+			toolPayloadMode: contextEngineProjection ? "preserve" : "elide"
 		});
-		promptText = projection.promptText;
+		const projectionDecision = contextEngineProjection ? resolveContextEngineBootstrapProjectionDecision({
+			startupBinding: decisionStartupBinding,
+			expectedBinding: buildContextEngineBinding(buildActiveRunAttemptParams(), contextEngineProjection),
+			projection: contextEngineProjection,
+			dynamicToolsFingerprint: codexDynamicToolsFingerprint(toolBridge.specs)
+		}) : {
+			project: true,
+			reason: "per-turn-projection"
+		};
+		embeddedAgentLog.info("codex app-server context-engine projection decision", {
+			sessionId: params.sessionId,
+			sessionKey: sandboxSessionKey,
+			engineId: activeContextEngine.info.id,
+			mode: contextEngineProjection?.mode ?? assembled.contextProjection?.mode ?? "per_turn",
+			epoch: contextEngineProjection?.epoch,
+			fingerprint: contextEngineProjection?.fingerprint,
+			previousThreadId: decisionStartupBinding?.threadId,
+			previousEpoch: decisionStartupBinding?.contextEngine?.projection?.epoch,
+			previousFingerprint: decisionStartupBinding?.contextEngine?.projection?.fingerprint,
+			projected: projectionDecision.project,
+			reason: projectionDecision.reason,
+			assembledMessages: assembled.messages.length,
+			originalHistoryMessages: historyMessages.length,
+			projectedPromptChars: projection.promptText.length,
+			developerInstructionAdditionChars: projection.developerInstructionAddition?.length ?? 0
+		});
+		promptText = projectionDecision.project ? projection.promptText : params.prompt;
 		developerInstructions = joinPresentSections(baseDeveloperInstructions, workspaceBootstrapInstructions, projection.developerInstructionAddition);
 		prePromptMessageCount = projection.prePromptMessageCount;
+	};
+	if (activeContextEngine) try {
+		await applyActiveContextEngineProjection(startupBinding);
 	} catch (assembleErr) {
 		embeddedAgentLog.warn("context engine assemble failed; using Codex baseline prompt", { error: formatErrorMessage(assembleErr) });
 	}
@@ -2500,13 +2643,13 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		promptText = projection.promptText;
 		prePromptMessageCount = projection.prePromptMessageCount;
 	}
-	promptText = prependCurrentTurnContext(promptText, params.currentTurnContext);
-	const promptBuild = await resolveAgentHarnessBeforePromptBuildResult({
-		prompt: promptText,
+	const buildPromptFromCurrentInputs = () => resolveAgentHarnessBeforePromptBuildResult({
+		prompt: prependCurrentTurnContext(promptText, params.currentTurnContext),
 		developerInstructions,
 		messages: historyMessages,
 		ctx: hookContext
 	});
+	let promptBuild = await buildPromptFromCurrentInputs();
 	const systemPromptReport = buildCodexSystemPromptReport({
 		attempt: params,
 		sessionKey: sandboxSessionKey,
@@ -2588,9 +2731,9 @@ async function runCodexAppServerAttempt(params, options = {}) {
 						timeoutMs: appServer.requestTimeoutMs,
 						signal: runAbortController.signal
 					});
-					const threadLifecycleParams = {
+					const buildThreadLifecycleParams = () => ({
 						client: startupClient,
-						params: runtimeParams,
+						params: buildActiveRunAttemptParams(),
 						agentId: sessionAgentId,
 						cwd: effectiveWorkspace,
 						dynamicTools: toolBridge.specs,
@@ -2599,6 +2742,7 @@ async function runCodexAppServerAttempt(params, options = {}) {
 						config: threadConfig,
 						mcpServersFingerprint: bundleMcpThreadConfig.fingerprint,
 						mcpServersFingerprintEvaluated: bundleMcpThreadConfig.evaluated,
+						contextEngineProjection,
 						pluginThreadConfig: pluginThreadConfigEnabled ? {
 							enabled: true,
 							inputFingerprint: pluginThreadConfigInputFingerprint,
@@ -2613,11 +2757,11 @@ async function runCodexAppServerAttempt(params, options = {}) {
 								appCacheKey: pluginAppCacheKey
 							})
 						} : void 0
-					};
-					restartContextEngineCodexThread = () => startOrResumeThread(threadLifecycleParams);
+					});
+					restartContextEngineCodexThread = () => startOrResumeThread(buildThreadLifecycleParams());
 					return {
 						client: startupClient,
-						thread: await startOrResumeThread(threadLifecycleParams)
+						thread: await startOrResumeThread(buildThreadLifecycleParams())
 					};
 				};
 				for (let attempt = 1; attempt <= CODEX_APP_SERVER_STARTUP_CONNECTION_CLOSE_MAX_ATTEMPTS; attempt += 1) try {
@@ -2702,14 +2846,22 @@ async function runCodexAppServerAttempt(params, options = {}) {
 	let turnAssistantCompletionIdleWatchArmed = false;
 	let turnAssistantCompletionLastActivityAt = Date.now();
 	let turnAssistantCompletionLastActivityDetails;
+	const turnAttemptIdleTimeoutMs = Math.max(100, Math.floor(params.timeoutMs));
+	let turnAttemptIdleTimer;
+	let turnAttemptIdleWatchArmed = false;
 	let turnTerminalIdleTimer;
 	let turnTerminalIdleWatchArmed = false;
 	let turnCompletionLastActivityAt = Date.now();
 	let turnCompletionLastActivityReason = "startup";
 	let turnCompletionLastActivityDetails;
+	let turnAttemptLastProgressAt = Date.now();
+	let turnAttemptLastProgressReason = "startup";
+	let turnAttemptLastProgressDetails;
+	let nativeHookRelayLastRenewedAt = 0;
 	let activeAppServerTurnRequests = 0;
 	const activeOpenClawDynamicToolCallIds = /* @__PURE__ */ new Set();
 	const activeTurnItemIds = /* @__PURE__ */ new Set();
+	let turnCrossedToolHandoff = false;
 	const clearTurnCompletionIdleTimer = () => {
 		if (turnCompletionIdleTimer) {
 			clearTimeout(turnCompletionIdleTimer);
@@ -2728,6 +2880,12 @@ async function runCodexAppServerAttempt(params, options = {}) {
 			turnAssistantCompletionIdleTimer = void 0;
 		}
 	};
+	const clearTurnAttemptIdleTimer = () => {
+		if (turnAttemptIdleTimer) {
+			clearTimeout(turnAttemptIdleTimer);
+			turnAttemptIdleTimer = void 0;
+		}
+	};
 	const fireTurnAssistantCompletionIdleRelease = () => {
 		if (completed || runAbortController.signal.aborted || !turnAssistantCompletionIdleWatchArmed) return;
 		if (activeAppServerTurnRequests > 0 || activeTurnItemIds.size > 0) {
@@ -2764,6 +2922,35 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		completed = true;
 		resolveCompletion?.();
 	};
+	const fireTurnAttemptIdleTimeout = () => {
+		if (completed || runAbortController.signal.aborted || !turnAttemptIdleWatchArmed) return;
+		const idleMs = Math.max(0, Date.now() - turnAttemptLastProgressAt);
+		if (idleMs < turnAttemptIdleTimeoutMs) {
+			scheduleTurnAttemptIdleWatch();
+			return;
+		}
+		timedOut = true;
+		turnCompletionIdleTimedOut = true;
+		turnCompletionIdleTimeoutMessage = "codex app-server turn idle timed out waiting for turn/completed";
+		projector?.markTimedOut();
+		trajectoryRecorder?.recordEvent("turn.progress_idle_timeout", {
+			threadId: thread.threadId,
+			turnId,
+			idleMs,
+			timeoutMs: turnAttemptIdleTimeoutMs,
+			lastActivityReason: turnAttemptLastProgressReason,
+			...turnAttemptLastProgressDetails
+		});
+		embeddedAgentLog.warn("codex app-server turn idle timed out waiting for progress", {
+			threadId: thread.threadId,
+			turnId,
+			idleMs,
+			timeoutMs: turnAttemptIdleTimeoutMs,
+			lastActivityReason: turnAttemptLastProgressReason,
+			...turnAttemptLastProgressDetails
+		});
+		runAbortController.abort("turn_progress_idle_timeout");
+	};
 	const fireTurnCompletionIdleTimeout = () => {
 		if (completed || runAbortController.signal.aborted || !turnCompletionIdleWatchArmed || activeAppServerTurnRequests > 0) return;
 		const idleMs = Math.max(0, Date.now() - turnCompletionLastActivityAt);
@@ -2838,6 +3025,14 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		turnAssistantCompletionIdleTimer = setTimeout(fireTurnAssistantCompletionIdleRelease, delayMs);
 		turnAssistantCompletionIdleTimer.unref?.();
 	}
+	function scheduleTurnAttemptIdleWatch() {
+		clearTurnAttemptIdleTimer();
+		if (completed || runAbortController.signal.aborted || !turnAttemptIdleWatchArmed) return;
+		const elapsedMs = Math.max(0, Date.now() - turnAttemptLastProgressAt);
+		const delayMs = Math.max(1, turnAttemptIdleTimeoutMs - elapsedMs);
+		turnAttemptIdleTimer = setTimeout(fireTurnAttemptIdleTimeout, delayMs);
+		turnAttemptIdleTimer.unref?.();
+	}
 	function scheduleTurnTerminalIdleWatch() {
 		clearTurnTerminalIdleTimer();
 		if (completed || runAbortController.signal.aborted || !turnTerminalIdleWatchArmed || activeAppServerTurnRequests > 0) return;
@@ -2846,10 +3041,41 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		turnTerminalIdleTimer = setTimeout(fireTurnTerminalIdleTimeout, delayMs);
 		turnTerminalIdleTimer.unref?.();
 	}
+	function scheduleTurnProgressWatches() {
+		scheduleTurnAttemptIdleWatch();
+		scheduleTurnCompletionIdleWatch();
+		scheduleTurnTerminalIdleWatch();
+	}
+	const renewNativeHookRelayForTurnProgress = () => {
+		if (!nativeHookRelay || options.nativeHookRelay?.ttlMs !== void 0) return;
+		const now = Date.now();
+		const renewsRecently = now - nativeHookRelayLastRenewedAt < CODEX_NATIVE_HOOK_RELAY_RENEW_INTERVAL_MS;
+		const expiresSoon = now >= nativeHookRelay.expiresAtMs - CODEX_NATIVE_HOOK_RELAY_TTL_GRACE_MS;
+		if (renewsRecently && !expiresSoon) return;
+		nativeHookRelayLastRenewedAt = now;
+		nativeHookRelay.renew(resolveCodexNativeHookRelayTtlMs({
+			explicitTtlMs: void 0,
+			attemptTimeoutMs: turnAttemptIdleTimeoutMs,
+			startupTimeoutMs,
+			turnStartTimeoutMs: params.timeoutMs
+		}));
+	};
 	const touchTurnCompletionActivity = (reason, options) => {
 		turnCompletionLastActivityAt = Date.now();
 		turnCompletionLastActivityReason = reason;
 		turnCompletionLastActivityDetails = options?.details;
+		if (options?.attemptProgress) {
+			turnAttemptLastProgressAt = turnCompletionLastActivityAt;
+			turnAttemptLastProgressReason = reason;
+			turnAttemptLastProgressDetails = options.details;
+			renewNativeHookRelayForTurnProgress();
+			params.onRunProgress?.({
+				reason,
+				provider: params.provider,
+				model: params.modelId,
+				backend: "codex-app-server"
+			});
+		}
 		emitTrustedDiagnosticEvent({
 			type: "run.progress",
 			runId: params.runId,
@@ -2861,8 +3087,7 @@ async function runCodexAppServerAttempt(params, options = {}) {
 			turnCompletionIdleWatchArmed = true;
 			turnCompletionIdleWatchPinnedByTerminalError = false;
 		}
-		scheduleTurnCompletionIdleWatch();
-		scheduleTurnTerminalIdleWatch();
+		scheduleTurnProgressWatches();
 	};
 	const disarmTurnCompletionIdleWatch = () => {
 		turnCompletionIdleWatchArmed = false;
@@ -2946,26 +3171,34 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		const isCurrentTurnNotification = isTurnNotification(notification.params, thread.threadId, turnId);
 		const isTurnCompletion = notification.method === "turn/completed" && isCurrentTurnNotification;
 		if (isCurrentTurnNotification) {
-			touchTurnCompletionActivity(`notification:${notification.method}`, { details: describeNotificationActivity(notification) });
+			touchTurnCompletionActivity(`notification:${notification.method}`, {
+				details: describeNotificationActivity(notification),
+				attemptProgress: true
+			});
 			reportCodexExecutionNotification(notification);
 		}
 		if (isCurrentTurnNotification) updateActiveTurnItemIds(notification, activeTurnItemIds);
 		const unblockedAssistantCompletionRelease = isCurrentTurnNotification && turnAssistantCompletionIdleWatchArmed && notification.method === "item/completed" && activeTurnItemIds.size === 0;
 		const trackedDynamicToolCompletion = isTrackedOpenClawDynamicToolCompletionNotification(notification, activeOpenClawDynamicToolCallIds);
-		const shouldRearmCompletionIdleWatchAfterLastCurrentTurnItem = isCurrentTurnNotification && notification.method === "item/completed" && activeTurnItemIds.size === 0 && !trackedDynamicToolCompletion && !isCompletedAssistantNotification(notification);
+		const rawToolOutputCompletion = isRawToolOutputCompletionNotification(notification);
+		if (isCurrentTurnNotification && (rawToolOutputCompletion || isNativeToolProgressNotification(notification))) turnCrossedToolHandoff = true;
+		const assistantCompletionCanRelease = isAssistantCompletionReleaseNotification(notification, turnCrossedToolHandoff);
+		const shouldRearmCompletionIdleWatchAfterLastCurrentTurnItem = isCurrentTurnNotification && notification.method === "item/completed" && activeTurnItemIds.size === 0 && !trackedDynamicToolCompletion && !assistantCompletionCanRelease;
 		if (isCurrentTurnNotification && notification.method === "error") {
 			if (isRetryableErrorNotification(notification.params)) disarmTurnCompletionIdleWatch();
 			else armTurnCompletionIdleWatch({ pinnedByTerminalError: true });
 			disarmTurnAssistantCompletionIdleWatch();
 		} else if (isTurnCompletion) disarmTurnAssistantCompletionIdleWatch();
-		else if (isCurrentTurnNotification && isCompletedAssistantNotification(notification)) armTurnAssistantCompletionIdleWatch(describeNotificationActivity(notification));
+		else if (isCurrentTurnNotification && assistantCompletionCanRelease) armTurnAssistantCompletionIdleWatch(describeNotificationActivity(notification));
 		else if (unblockedAssistantCompletionRelease) armTurnAssistantCompletionIdleWatch(describeNotificationActivity(notification));
 		else if (shouldRearmCompletionIdleWatchAfterLastCurrentTurnItem) armTurnCompletionIdleWatch();
+		else if (isCurrentTurnNotification && rawToolOutputCompletion) armTurnCompletionIdleWatch();
 		else if (isCurrentTurnNotification && shouldDisarmAssistantCompletionIdleWatch(notification)) disarmTurnAssistantCompletionIdleWatch();
-		if (turnCompletionIdleWatchArmed && !turnCompletionIdleWatchPinnedByTerminalError && notification.method !== "turn/completed" && isCurrentTurnNotification && !trackedDynamicToolCompletion && !shouldRearmCompletionIdleWatchAfterLastCurrentTurnItem) disarmTurnCompletionIdleWatch();
+		if (turnCompletionIdleWatchArmed && !turnCompletionIdleWatchPinnedByTerminalError && notification.method !== "turn/completed" && isCurrentTurnNotification && !trackedDynamicToolCompletion && !rawToolOutputCompletion && !shouldRearmCompletionIdleWatchAfterLastCurrentTurnItem) disarmTurnCompletionIdleWatch();
 		const isTurnAbortMarker = isCurrentTurnNotification && isCodexTurnAbortMarkerNotification(notification, { currentPromptText: promptBuild.prompt });
 		const isTurnTerminal = isTurnCompletion || isTurnAbortMarker;
 		try {
+			await waitForCodexNotificationDispatchTurn();
 			await projector.handleNotification(notification);
 		} catch (error) {
 			embeddedAgentLog.debug("codex app-server projector notification threw", {
@@ -2985,16 +3218,25 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		}
 	};
 	const enqueueNotification = (notification) => {
+		if (!projector || !turnId) {
+			userInputBridge?.handleNotification(notification);
+			pendingNotifications.push(notification);
+			return Promise.resolve();
+		}
 		notificationQueue = notificationQueue.then(() => handleNotification(notification), () => handleNotification(notification));
 		return notificationQueue;
 	};
 	const notificationCleanup = client.addNotificationHandler(enqueueNotification);
 	const requestCleanup = client.addRequestHandler(async (request) => {
-		activeAppServerTurnRequests += 1;
-		clearTurnCompletionIdleTimer();
-		disarmTurnAssistantCompletionIdleWatch();
-		touchTurnCompletionActivity(`request:${request.method}`);
 		let armCompletionWatchOnResponse = false;
+		let requestCountsAsTurnActivity = false;
+		const markCurrentTurnRequestProgress = () => {
+			activeAppServerTurnRequests += 1;
+			clearTurnCompletionIdleTimer();
+			disarmTurnAssistantCompletionIdleWatch();
+			requestCountsAsTurnActivity = true;
+			touchTurnCompletionActivity(`request:${request.method}:start`, { attemptProgress: true });
+		};
 		try {
 			if (request.method === "account/chatgptAuthTokens/refresh") return refreshCodexAppServerAuthTokens({
 				agentDir,
@@ -3003,7 +3245,10 @@ async function runCodexAppServerAttempt(params, options = {}) {
 			});
 			if (!turnId) return;
 			if (request.method === "mcpServer/elicitation/request") {
-				armCompletionWatchOnResponse = true;
+				if (isCurrentThreadOptionalTurnRequestParams(request.params, thread.threadId, turnId)) {
+					armCompletionWatchOnResponse = true;
+					markCurrentTurnRequestProgress();
+				}
 				return handleCodexAppServerElicitationRequest({
 					requestParams: request.params,
 					paramsForRun: params,
@@ -3014,7 +3259,10 @@ async function runCodexAppServerAttempt(params, options = {}) {
 				});
 			}
 			if (request.method === "item/tool/requestUserInput") {
-				armCompletionWatchOnResponse = true;
+				if (isCurrentThreadTurnRequestParams(request.params, thread.threadId, turnId)) {
+					armCompletionWatchOnResponse = true;
+					markCurrentTurnRequestProgress();
+				}
 				return userInputBridge?.handleRequest({
 					id: request.id,
 					params: request.params
@@ -3022,7 +3270,10 @@ async function runCodexAppServerAttempt(params, options = {}) {
 			}
 			if (request.method !== "item/tool/call") {
 				if (isCodexAppServerApprovalRequest(request.method)) {
-					armCompletionWatchOnResponse = true;
+					if (isCurrentApprovalTurnRequestParams(request.params, thread.threadId, turnId)) {
+						armCompletionWatchOnResponse = true;
+						markCurrentTurnRequestProgress();
+					}
 					return handleApprovalRequest({
 						method: request.method,
 						params: request.params,
@@ -3037,6 +3288,8 @@ async function runCodexAppServerAttempt(params, options = {}) {
 			const call = readDynamicToolCallParams(request.params);
 			if (!call || call.threadId !== thread.threadId || call.turnId !== turnId) return;
 			armCompletionWatchOnResponse = true;
+			markCurrentTurnRequestProgress();
+			turnCrossedToolHandoff = true;
 			activeOpenClawDynamicToolCallIds.add(call.callId);
 			trajectoryRecorder?.recordEvent("tool.call", {
 				threadId: call.threadId,
@@ -3113,11 +3366,85 @@ async function runCodexAppServerAttempt(params, options = {}) {
 			});
 			return response;
 		} finally {
-			activeAppServerTurnRequests = Math.max(0, activeAppServerTurnRequests - 1);
-			touchTurnCompletionActivity(`request:${request.method}:response`, { arm: armCompletionWatchOnResponse });
+			if (requestCountsAsTurnActivity) {
+				activeAppServerTurnRequests = Math.max(0, activeAppServerTurnRequests - 1);
+				touchTurnCompletionActivity(`request:${request.method}:response`, {
+					arm: armCompletionWatchOnResponse,
+					attemptProgress: true
+				});
+			} else scheduleTurnProgressWatches();
 		}
 	});
-	const llmInputEvent = {
+	const forceContextEngineCompactionForCodexOverflow = async (error) => {
+		if (!activeContextEngine?.info.ownsCompaction) return false;
+		embeddedAgentLog.warn("codex app-server context-engine turn overflowed; forcing context-engine compaction", {
+			sessionId: activeSessionId,
+			sessionKey: sandboxSessionKey,
+			threadId: thread.threadId,
+			engineId: activeContextEngine.info.id,
+			tokenBudget: params.contextTokenBudget,
+			error: formatErrorMessage(error)
+		});
+		try {
+			const runtimeContext = buildActiveContextEngineRuntimeContext();
+			const overflowTokenCount = params.contextTokenBudget ?? params.contextWindowInfo?.tokens;
+			const compactResult = await activeContextEngine.compact({
+				sessionId: activeSessionId,
+				sessionKey: sandboxSessionKey,
+				sessionFile: activeSessionFile,
+				tokenBudget: params.contextTokenBudget,
+				force: true,
+				...overflowTokenCount ? { currentTokenCount: overflowTokenCount } : {},
+				compactionTarget: "threshold",
+				runtimeContext: overflowTokenCount ? {
+					...runtimeContext,
+					currentTokenCount: overflowTokenCount
+				} : runtimeContext
+			});
+			embeddedAgentLog.info("codex app-server context-engine forced compaction result", {
+				sessionId: activeSessionId,
+				sessionKey: sandboxSessionKey,
+				engineId: activeContextEngine.info.id,
+				ok: compactResult.ok,
+				compacted: compactResult.compacted,
+				reason: compactResult.reason,
+				tokensBefore: compactResult.result?.tokensBefore,
+				tokensAfter: compactResult.result?.tokensAfter
+			});
+			if (!compactResult.ok || !compactResult.compacted) return false;
+			adoptContextEngineCompactionTranscript(compactResult);
+			const maintenanceRuntimeContext = buildActiveContextEngineRuntimeContext();
+			await runHarnessContextEngineMaintenance({
+				contextEngine: activeContextEngine,
+				sessionId: activeSessionId,
+				sessionKey: sandboxSessionKey,
+				sessionFile: activeSessionFile,
+				reason: "compaction",
+				runtimeContext: maintenanceRuntimeContext,
+				config: params.config
+			});
+			return true;
+		} catch (compactErr) {
+			embeddedAgentLog.warn("codex app-server context-engine forced compaction failed", {
+				sessionId: params.sessionId,
+				sessionKey: sandboxSessionKey,
+				engineId: activeContextEngine.info.id,
+				error: formatErrorMessage(compactErr)
+			});
+			return false;
+		}
+	};
+	const rebuildPromptAfterContextEngineCompaction = async () => {
+		historyMessages = await readMirroredSessionHistoryMessages(activeSessionFile) ?? historyMessages;
+		resetCodexPromptInputs();
+		try {
+			await applyActiveContextEngineProjection(void 0);
+		} catch (assembleErr) {
+			embeddedAgentLog.warn("context engine assemble failed after forced compaction; using Codex baseline prompt", { error: formatErrorMessage(assembleErr) });
+		}
+		promptBuild = await buildPromptFromCurrentInputs();
+	};
+	const buildLlmInputEvent = () => ({
 		runId: params.runId,
 		sessionId: params.sessionId,
 		provider: params.provider,
@@ -3126,8 +3453,8 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		prompt: promptBuild.prompt,
 		historyMessages,
 		imagesCount: params.images?.length ?? 0
-	};
-	const turnStartFailureMessages = [...historyMessages, buildCodexUserPromptMessage({
+	});
+	const buildTurnStartFailureMessages = () => [...historyMessages, buildCodexUserPromptMessage({
 		...params,
 		prompt: promptBuild.prompt
 	})];
@@ -3143,7 +3470,7 @@ async function runCodexAppServerAttempt(params, options = {}) {
 	}));
 	try {
 		runAgentHarnessLlmInputHook({
-			event: llmInputEvent,
+			event: buildLlmInputEvent(),
 			ctx: hookContext
 		});
 		emitCodexAppServerEvent(params, {
@@ -3165,7 +3492,11 @@ async function runCodexAppServerAttempt(params, options = {}) {
 				threadId: thread.threadId,
 				error: formatErrorMessage(turnStartError)
 			});
-			await clearCodexAppServerBinding(params.sessionFile);
+			const preRetrySessionFile = activeSessionFile;
+			const compactedForRetry = await forceContextEngineCompactionForCodexOverflow(turnStartError);
+			await clearCodexAppServerBinding(preRetrySessionFile);
+			if (activeSessionFile !== preRetrySessionFile) await clearCodexAppServerBinding(activeSessionFile);
+			if (compactedForRetry) await rebuildPromptAfterContextEngineCompaction();
 			thread = await restartContextEngineCodexThread();
 			emitCodexAppServerEvent(params, {
 				stream: "codex_app_server.lifecycle",
@@ -3219,7 +3550,7 @@ async function runCodexAppServerAttempt(params, options = {}) {
 			});
 			runAgentHarnessAgentEndHook({
 				event: {
-					messages: turnStartFailureMessages,
+					messages: buildTurnStartFailureMessages(),
 					success: false,
 					error: turnStartErrorMessage,
 					durationMs: Date.now() - attemptStartedAt
@@ -3248,7 +3579,7 @@ async function runCodexAppServerAttempt(params, options = {}) {
 				return buildCodexTurnStartFailureResult({
 					params,
 					message: usageLimitError.message,
-					messagesSnapshot: turnStartFailureMessages,
+					messagesSnapshot: buildTurnStartFailureMessages(),
 					systemPromptReport
 				});
 			}
@@ -3302,11 +3633,9 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		abort: () => runAbortController.abort("aborted")
 	};
 	setActiveEmbeddedRun(params.sessionId, handle, params.sessionKey);
-	const timeout = setTimeout(() => {
-		timedOut = true;
-		projector?.markTimedOut();
-		runAbortController.abort("timeout");
-	}, Math.max(100, params.timeoutMs));
+	turnAttemptIdleWatchArmed = true;
+	turnTerminalIdleWatchArmed = true;
+	touchTurnCompletionActivity("turn:start", { attemptProgress: true });
 	const abortListener = () => {
 		const shouldRetireClient = timedOut;
 		interruptCodexTurnBestEffort(client, {
@@ -3380,20 +3709,20 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		});
 		if (activeContextEngine) {
 			const activeContextEnginePluginId = resolveContextEngineOwnerPluginId(activeContextEngine);
-			const finalMessages = await readMirroredSessionHistoryMessages(params.sessionFile) ?? historyMessages.concat(result.messagesSnapshot);
+			const finalMessages = await readMirroredSessionHistoryMessages(activeSessionFile) ?? historyMessages.concat(result.messagesSnapshot);
 			await finalizeHarnessContextEngineTurn({
 				contextEngine: activeContextEngine,
 				promptError: Boolean(finalPromptError),
 				aborted: finalAborted,
 				yieldAborted: Boolean(result.yieldDetected),
-				sessionIdUsed: params.sessionId,
+				sessionIdUsed: activeSessionId,
 				sessionKey: sandboxSessionKey,
-				sessionFile: params.sessionFile,
+				sessionFile: activeSessionFile,
 				messagesSnapshot: finalMessages,
 				prePromptMessageCount,
 				tokenBudget: params.contextTokenBudget,
 				runtimeContext: buildHarnessContextEngineRuntimeContextFromUsage({
-					attempt: runtimeParams,
+					attempt: buildActiveRunAttemptParams(),
 					workspaceDir: effectiveWorkspace,
 					agentDir,
 					activeAgentId: sessionAgentId,
@@ -3462,7 +3791,7 @@ async function runCodexAppServerAttempt(params, options = {}) {
 		});
 		if (!timedOut && !runAbortController.signal.aborted) await steeringQueue?.flushPending();
 		userInputBridge?.cancelPending();
-		clearTimeout(timeout);
+		clearTurnAttemptIdleTimer();
 		clearTurnCompletionIdleTimer();
 		clearTurnAssistantCompletionIdleTimer();
 		clearTurnTerminalIdleTimer();
@@ -3804,6 +4133,45 @@ function shouldProjectMirroredHistoryForCodexStart(params) {
 		next: params.dynamicToolsFingerprint
 	});
 }
+function readContextEngineThreadBootstrapProjection(projection) {
+	if (projection?.mode !== "thread_bootstrap") return;
+	const epoch = projection.epoch?.trim();
+	if (!epoch) {
+		embeddedAgentLog.warn("context engine requested Codex thread-bootstrap projection without an epoch; using per-turn projection");
+		return;
+	}
+	const fingerprint = projection.fingerprint?.trim();
+	return {
+		mode: "thread_bootstrap",
+		epoch,
+		...fingerprint ? { fingerprint } : {}
+	};
+}
+function resolveContextEngineBootstrapProjectionDecision(params) {
+	const bindingProjection = params.startupBinding?.contextEngine?.projection;
+	if (!params.startupBinding?.threadId || !bindingProjection) return {
+		project: true,
+		reason: !params.startupBinding?.threadId ? "missing-thread-binding" : "missing-projection-binding"
+	};
+	if (!params.expectedBinding || !isContextEngineBindingCompatible(params.startupBinding.contextEngine, params.expectedBinding)) return {
+		project: true,
+		reason: "context-engine-binding-mismatch"
+	};
+	if (!areCodexDynamicToolFingerprintsCompatible({
+		previous: params.startupBinding.dynamicToolsFingerprint,
+		next: params.dynamicToolsFingerprint
+	})) return {
+		project: true,
+		reason: "dynamic-tools-mismatch"
+	};
+	return bindingProjection.mode !== "thread_bootstrap" || bindingProjection.epoch !== params.projection.epoch || bindingProjection.fingerprint !== params.projection.fingerprint ? {
+		project: true,
+		reason: "projection-mismatch"
+	} : {
+		project: false,
+		reason: "matching-thread-bootstrap-binding"
+	};
+}
 async function withCodexStartupTimeout(params) {
 	if (params.signal.aborted) throw new Error("codex app-server startup aborted");
 	let timeout;
@@ -3985,6 +4353,10 @@ function isCompletedAssistantNotification(notification) {
 	const item = isJsonObject(notification.params.item) ? notification.params.item : void 0;
 	return Boolean(item && readString(item, "type") === "agentMessage" && readString(item, "phase") !== "commentary");
 }
+function isAssistantCompletionReleaseNotification(notification, turnCrossedToolHandoff) {
+	if (isCompletedAssistantNotification(notification)) return true;
+	return !turnCrossedToolHandoff && isRawAssistantCompletionNotification(notification);
+}
 function shouldDisarmAssistantCompletionIdleWatch(notification) {
 	if (!isJsonObject(notification.params)) return false;
 	if (notification.method === "item/started") return true;
@@ -4004,6 +4376,28 @@ function isTrackedOpenClawDynamicToolCompletionNotification(notification, active
 	const itemType = item ? readString(item, "type") : void 0;
 	return itemType === void 0 || itemType === "dynamicToolCall";
 }
+function isRawToolOutputCompletionNotification(notification) {
+	if (notification.method !== "rawResponseItem/completed" || !isJsonObject(notification.params)) return false;
+	const item = isJsonObject(notification.params.item) ? notification.params.item : void 0;
+	return item ? readString(item, "type") === "custom_tool_call_output" : false;
+}
+function isNativeToolProgressNotification(notification) {
+	if (notification.method !== "item/started" && notification.method !== "item/completed" && notification.method !== "item/updated") return false;
+	if (!isJsonObject(notification.params)) return false;
+	const item = isJsonObject(notification.params.item) ? notification.params.item : void 0;
+	switch (item ? readString(item, "type") : void 0) {
+		case "commandExecution":
+		case "fileChange":
+		case "mcpToolCall":
+		case "webSearch": return true;
+		default: return false;
+	}
+}
+function isRawAssistantCompletionNotification(notification) {
+	if (notification.method !== "rawResponseItem/completed" || !isJsonObject(notification.params)) return false;
+	const item = isJsonObject(notification.params.item) ? notification.params.item : void 0;
+	return Boolean(item && readString(item, "type") === "message" && readString(item, "role") === "assistant" && readString(item, "phase") !== "commentary" && readRawAssistantTextPreview(item));
+}
 function readRawAssistantTextPreview(item) {
 	if (readString(item, "role") !== "assistant" || !Array.isArray(item.content)) return;
 	const text = item.content.flatMap((content) => {
@@ -4018,6 +4412,19 @@ function isTurnNotification(value, threadId, turnId) {
 	if (!isJsonObject(value)) return false;
 	return readString(value, "threadId") === threadId && readNotificationTurnId(value) === turnId;
 }
+function isCurrentThreadTurnRequestParams(value, threadId, turnId) {
+	if (!isJsonObject(value)) return false;
+	return readString(value, "threadId") === threadId && readString(value, "turnId") === turnId;
+}
+function isCurrentApprovalTurnRequestParams(value, threadId, turnId) {
+	if (!isJsonObject(value)) return false;
+	return (readString(value, "threadId") ?? readString(value, "conversationId")) === threadId && readString(value, "turnId") === turnId;
+}
+function isCurrentThreadOptionalTurnRequestParams(value, threadId, turnId) {
+	if (!isJsonObject(value) || readString(value, "threadId") !== threadId) return false;
+	const requestTurnId = value.turnId;
+	return requestTurnId === null || requestTurnId === void 0 || requestTurnId === turnId;
+}
 function isRetryableErrorNotification(value) {
 	if (!isJsonObject(value)) return false;
 	return readBoolean(value, "willRetry") === true || readBoolean(value, "will_retry") === true;
@@ -4289,6 +4696,11 @@ function prependCurrentTurnContext(prompt, context) {
 	const text = context?.text.trim();
 	return text ? [text, prompt].filter(Boolean).join("\n\n") : prompt;
 }
+function waitForCodexNotificationDispatchTurn() {
+	return new Promise((resolve) => {
+		setImmediate(resolve);
+	});
+}
 function handleApprovalRequest(params) {
 	return handleCodexAppServerApprovalRequest({
 		method: params.method,