@openclaw/codex 2026.10.5-beta.3 → 2026.10.10-beta.1

package/dist/.setup/{run-attempt-lifecycle-KN4oh-7O.mjs → run-attempt-lifecycle-DN-ATDp9.mjs}

@@ -1,4 +1,4 @@
-import { t as attemptTerminal } from "./attempt-terminal-jO5IMj9K.mjs";
+import { t as attemptTerminal } from "./attempt-terminal-sZutF0WY.mjs";
 import path from "node:path";
 import fs from "node:fs/promises";
 import { awaitAgentEndSideEffects, embeddedAgentLog, formatErrorMessage, runAgentCleanupStep, runAgentEndSideEffectsAsync } from "openclaw/plugin-sdk/agent-harness-runtime";

package/dist/.setup/{runtime-artifact-C13pR7tD.mjs → runtime-artifact-CmLWeyJB.mjs}

@@ -1,7 +1,7 @@
 import { n as isCodexAppServerProxyLaunch } from "./launch-args-DbFCehO7.mjs";
-import { a as resolvePackagedCodexNativeCommand } from "./managed-binary-BtIjV7yN.mjs";
-import { n as resolveCodexAppServerSpawnEnv, r as resolveCodexAppServerSpawnInvocation } from "./transport-stdio-CRWTkKOn.mjs";
-import { captureCodexConfiguredConnection, finalizeCodexConfiguredConnection, isCodexConfiguredConnectionArtifact, validateCodexConfiguredConnectionCapture } from "./runtime-artifact-connection-jS5DeCok.mjs";
+import { p as resolvePackagedCodexNativeCommand } from "./managed-binary-DbKvGXKl.mjs";
+import { n as resolveCodexAppServerSpawnEnv, r as resolveCodexAppServerSpawnInvocation } from "./transport-stdio-Bq160Dhv.mjs";
+import { captureCodexConfiguredConnection, finalizeCodexConfiguredConnection, isCodexConfiguredConnectionArtifact, validateCodexConfiguredConnectionCapture } from "./runtime-artifact-connection-DpWlZ02e.mjs";
 import { createHash } from "node:crypto";
 import { resolveWindowsExecutablePath } from "openclaw/plugin-sdk/windows-spawn";
 import { resolveGlobalSingleton } from "openclaw/plugin-sdk/global-singleton";

package/dist/.setup/{runtime-artifact-connection-jS5DeCok.mjs → runtime-artifact-connection-DpWlZ02e.mjs}

@@ -1,6 +1,6 @@
-import { t as codexAppServerStartOptionsKey } from "./config-options-DDzeNQ8m.mjs";
-import "./config-runtime-DWzK-k0n.mjs";
-import { r as resolveCodexAppServerUnixSocketPath } from "./transport-websocket-DIyPfkHo.mjs";
+import { t as codexAppServerStartOptionsKey } from "./config-options-DMFZkd3X.mjs";
+import "./config-runtime-BZRizyuG.mjs";
+import { r as resolveCodexAppServerUnixSocketPath } from "./transport-websocket-0YqiI_MH.mjs";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createHash } from "node:crypto";
 import path from "node:path";

package/dist/.setup/{sandbox-guard-DIImwCy1.mjs → sandbox-guard-DneAfNye.mjs}

@@ -1,16 +1,13 @@
 import { l as isCodexRemoteExecPlacementSandbox } from "./config-parsing-DsWSCPHO.mjs";
-import { n as resolveCodexNativeExecutionPolicy, t as formatCodexNativeNodeExecBlock } from "./native-execution-policy-MXEe7PB3.mjs";
-import { t as __exportAll } from "./session-binding-sidecars-DD-enC8w.mjs";
+import { n as prepareCodexNativeExecutionPolicy, t as formatCodexNativeNodeExecBlock } from "./native-execution-policy-D09tLP-u.mjs";
+import { t as __exportAll } from "./session-binding-sidecars-BNSS6WL4.mjs";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { tryResolveDefaultAgentId } from "openclaw/plugin-sdk/agent-scope-runtime";
-import { parseAgentSessionKey } from "openclaw/plugin-sdk/routing";
-import { resolveSandboxRuntimeStatus } from "openclaw/plugin-sdk/sandbox";
 //#region extensions/codex/src/app-server/sandbox-guard.ts
-/**
-* Blocks direct Codex app-server requests that would bypass OpenClaw sandbox or
-* node-exec routing guarantees.
-*/
 var sandbox_guard_exports = /* @__PURE__ */ __exportAll({
+	assertNativeConversationApprovalPolicySupported: () => assertNativeConversationApprovalPolicySupported,
+	prepareCodexAppServerDirectSandboxBypassBlock: () => prepareCodexAppServerDirectSandboxBypassBlock,
+	prepareCodexNativeExecutionBlock: () => prepareCodexNativeExecutionBlock,
+	prepareCodexNativeSandboxBlock: () => prepareCodexNativeSandboxBlock,
 	resolveCodexAppServerDirectSandboxBypassBlock: () => resolveCodexAppServerDirectSandboxBypassBlock,
 	resolveCodexNativeExecutionBlock: () => resolveCodexNativeExecutionBlock,
 	resolveCodexNativeSandboxBlock: () => resolveCodexNativeSandboxBlock
@@ -59,6 +56,10 @@ function resolveCodexAppServerDirectSandboxBypassBlock(params) {
 			config: params.config,
 			sessionKey: params.sessionKey,
 			sessionId: params.sessionId,
+			agentId: params.agentId,
+			storePath: params.storePath,
+			sessionTarget: params.sessionTarget,
+			executionPolicy: params.executionPolicy,
 			surface: `app-server method \`${params.method}\``
 		});
 		if (nodeExecBlock) return nodeExecBlock;
@@ -67,13 +68,63 @@ function resolveCodexAppServerDirectSandboxBypassBlock(params) {
 	const sessionKey = params.sessionKey?.trim() || params.sessionId?.trim();
 	if (!sessionKey) return;
 	const sandboxBlock = resolveCodexNativeSandboxBlock({
-		config: params.config,
+		...params,
 		sessionKey,
-		sandbox: params.sandbox,
 		surface: `app-server method \`${params.method}\``
 	});
 	return sandboxBlock && params.method === "thread/start" && hasOpenClawSandboxEnvironmentSelection(params.requestParams) ? void 0 : sandboxBlock;
 }
+/** Resolve policy before yielding to client acquisition and recheck it at each write. */
+async function prepareCodexAppServerDirectSandboxBypassBlock(params) {
+	if (ALLOWED_CONTROL_PLANE_METHODS.has(params.method) && params.method !== "config/mcpServer/reload") return {
+		block: void 0,
+		async assertCurrent() {},
+		release() {}
+	};
+	const selected = await prepareCodexNativeExecutionPolicy({
+		...params,
+		readRuntimeSessionEntry: true
+	});
+	return {
+		block: resolveCodexAppServerDirectSandboxBypassBlock({
+			...params,
+			executionPolicy: selected.policy
+		}),
+		assertCurrent: selected.assertCurrent,
+		source: selected.source,
+		release: selected.release
+	};
+}
+async function prepareCodexNativeExecutionBlock(params) {
+	const selected = await prepareCodexNativeExecutionPolicy({
+		...params,
+		readRuntimeSessionEntry: true
+	});
+	return {
+		block: resolveCodexNativeExecutionBlock({
+			...params,
+			executionPolicy: selected.policy
+		}),
+		assertCurrent: selected.assertCurrent,
+		source: selected.source,
+		release: selected.release
+	};
+}
+async function prepareCodexNativeSandboxBlock(params) {
+	const selected = await prepareCodexNativeExecutionPolicy({
+		...params,
+		readRuntimeSessionEntry: true
+	});
+	return {
+		block: resolveCodexNativeSandboxBlock({
+			...params,
+			executionPolicy: selected.policy
+		}),
+		assertCurrent: selected.assertCurrent,
+		source: selected.source,
+		release: selected.release
+	};
+}
 /** Resolves the generic native-execution block for sandboxed or node-hosted sessions. */
 function resolveCodexNativeExecutionBlock(params) {
 	return resolveCodexNativeSandboxBlock(params) ?? resolveCodexNativeNodeExecBlock(params);
@@ -81,18 +132,9 @@ function resolveCodexNativeExecutionBlock(params) {
 /** Returns a block message when native Codex execution cannot honor active sandboxing. */
 function resolveCodexNativeSandboxBlock(params) {
 	if (params.sandboxEnvironmentSelected) return;
-	const sessionKey = params.sessionKey?.trim() || params.sessionId?.trim();
-	if (!sessionKey) return;
+	if (!(params.sessionKey?.trim() || params.sessionId?.trim())) return;
 	if (isCodexRemoteExecPlacementSandbox(params.sandbox) || params.sandbox?.enabled === true) return formatCodexNativeSandboxBlock({ surface: params.surface });
-	const sandboxAgentId = parseAgentSessionKey(sessionKey)?.agentId ?? params.agentId ?? tryResolveDefaultAgentId(params.config ?? {});
-	if (!sandboxAgentId) return;
-	if (!resolveSandboxRuntimeStatus({
-		cfg: params.config,
-		sessionKey,
-		agentId: sandboxAgentId,
-		classificationAgentId: sandboxAgentId
-	}).sandboxed) return;
-	return formatCodexNativeSandboxBlock({ surface: params.surface });
+	return params.executionPolicy.sandboxed ? formatCodexNativeSandboxBlock({ surface: params.surface }) : void 0;
 }
 function hasOpenClawSandboxEnvironmentSelection(value) {
 	if (!isRecord(value)) return false;
@@ -107,18 +149,16 @@ function formatCodexNativeSandboxBlock(params) {
 	].join(" ");
 }
 function resolveCodexNativeNodeExecBlock(params) {
-	const sessionKey = params.sessionKey?.trim() || params.sessionId?.trim();
-	const policy = resolveCodexNativeExecutionPolicy({
-		config: params.config,
-		sessionKey,
-		agentId: params.agentId,
-		readRuntimeSessionEntry: Boolean(sessionKey)
-	});
+	const policy = params.executionPolicy;
 	if (policy.nativeToolSurfaceAllowed) return;
 	return formatCodexNativeNodeExecBlock({
 		surface: params.surface,
 		reason: policy.blockReason
 	});
 }
+const NATIVE_CONVERSATION_INTERACTIVE_APPROVALS_UNAVAILABLE = "OpenClaw native Codex conversation binding cannot route interactive approvals yet; use the Codex harness or explicit /acp spawn codex for that workflow.";
+function assertNativeConversationApprovalPolicySupported(runtime) {
+	if (runtime.approvalPolicy !== "never" && runtime.approvalsReviewer === "user") throw new Error(NATIVE_CONVERSATION_INTERACTIVE_APPROVALS_UNAVAILABLE);
+}
 //#endregion
-export { resolveCodexNativeSandboxBlock as n, sandbox_guard_exports as r, resolveCodexNativeExecutionBlock as t };
+export { sandbox_guard_exports as a, resolveCodexNativeExecutionBlock as i, prepareCodexNativeExecutionBlock as n, prepareCodexNativeSandboxBlock as r, assertNativeConversationApprovalPolicySupported as t };

package/dist/.setup/{session-binding-JEHNMPsr.mjs → session-binding-BgsWcbdY.mjs}

@@ -1,13 +1,13 @@
-import { i as adoptCodexNativeSubagentSubmissions, n as mutateNativePendingAssignments, o as mutateCodexNativeSubagentSubmissions } from "./native-subagent-pending-assignments-DmVhedNs.mjs";
-import { a as readStoredCodexAppServerBinding, i as readCodexBindingTimestamp, n as matchesPendingSupervisionBranch, o as stripUndefinedBinding, r as readCodexAppServerThreadBinding, s as validateBindingForWrite } from "./session-binding-record-codec-BpH8u_G9.mjs";
-import { a as ownsStoredSessionGeneration, c as preserveNativeTaskImport, d as readCurrentCodexNativeSubagentSubmissions, f as readCurrentNativePendingAssignments, i as matchesCodexNativeSubagentSubmissionBinding, l as readCurrentCodexAppServerBinding, m as sessionBindingIdentity, n as assertCodexBindingMayBeReplaced, o as preserveCodexNativeSubagentSubmissions, p as readPluginAppPolicyContext, r as bindingStoreKey, s as preserveNativePendingAssignments, t as CodexSupervisionBindingReplacementError, u as readCurrentCodexAppServerBindings } from "./session-binding-record-DU_0biMD.mjs";
+import { i as adoptCodexNativeSubagentSubmissions, n as mutateNativePendingAssignments, o as mutateCodexNativeSubagentSubmissions } from "./native-subagent-pending-assignments-CTinVtjo.mjs";
+import { a as readStoredCodexAppServerBinding, i as readCodexBindingTimestamp, n as matchesPendingSupervisionBranch, o as stripUndefinedBinding, r as readCodexAppServerThreadBinding, s as validateBindingForWrite } from "./session-binding-record-codec-DvmOI7g_.mjs";
+import { a as ownsStoredSessionGeneration, c as preserveNativeTaskImport, d as readCurrentCodexAppServerBindingAsync, f as readCurrentCodexAppServerBindings, g as sessionBindingIdentity, h as readPluginAppPolicyContext, i as matchesCodexNativeSubagentSubmissionBinding, l as preservedSessionGeneration, m as readCurrentNativePendingAssignments, n as assertCodexBindingMayBeReplaced, o as preserveCodexNativeSubagentSubmissions, p as readCurrentCodexNativeSubagentSubmissions, r as bindingStoreKey, s as preserveNativePendingAssignments, t as CodexSupervisionBindingReplacementError, u as readCurrentCodexAppServerBinding, v as storedSessionGeneration } from "./session-binding-record-C_THntMe.mjs";
 import { a as PHYSICAL_SESSION_RETIRE_TTL_MS, i as CODEX_APP_SERVER_BINDING_NAMESPACE, n as CODEX_APP_SERVER_BINDING_LEASE, r as CODEX_APP_SERVER_BINDING_MAX_ENTRIES, t as CODEX_APP_SERVER_BINDING_GUARDED_REQUEST_TIMEOUT_MS } from "./session-binding-meta-Lkm5Lpf4.mjs";
-import { n as normalizeCodexAppServerBindingModelProvider } from "./auth-profile-CgHQ8Vot.mjs";
-import { t as __exportAll } from "./session-binding-sidecars-DD-enC8w.mjs";
+import { n as normalizeCodexAppServerBindingModelProvider } from "./auth-profile-auwzSwwy.mjs";
+import { t as __exportAll } from "./session-binding-sidecars-BNSS6WL4.mjs";
 import { asOptionalRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createHash } from "node:crypto";
 import { AgentHarnessSessionSupersededError, embeddedAgentLog } from "openclaw/plugin-sdk/agent-harness-runtime";
-import { combineNativeSessionBindingAuthority as combineCodexBindingAuthority, createNativeSessionBindingLifecycle, reclaimNativeSessionGenerationWithAuthority, resolveNativeSessionBindingWithAuthority } from "openclaw/plugin-sdk/agent-harness-session-runtime";
+import { combinePreparedNativeSessionBindingAuthority as combineCodexBindingAuthority, createNativeSessionBindingLifecycleV2, reclaimNativeSessionGenerationWithAuthority, resolvePreparedNativeSessionBinding } from "openclaw/plugin-sdk/agent-harness-session-runtime";
 //#region extensions/codex/src/app-server/session-binding-native-mutations.ts
 /** The caller supplies the transaction's freshly parsed row and current-authority closure. */
 function mutateNativeSubagentBinding({ identity, current, mutation, assertCurrent }) {
@@ -64,7 +64,7 @@ function normalizeStoredCodexAppServerBindingFingerprints(value) {
 	});
 }
 /** Encodes a migrated sidecar binding as one canonical plugin-state row. */
-function createStoredCodexAppServerBinding(value, options = {}) {
+async function createStoredCodexAppServerBinding(value, options = {}) {
 	const rawRecord = asOptionalRecord(value);
 	if (!rawRecord) return;
 	const record = normalizeLegacyBindingFingerprints(rawRecord);
@@ -74,7 +74,7 @@ function createStoredCodexAppServerBinding(value, options = {}) {
 	const authProfileId = typeof record.authProfileId === "string" ? record.authProfileId : void 0;
 	const binding = readCodexAppServerThreadBinding({
 		...record,
-		modelProvider: normalizeCodexAppServerBindingModelProvider({
+		modelProvider: await normalizeCodexAppServerBindingModelProvider({
 			...options.lookup,
 			authProfileId,
 			modelProvider: typeof record.modelProvider === "string" ? record.modelProvider : void 0
@@ -141,13 +141,13 @@ async function reclaimCurrentCodexSessionGeneration(params) {
 /** Resolve continuity before selecting native queues, catalogs, or connections. */
 async function resolveCodexSessionBinding(params) {
 	const identity = params.identity;
-	return await resolveNativeSessionBindingWithAuthority({
+	return await resolvePreparedNativeSessionBinding({
 		...params,
 		...identity.kind === "session" ? {
 			target: identity,
 			generation: codexSessionGenerationOperations(params.bindingStore, identity)
 		} : {},
-		readBinding: (sessionId) => params.bindingStore.read(sessionId && identity.kind === "session" ? {
+		readBinding: (sessionId) => params.bindingStore.readAsync(sessionId && identity.kind === "session" ? {
 			...identity,
 			sessionId
 		} : identity),
@@ -156,7 +156,16 @@ async function resolveCodexSessionBinding(params) {
 }
 /** Creates the single binding facade owned by the Codex plugin runtime. */
 function createCodexAppServerBindingStore(state) {
-	const lifecycle = createNativeSessionBindingLifecycle(state, {
+	const lifecycle = createNativeSessionBindingLifecycleV2({
+		lookup: (key) => state.asyncReads.lookup(key),
+		assertLeaseCurrent: (key, token) => {
+			const raw = state.lookup(key);
+			const current = readStoredCodexAppServerBinding(raw);
+			if (raw !== void 0 && !current) throw new Error(`Invalid Codex app-server binding row: ${key}`);
+			if (current?.lease?.token !== token || current.lease.expiresAt <= Date.now()) throw bindingLeaseLostError(key);
+		},
+		withCurrent: (authority) => state.withCurrent(authority)
+	}, {
 		workerCodec: "codex",
 		readRecord: readStoredCodexAppServerBinding,
 		lease: CODEX_APP_SERVER_BINDING_LEASE,
@@ -224,12 +233,13 @@ function createCodexAppServerBindingStore(state) {
 	};
 	return {
 		read: (identity) => readCurrentCodexAppServerBinding(state, identity),
+		readAsync: (identity) => readCurrentCodexAppServerBindingAsync(state.asyncReads, identity),
 		readMany: (identities) => readCurrentCodexAppServerBindings(state.asyncReads, identities),
-		readNativeSubagentAssignments: (identity, owner) => readCurrentNativePendingAssignments(state, identity, owner),
-		readNativeSubagentSubmissions: (identity, owner) => readCurrentCodexNativeSubagentSubmissions(state, identity, owner),
+		readNativeSubagentAssignments: (identity, owner) => readCurrentNativePendingAssignments(state.asyncReads, identity, owner),
+		readNativeSubagentSubmissions: (identity, owner) => readCurrentCodexNativeSubagentSubmissions(state.asyncReads, identity, owner),
 		async hasOtherThreadOwner(threadId, currentIdentity) {
 			const currentKey = currentIdentity ? bindingStoreKey(currentIdentity) : void 0;
-			return state.entries().some(({ key, value }) => {
+			return (await state.asyncReads.entries()).some(({ key, value }) => {
 				const stored = readStoredCodexAppServerBinding(value);
 				if (!stored) throw new Error(`Invalid Codex app-server binding row: ${key}`);
 				const isCurrentOwner = currentIdentity !== void 0 && key === currentKey && (currentIdentity.kind === "conversation" || stored.sessionId === currentIdentity.sessionId.trim());
@@ -238,7 +248,7 @@ function createCodexAppServerBindingStore(state) {
 		},
 		async prepareSessionGenerationReclaim(identity) {
 			const key = bindingStoreKey(identity);
-			const raw = state.lookup(key);
+			const raw = await state.asyncReads.lookup(key);
 			const current = readStoredCodexAppServerBinding(raw);
 			if (raw !== void 0 && !current) throw new Error(`Invalid Codex app-server binding row: ${key}`);
 			if (!current) return {
@@ -394,13 +404,5 @@ function codexSessionGenerationOperations(store, identity) {
 function isSameSupervisionOwner(current, replacement) {
 	return replacement.connectionScope === "supervision" && replacement.threadId === current.threadId && replacement.supervisionSourceThreadId === current.supervisionSourceThreadId;
 }
-function storedSessionGeneration(identity, current) {
-	if (identity.kind === "session") return { sessionId: identity.sessionId };
-	return current?.sessionId ? { sessionId: current.sessionId } : {};
-}
-function preservedSessionGeneration(identity, current) {
-	if (current?.sessionId) return { sessionId: current.sessionId };
-	return storedSessionGeneration(identity, current);
-}
 //#endregion
 export { session_binding_exports as a, resolveCodexSessionBinding as i, createCodexSessionGenerationSupersededError as n, hashCodexAppServerBindingFingerprint as o, reclaimCurrentCodexSessionGeneration as r, clearCodexBindingForClient as t };

package/dist/.setup/{session-binding-record-DU_0biMD.mjs → session-binding-record-C_THntMe.mjs}

@@ -1,6 +1,6 @@
-import { a as matchesCodexNativeSubagentSubmissionOwner, h as codexNativeSubagentHistoryConnectionFingerprint, r as readNativePendingAssignments, s as readCodexNativeSubagentSubmissions, t as matchesNativeAssignmentLifecycle } from "./native-subagent-pending-assignments-DmVhedNs.mjs";
-import { a as readStoredCodexAppServerBinding, t as legacyAppPolicyEntrySchema } from "./session-binding-record-codec-BpH8u_G9.mjs";
-import { t as __exportAll } from "./session-binding-sidecars-DD-enC8w.mjs";
+import { a as matchesCodexNativeSubagentSubmissionOwner, h as codexNativeSubagentHistoryConnectionFingerprint, r as readNativePendingAssignments, s as readCodexNativeSubagentSubmissions, t as matchesNativeAssignmentLifecycle } from "./native-subagent-pending-assignments-CTinVtjo.mjs";
+import { a as readStoredCodexAppServerBinding, t as legacyAppPolicyEntrySchema } from "./session-binding-record-codec-DvmOI7g_.mjs";
+import { t as __exportAll } from "./session-binding-sidecars-BNSS6WL4.mjs";
 import { asOptionalRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createHash } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
@@ -17,13 +17,16 @@ var session_binding_record_exports = /* @__PURE__ */ __exportAll({
 	preserveCodexNativeSubagentSubmissions: () => preserveCodexNativeSubagentSubmissions,
 	preserveNativePendingAssignments: () => preserveNativePendingAssignments,
 	preserveNativeTaskImport: () => preserveNativeTaskImport,
+	preservedSessionGeneration: () => preservedSessionGeneration,
 	readCurrentCodexAppServerBinding: () => readCurrentCodexAppServerBinding,
+	readCurrentCodexAppServerBindingAsync: () => readCurrentCodexAppServerBindingAsync,
 	readCurrentCodexAppServerBindings: () => readCurrentCodexAppServerBindings,
 	readCurrentCodexNativeSubagentSubmissions: () => readCurrentCodexNativeSubagentSubmissions,
 	readCurrentNativePendingAssignments: () => readCurrentNativePendingAssignments,
 	readPluginAppPolicyContext: () => readPluginAppPolicyContext,
 	readStoredCodexAppServerBinding: () => readStoredCodexAppServerBinding,
-	sessionBindingIdentity: () => sessionBindingIdentity
+	sessionBindingIdentity: () => sessionBindingIdentity,
+	storedSessionGeneration: () => storedSessionGeneration
 });
 /** Resolves the same agent scope OpenClaw uses for transcript/session ownership. */
 function sessionBindingIdentity(params) {
@@ -55,11 +58,15 @@ function bindingStoreKey(identity) {
 function ownsStoredSessionGeneration(identity, current) {
 	return identity.kind !== "session" || !current?.sessionId || current.sessionId === identity.sessionId;
 }
-/** The same physical-generation check serves execution and read-only projections. */
+/** Final effect guards retain the live row until raw SDK binding writers retire. */
 function readCurrentCodexAppServerBinding(state, identity) {
 	const key = bindingStoreKey(identity);
 	return decodeCurrentCodexAppServerBinding(key, state.lookup(key), identity);
 }
+async function readCurrentCodexAppServerBindingAsync(state, identity) {
+	const key = bindingStoreKey(identity);
+	return decodeCurrentCodexAppServerBinding(key, await state.lookup(key), identity);
+}
 function decodeCurrentCodexAppServerBinding(key, raw, identity) {
 	const stored = readStoredCodexAppServerBinding(raw);
 	if (raw !== void 0 && !stored) throw new Error(`Invalid Codex app-server binding row: ${key}`);
@@ -96,19 +103,19 @@ function matchesCodexNativeSubagentSubmissionBinding(binding, owner) {
 function preserveCodexNativeSubagentSubmissions(currentBinding, nextBinding, value) {
 	return currentBinding.threadId === nextBinding.threadId ? preserveNativePendingAssignments(currentBinding, nextBinding, value) : void 0;
 }
-function readCurrentCodexNativeSubagentSubmissions(state, identity, owner) {
-	const stored = readCurrentNativeSubagentBinding(state, identity, owner);
+async function readCurrentCodexNativeSubagentSubmissions(state, identity, owner) {
+	const stored = await readCurrentNativeSubagentBinding(state, identity, owner);
 	if (!stored) return [];
 	const submissions = readCodexNativeSubagentSubmissions(stored.nativeSubagentSubmissions);
 	return submissions && matchesCodexNativeSubagentSubmissionOwner(submissions.owner, owner) ? submissions.receipts : [];
 }
-function readCurrentNativePendingAssignments(state, identity, owner) {
-	const stored = readCurrentNativeSubagentBinding(state, identity, owner);
+async function readCurrentNativePendingAssignments(state, identity, owner) {
+	const stored = await readCurrentNativeSubagentBinding(state, identity, owner);
 	return (readNativePendingAssignments(stored?.nativeSubagentAssignments)?.assignments ?? []).filter((entry) => matchesNativeAssignmentLifecycle(entry.owner, owner));
 }
-function readCurrentNativeSubagentBinding(state, identity, owner) {
+async function readCurrentNativeSubagentBinding(state, identity, owner) {
 	const key = bindingStoreKey(identity);
-	const raw = state.lookup(key);
+	const raw = await state.lookup(key);
 	const stored = readStoredCodexAppServerBinding(raw);
 	if (raw !== void 0 && !stored) throw new Error(`Invalid Codex app-server binding row: ${key}`);
 	if (stored?.state !== "active" || !ownsStoredSessionGeneration(identity, stored) || identity.kind === "session" && owner.sessionId !== identity.sessionId || !matchesCodexNativeSubagentSubmissionBinding(stored.binding, owner)) return;
@@ -175,5 +182,13 @@ function readPluginAppPolicyContext(value) {
 		pluginAppIds: parsedPluginAppIds
 	};
 }
+function storedSessionGeneration(identity, current) {
+	if (identity.kind === "session") return { sessionId: identity.sessionId };
+	return current?.sessionId ? { sessionId: current.sessionId } : {};
+}
+function preservedSessionGeneration(identity, current) {
+	if (current?.sessionId) return { sessionId: current.sessionId };
+	return storedSessionGeneration(identity, current);
+}
 //#endregion
-export { ownsStoredSessionGeneration as a, preserveNativeTaskImport as c, readCurrentCodexNativeSubagentSubmissions as d, readCurrentNativePendingAssignments as f, session_binding_record_exports as h, matchesCodexNativeSubagentSubmissionBinding as i, readCurrentCodexAppServerBinding as l, sessionBindingIdentity as m, assertCodexBindingMayBeReplaced as n, preserveCodexNativeSubagentSubmissions as o, readPluginAppPolicyContext as p, bindingStoreKey as r, preserveNativePendingAssignments as s, CodexSupervisionBindingReplacementError as t, readCurrentCodexAppServerBindings as u };
+export { session_binding_record_exports as _, ownsStoredSessionGeneration as a, preserveNativeTaskImport as c, readCurrentCodexAppServerBindingAsync as d, readCurrentCodexAppServerBindings as f, sessionBindingIdentity as g, readPluginAppPolicyContext as h, matchesCodexNativeSubagentSubmissionBinding as i, preservedSessionGeneration as l, readCurrentNativePendingAssignments as m, assertCodexBindingMayBeReplaced as n, preserveCodexNativeSubagentSubmissions as o, readCurrentCodexNativeSubagentSubmissions as p, bindingStoreKey as r, preserveNativePendingAssignments as s, CodexSupervisionBindingReplacementError as t, readCurrentCodexAppServerBinding as u, storedSessionGeneration as v };

package/dist/.setup/{session-binding-record-codec-BpH8u_G9.mjs → session-binding-record-codec-DvmOI7g_.mjs}

@@ -111,6 +111,7 @@ const threadBindingSchema = z.object({
 	contextEngine: contextEngineSchema.optional().catch(void 0),
 	environmentSelectionFingerprint: optionalStringSchema,
 	conversationStartId: optionalStringSchema,
+	conversationIncognito: z.literal(true).optional(),
 	conversationSourceTransferComplete: z.literal(true).optional().catch(void 0),
 	historyCoveredThrough: optionalTimestampSchema,
 	continuityCalibration: z.object({

package/dist/.setup/{session-binding-sidecars-DD-enC8w.mjs → session-binding-sidecars-BNSS6WL4.mjs}

@@ -246,6 +246,16 @@ function isSafeLegacySessionId(value) {
 	const trimmed = value.trim();
 	return trimmed.length > 0 && trimmed.length <= 255 && /^[A-Za-z0-9][A-Za-z0-9._:@-]*$/.test(trimmed);
 }
+async function resolveLegacySessionFileLocator(sessionsDir, entry, sessionId) {
+	const base = path.resolve(sessionsDir);
+	const fallback = path.join(base, `${sessionId}.jsonl`);
+	const sessionFile = entry.sessionFile?.trim();
+	if (!sessionFile) return fallback;
+	const candidate = path.resolve(base, sessionFile);
+	const [canonicalBase, canonicalCandidate] = await Promise.all([canonicalPathFromExistingAncestor(base), canonicalPathFromExistingAncestor(candidate)]);
+	if (!isPathInside(canonicalBase, canonicalCandidate)) throw new Error("legacy session file locator escapes its session directory");
+	return candidate;
+}
 //#endregion
 //#region extensions/codex/src/migration/session-binding-sidecars.ts
 const LEGACY_BINDING_SUFFIX = ".codex-app-server.json";
@@ -410,7 +420,7 @@ async function collectBindingOwners(sources, surfaces, params) {
 				storePath,
 				transcriptPath: legacyTranscriptPath,
 				...entry.lifecycleRevision ? { lifecycleRevision: entry.lifecycleRevision } : {},
-				...entry.agentHarnessId?.trim() ? { agentHarnessId: entry.agentHarnessId.trim() } : {},
+				agentHarnessId: entry.agentHarnessId?.trim(),
 				...entry.updatedAt !== void 0 ? { updatedAt: entry.updatedAt } : {}
 			};
 			const candidates = owners.get(canonicalLegacyTranscriptPath) ?? /* @__PURE__ */ new Map();
@@ -428,16 +438,6 @@ async function collectBindingOwners(sources, surfaces, params) {
 		failures
 	};
 }
-async function resolveLegacySessionFileLocator(sessionsDir, entry, sessionId) {
-	const base = path.resolve(sessionsDir);
-	const fallback = path.join(base, `${sessionId}.jsonl`);
-	const sessionFile = entry.sessionFile?.trim();
-	if (!sessionFile) return fallback;
-	const candidate = path.resolve(base, sessionFile);
-	const [canonicalBase, canonicalCandidate] = await Promise.all([canonicalPathFromExistingAncestor(base), canonicalPathFromExistingAncestor(candidate)]);
-	if (!isPathInside(canonicalBase, canonicalCandidate)) throw new Error("legacy session file locator escapes its session directory");
-	return candidate;
-}
 function tryResolveLegacyBindingOwnerAgentId(params) {
 	if (params.sessionKey.trim().toLowerCase().startsWith("agent:")) return resolveSessionAgentIdsStrict({
 		sessionKey: params.sessionKey,
@@ -482,9 +482,9 @@ async function migrateSource(source, candidates, params, store) {
 		return await withFileLock(source.sidecarPath, LEGACY_BINDING_LOCK_OPTIONS, async () => {
 			const [contents, stat] = await Promise.all([fs.readFile(source.sidecarPath, "utf8"), fs.stat(source.sidecarPath)]);
 			const raw = JSON.parse(contents);
-			const [{ bindingStoreKey, createStoredCodexAppServerBinding, normalizeStoredCodexAppServerBindingFingerprints, readStoredCodexAppServerBinding }, { legacyCodexConversationBindingId }] = await Promise.all([import("./session-binding-JEHNMPsr.mjs").then((n) => n.a), import("./conversation-binding-data-UgLuTSQT.mjs").then((n) => n.t)]);
+			const [{ bindingStoreKey, createStoredCodexAppServerBinding, normalizeStoredCodexAppServerBindingFingerprints, readStoredCodexAppServerBinding }, { legacyCodexConversationBindingId }] = await Promise.all([import("./session-binding-BgsWcbdY.mjs").then((n) => n.a), import("./conversation-binding-data-khgW0n-o.mjs").then((n) => n.t)]);
 			const agentId = owner?.agentId ?? (source.agentIds.size === 1 ? [...source.agentIds][0] : void 0);
-			const baseStored = createStoredCodexAppServerBinding(raw, {
+			const baseStored = await createStoredCodexAppServerBinding(raw, {
 				now: stat.mtime.toISOString(),
 				lookup: {
 					config: params.config,
@@ -493,6 +493,7 @@ async function migrateSource(source, candidates, params, store) {
 			});
 			if (!baseStored) return retain("its binding is invalid");
 			if (candidates.length > 1) return retain(`${candidates.length} matching session owners make ownership ambiguous`);
+			if (owner?.agentHarnessId === "") return retain("its session owner changed before Codex ownership could be recorded", "notice");
 			if (owner?.agentHarnessId && owner.agentHarnessId !== CODEX_AGENT_HARNESS_ID) return retain(`its session is owned by agent harness ${owner.agentHarnessId}`, "notice");
 			const readEvidence = params.context.readSessionIdentityEvidenceBatch;
 			const canonicalOwner = owner && readEvidence ? (await readEvidence([{
@@ -511,20 +512,22 @@ async function migrateSource(source, candidates, params, store) {
 				const current = await store.lookup(key);
 				if (current === void 0) return;
 				const parsed = readStoredCodexAppServerBinding(current);
-				if (!parsed) return `canonical plugin state is invalid at ${key}`;
+				if (!parsed) return `current plugin state is invalid at ${key}`;
 				const normalized = normalizeStoredCodexAppServerBindingFingerprints(parsed);
-				if (!normalized) return `canonical plugin state is invalid at ${key}`;
+				if (!normalized) return `current plugin state is invalid at ${key}`;
 				if (isDeepStrictEqual(parsed, normalized)) return parsed;
-				if (parsed.lease && parsed.lease.expiresAt > Date.now()) return `canonical plugin state is leased at ${key}`;
-				const update = store.update;
-				if (!update) return `canonical plugin state could not be normalized at ${key}`;
-				await update(key, (candidate) => {
-					const candidateParsed = readStoredCodexAppServerBinding(candidate);
-					if (!candidateParsed || !isDeepStrictEqual(candidateParsed, parsed)) return;
-					return normalized;
+				if (parsed.lease && parsed.lease.expiresAt > Date.now()) return `current plugin state is leased at ${key}`;
+				const { observe, compareAndApply } = store;
+				if (!observe || !compareAndApply) return `current plugin state could not be normalized at ${key}`;
+				const observation = await observe(key);
+				const candidateParsed = readStoredCodexAppServerBinding(observation.value);
+				if (candidateParsed && isDeepStrictEqual(candidateParsed, parsed)) await compareAndApply(key, observation.comparison, {
+					operation: "update",
+					action: "set",
+					value: normalized
 				});
 				const persisted = readStoredCodexAppServerBinding(await store.lookup(key));
-				if (!persisted || !isDeepStrictEqual(persisted, normalized)) return `canonical plugin state changed at ${key}`;
+				if (!persisted || !isDeepStrictEqual(persisted, normalized)) return `current plugin state changed at ${key}`;
 				importedKeys++;
 				return normalized;
 			};
@@ -557,37 +560,38 @@ async function migrateSource(source, candidates, params, store) {
 			for (const entry of entries) {
 				const current = await readNormalizedRow(entry.key);
 				if (typeof current === "string") return retain(current);
-				if (current && !hasExpected(current, entry.value)) return retain(`canonical plugin state changed at ${entry.key}`);
+				if (current && !hasExpected(current, entry.value)) return retain(`current plugin state changed at ${entry.key}`);
 			}
 			for (const entry of entries) {
 				if (await store.registerIfAbsent(entry.key, entry.value)) importedKeys++;
-				if (!hasExpected(await store.lookup(entry.key), entry.value)) return retain(`canonical plugin state changed at ${entry.key}`);
+				if (!hasExpected(await store.lookup(entry.key), entry.value)) return retain(`current plugin state changed at ${entry.key}`);
 			}
 			if (owner) {
 				const ownershipResult = await recordSessionOwner(owner, params.env, {
 					canCreateOwner,
 					readEvidence
 				});
-				const ownershipWarning = typeof ownershipResult === "string" ? ownershipResult : ownershipResult ? "its canonical session was deleted" : void 0;
+				const ownershipWarning = typeof ownershipResult === "string" ? ownershipResult : ownershipResult ? "its saved session was deleted" : void 0;
 				if (ownershipWarning) {
 					if (sessionEntry?.value.state === "active") {
-						const update = store.update;
-						if (!update) return retain(`${ownershipWarning}; its stale session binding could not be retired`);
-						await update(sessionEntry.key, (current) => {
-							const parsed = readStoredCodexAppServerBinding(current);
-							if (parsed?.lease && parsed.lease.expiresAt > Date.now()) return;
-							if (!hasExpected(current, sessionEntry.value)) return;
-							return {
+						const { observe, compareAndApply } = store;
+						if (!observe || !compareAndApply) return retain(`${ownershipWarning}; its stale session binding could not be retired`);
+						const observation = await observe(sessionEntry.key);
+						const parsed = readStoredCodexAppServerBinding(observation.value);
+						if (!(parsed?.lease && parsed.lease.expiresAt > Date.now()) && hasExpected(observation.value, sessionEntry.value)) await compareAndApply(sessionEntry.key, observation.comparison, {
+							operation: "update",
+							action: "set",
+							value: {
 								version: 1,
 								state: "cleared",
 								sessionId: owner.sessionId,
 								retired: true
-							};
+							}
 						});
 						if (hasExpected(await store.lookup(sessionEntry.key), sessionEntry.value)) return retain(`${ownershipWarning}; its stale session binding could not be retired`);
 					}
 					if (typeof ownershipResult === "string") return retain(ownershipWarning, "notice");
-				} else for (const entry of entries) if (!hasExpected(await store.lookup(entry.key), entry.value)) return retain(`canonical plugin state changed at ${entry.key}`);
+				} else for (const entry of entries) if (!hasExpected(await store.lookup(entry.key), entry.value)) return retain(`current plugin state changed at ${entry.key}`);
 			}
 			const archiveWarnings = [];
 			await (0, runtime_doctor_migrations_exports.archiveLegacyStateSource)({
@@ -611,29 +615,15 @@ async function migrateSource(source, candidates, params, store) {
 	}
 }
 async function recordSessionOwner(owner, env, options) {
-	const { patchSessionEntry } = await import("openclaw/plugin-sdk/session-store-runtime");
-	const currentIndex = await readLegacySessionIndex(owner.storePath);
-	if ("failure" in currentIndex) return "its legacy session owner could not be revalidated";
-	const currentOwner = currentIndex.entries.find(({ sessionKey }) => sessionKey === owner.sessionKey);
-	if (!currentOwner || currentOwner.entry.sessionId !== owner.sessionId) return "its session owner changed before Codex ownership could be recorded";
-	let currentTranscriptPath;
-	try {
-		currentTranscriptPath = await resolveLegacySessionFileLocator(path.dirname(owner.storePath), currentOwner.entry, currentOwner.entry.sessionId);
-	} catch {
-		return "its session owner changed before Codex ownership could be recorded";
-	}
-	if (await canonicalPathFromExistingAncestor(currentTranscriptPath) !== await canonicalPathFromExistingAncestor(owner.transcriptPath) || currentOwner.entry.lifecycleRevision !== owner.lifecycleRevision) return "its session owner changed before Codex ownership could be recorded";
-	const legacyHarnessId = currentOwner.entry.agentHarnessId?.trim();
-	if (currentOwner.entry.agentHarnessId !== void 0 && !legacyHarnessId) return "its session owner changed before Codex ownership could be recorded";
-	if (legacyHarnessId && legacyHarnessId !== CODEX_AGENT_HARNESS_ID) return `its session is owned by agent harness ${legacyHarnessId}`;
-	let observedForeignHarness;
+	const { prepareSessionEntryPatch } = await import("openclaw/plugin-sdk/session-store-runtime");
+	let ownershipRefusal;
 	let observedCanonicalEntry = false;
-	const updated = await patchSessionEntry({
+	if (!await prepareSessionEntryPatch({
 		agentId: owner.agentId,
 		env,
 		...options.canCreateOwner ? { fallbackEntry: {
 			sessionId: owner.sessionId,
-			updatedAt: currentOwner.entry.updatedAt ?? owner.updatedAt ?? 0,
+			updatedAt: owner.updatedAt ?? 0,
 			...owner.lifecycleRevision ? { lifecycleRevision: owner.lifecycleRevision } : {}
 		} } : {},
 		preserveActivity: true,
@@ -641,30 +631,32 @@ async function recordSessionOwner(owner, env, options) {
 		skipMaintenance: true,
 		storePath: owner.storePath,
 		sessionKey: owner.sessionKey,
-		update: (entry, { existingEntry }) => {
+		prepare: (entry, { existingEntry }) => {
 			observedCanonicalEntry = existingEntry !== void 0;
-			if (entry.sessionId.trim() !== owner.sessionId || entry.lifecycleRevision !== owner.lifecycleRevision) return null;
+			if (entry.sessionId.trim() !== owner.sessionId || entry.lifecycleRevision !== owner.lifecycleRevision) {
+				ownershipRefusal = "its session owner changed before Codex ownership could be recorded";
+				return null;
+			}
 			const harnessId = typeof entry.agentHarnessId === "string" ? entry.agentHarnessId.trim() : void 0;
-			if (entry.agentHarnessId !== void 0 && !harnessId) return null;
+			if (entry.agentHarnessId !== void 0 && !harnessId) {
+				ownershipRefusal = "Codex harness ownership could not be recorded on its session";
+				return null;
+			}
 			if (harnessId && harnessId !== CODEX_AGENT_HARNESS_ID) {
-				observedForeignHarness = harnessId;
+				ownershipRefusal = `its session is owned by agent harness ${harnessId}`;
 				return null;
 			}
 			return { agentHarnessId: CODEX_AGENT_HARNESS_ID };
 		}
-	});
-	if (!updated) {
+	}) || ownershipRefusal) {
 		if (!options.canCreateOwner && !observedCanonicalEntry && options.readEvidence) {
 			if ((await options.readEvidence([{
 				agentId: owner.agentId,
 				sessionId: owner.sessionId
 			}]))[0]?.state === "absent") return { deleted: true };
 		}
-		return observedForeignHarness ? `its session is owned by agent harness ${observedForeignHarness}` : "its session owner changed before Codex ownership could be recorded";
+		return ownershipRefusal ?? "its session owner changed before Codex ownership could be recorded";
 	}
-	if (updated.sessionId.trim() !== owner.sessionId || updated.lifecycleRevision !== owner.lifecycleRevision) return "its session owner changed before Codex ownership could be recorded";
-	const harnessId = updated.agentHarnessId?.trim();
-	return harnessId === CODEX_AGENT_HARNESS_ID ? void 0 : harnessId ? `its session is owned by agent harness ${harnessId}` : "Codex harness ownership could not be recorded on its session";
 }
 async function readDirectoryEntries(directory) {
 	try {