@openclaw/codex 2026.7.1-beta.5 → 2026.7.1

package/dist/{app-server-policy-BUk0GLMy.js → app-server-policy-C968Kgin.js}

@@ -1,6 +1,6 @@
 import { r as isJsonObject } from "./protocol-2POPqAY4.js";
 import { n as canUseCodexModelBackedApprovalsReviewerForModel } from "./config-CYEDnLJ2.js";
-import { f as summarizeCodexAccountRateLimits, l as hasCodexRateLimitSnapshots, m as summarizeCodexRateLimits } from "./provider-cc_62eQE.js";
+import { f as summarizeCodexAccountRateLimits, l as hasCodexRateLimitSnapshots, m as summarizeCodexRateLimits } from "./provider-zjPfx5Fs.js";
 //#region extensions/codex/src/command-formatters.ts
 /** Formats the combined `/codex status` probe result. */
 function formatCodexStatus(probes) {

package/dist/{command-handlers-UVniG5Hl.js → command-handlers-Dv-pzAmg.js}

@@ -2,15 +2,15 @@ import { r as isJsonObject } from "./protocol-2POPqAY4.js";
 import { o as isCodexFastServiceTier } from "./config-CYEDnLJ2.js";
 import { n as assertCodexThreadResumeResponse } from "./protocol-validators-dZQ-UTOa.js";
 import { t as listAllCodexAppServerModels } from "./models-DDmO1zwd.js";
-import { p as summarizeCodexAccountUsage } from "./provider-cc_62eQE.js";
+import { p as summarizeCodexAccountUsage } from "./provider-zjPfx5Fs.js";
 import { y as resolveCodexAppServerAuthProfileIdForAgent } from "./shared-client-4ICy3U6d.js";
-import { a as reclaimCurrentCodexSessionGeneration, i as normalizeCodexAppServerBindingModelProvider, n as bindingStoreKey, o as sessionBindingIdentity } from "./session-binding-Dc03iwRF.js";
-import { r as CODEX_CONTROL_METHODS } from "./plugin-app-cache-key-o-AHbdaf.js";
-import { a as formatCodexDisplayText, c as formatList, d as formatThreads, f as readString$1, i as formatAccount, l as formatModels, o as formatCodexStatus, r as buildHelp, s as formatComputerUseStatus, u as formatSkills } from "./app-server-policy-BUk0GLMy.js";
+import { a as normalizeCodexAppServerBindingModelProvider, n as bindingStoreKey, o as reclaimCurrentCodexSessionGeneration, s as sessionBindingIdentity } from "./session-binding-C1ZXdP-x.js";
+import { r as CODEX_CONTROL_METHODS } from "./plugin-app-cache-key-BrhVdeEf.js";
+import { a as formatCodexDisplayText, c as formatList, d as formatThreads, f as readString$1, i as formatAccount, l as formatModels, o as formatCodexStatus, r as buildHelp, s as formatComputerUseStatus, u as formatSkills } from "./app-server-policy-C968Kgin.js";
 import { n as resolveCodexNativeExecutionBlock, r as resolveCodexNativeSandboxBlock } from "./sandbox-guard-DA2TQfZW.js";
-import { S as canMutateCodexHost, _ as setCodexConversationPermissions, d as formatPermissionsMode, f as parseCodexFastModeArg, g as setCodexConversationModel, h as setCodexConversationFastMode, i as safeCodexControlRequest, m as readCodexConversationActiveTurn, n as readCodexStatusProbes, p as parseCodexPermissionsModeArg, r as requestOptions, s as formatCodexCliSessions, t as codexControlRequest, v as steerCodexConversationTurn, x as CODEX_NATIVE_EXECUTION_AUTH_ERROR, y as stopCodexConversationTurn } from "./command-rpc-BjgEPh19.js";
+import { S as canMutateCodexHost, _ as setCodexConversationPermissions, d as formatPermissionsMode, f as parseCodexFastModeArg, g as setCodexConversationModel, h as setCodexConversationFastMode, i as safeCodexControlRequest, m as readCodexConversationActiveTurn, n as readCodexStatusProbes, p as parseCodexPermissionsModeArg, r as requestOptions, s as formatCodexCliSessions, t as codexControlRequest, v as steerCodexConversationTurn, x as CODEX_NATIVE_EXECUTION_AUTH_ERROR, y as stopCodexConversationTurn } from "./command-rpc-eLM_mtC7.js";
 import { i as readCodexConversationBindingData, n as createCodexCliNodeConversationBindingData, o as resolveCodexDefaultWorkspaceDir, r as createCodexConversationBindingData } from "./conversation-binding-data-BHRpYbX3.js";
-import { n as installCodexComputerUse, r as readCodexComputerUseStatus } from "./computer-use-DDeySrnb.js";
+import { n as installCodexComputerUse, r as readCodexComputerUseStatus } from "./computer-use-Bmaz333N.js";
 import { parseStrictPositiveInteger } from "openclaw/plugin-sdk/number-runtime";
 import crypto from "node:crypto";
 import { ensureAuthProfileStore, findNormalizedProviderValue, resolveAgentDir, resolveAuthProfileEligibility, resolveAuthProfileOrder, resolveDefaultAgentDir, resolveProfileUnusableUntilForDisplay, resolveSessionAgentIds } from "openclaw/plugin-sdk/agent-runtime";

package/dist/{command-rpc-BjgEPh19.js → command-rpc-eLM_mtC7.js}

@@ -1,10 +1,10 @@
 import { d as resolveCodexAppServerRuntimeOptions, m as resolveCodexModelBackedReviewerPolicyContext, o as isCodexFastServiceTier } from "./config-CYEDnLJ2.js";
 import { n as listCodexAppServerModels } from "./models-DDmO1zwd.js";
-import { d as resolveCodexAppServerRequestModelSelection, p as resolveCodexBindingModelProviderFallback } from "./thread-lifecycle-BskXnNP-.js";
+import { f as resolveCodexAppServerRequestModelSelection, m as resolveCodexBindingModelProviderFallback } from "./thread-lifecycle-qWE88Dn2.js";
 import { a as getLeasedSharedCodexAppServerClient, o as releaseLeasedSharedCodexAppServerClient } from "./shared-client-4ICy3U6d.js";
-import { i as normalizeCodexAppServerBindingModelProvider, n as bindingStoreKey, r as isCodexAppServerNativeAuthProfile } from "./session-binding-Dc03iwRF.js";
-import { i as describeControlFailure, r as CODEX_CONTROL_METHODS } from "./plugin-app-cache-key-o-AHbdaf.js";
-import { a as formatCodexDisplayText } from "./app-server-policy-BUk0GLMy.js";
+import { a as normalizeCodexAppServerBindingModelProvider, i as isCodexAppServerNativeAuthProfile, n as bindingStoreKey } from "./session-binding-C1ZXdP-x.js";
+import { i as describeControlFailure, r as CODEX_CONTROL_METHODS } from "./plugin-app-cache-key-BrhVdeEf.js";
+import { a as formatCodexDisplayText } from "./app-server-policy-C968Kgin.js";
 import { t as requestCodexAppServerJson } from "./request-BcJyl8KL.js";
 import fs from "node:fs/promises";
 import path from "node:path";

package/dist/{compact-CZzbcygx.js → compact-4mVBriKT.js}

@@ -2,7 +2,7 @@ import { r as isJsonObject } from "./protocol-2POPqAY4.js";
 import { _ as readCodexNotificationItem } from "./attempt-notifications-BGsEIIDI.js";
 import { d as resolveCodexAppServerRuntimeOptions } from "./config-CYEDnLJ2.js";
 import { a as getLeasedSharedCodexAppServerClient, o as releaseLeasedSharedCodexAppServerClient, u as CodexAppServerRpcError } from "./shared-client-4ICy3U6d.js";
-import { o as sessionBindingIdentity, t as CODEX_APP_SERVER_BINDING_GUARDED_REQUEST_TIMEOUT_MS } from "./session-binding-Dc03iwRF.js";
+import { s as sessionBindingIdentity, t as CODEX_APP_SERVER_BINDING_GUARDED_REQUEST_TIMEOUT_MS } from "./session-binding-C1ZXdP-x.js";
 import { n as resolveCodexNativeExecutionBlock } from "./sandbox-guard-DA2TQfZW.js";
 import { n as readCodexNotificationThreadId, r as readCodexNotificationTurnId } from "./notification-correlation-Bo7KB3ks.js";
 import { embeddedAgentLog, resolveCompactionTimeoutMs } from "openclaw/plugin-sdk/agent-harness-runtime";

package/dist/{computer-use-DDeySrnb.js → computer-use-Bmaz333N.js}

@@ -1,5 +1,5 @@
 import { d as resolveCodexAppServerRuntimeOptions, p as resolveCodexComputerUseConfig } from "./config-CYEDnLJ2.js";
-import { i as describeControlFailure } from "./plugin-app-cache-key-o-AHbdaf.js";
+import { i as describeControlFailure } from "./plugin-app-cache-key-BrhVdeEf.js";
 import { t as requestCodexAppServerJson } from "./request-BcJyl8KL.js";
 import { existsSync } from "node:fs";
 //#region extensions/codex/src/app-server/computer-use.ts

package/dist/doctor-contract-api.js

@@ -88,20 +88,58 @@ async function collectLegacyBindingSources(params, options = {}) {
 		surfaces
 	};
 }
+async function readLegacySessionIndex(storePath) {
+	let contents;
+	try {
+		contents = await fs.readFile(storePath, "utf8");
+	} catch (error) {
+		const code = error.code;
+		return code === "ENOENT" ? { entries: [] } : { failure: `session index ${storePath} could not be read${code ? ` (${code})` : ""}` };
+	}
+	let raw;
+	try {
+		raw = JSON.parse(contents);
+	} catch {
+		return { failure: `session index ${storePath} could not be read (invalid JSON)` };
+	}
+	if (!isRecord(raw)) return { failure: `session index ${storePath} has invalid entries` };
+	let normalizedEntries;
+	try {
+		normalizedEntries = listSessionEntries({
+			storePath,
+			hydrateSkillPromptRefs: false
+		});
+	} catch {
+		return { failure: `session index ${storePath} could not be normalized` };
+	}
+	const normalizedByKey = new Map(normalizedEntries.map(({ sessionKey, entry }) => [sessionKey, entry]));
+	const entries = [];
+	for (const [sessionKey, value] of Object.entries(raw)) {
+		if (!isRecord(value)) return { failure: `session index ${storePath} has invalid entries` };
+		if (value.sessionId === void 0) continue;
+		const rawSessionId = typeof value.sessionId === "string" ? value.sessionId.trim() : "";
+		const sessionId = normalizedByKey.get(sessionKey)?.sessionId?.trim() ?? "";
+		const sessionFile = value.sessionFile;
+		const lifecycleRevision = value.lifecycleRevision;
+		const agentHarnessId = value.agentHarnessId;
+		if (!sessionId || sessionId !== rawSessionId || sessionFile !== void 0 && typeof sessionFile !== "string" || lifecycleRevision !== void 0 && typeof lifecycleRevision !== "string" || agentHarnessId !== void 0 && typeof agentHarnessId !== "string") return { failure: `session index ${storePath} has invalid entries` };
+		entries.push({
+			sessionKey,
+			entry: {
+				sessionId,
+				...typeof sessionFile === "string" ? { sessionFile } : {},
+				...typeof lifecycleRevision === "string" ? { lifecycleRevision } : {},
+				...typeof agentHarnessId === "string" ? { agentHarnessId } : {}
+			}
+		});
+	}
+	return { entries };
+}
 async function* iterateIndexedSidecars(surface, params) {
 	for (const storePath of surface.storePaths) {
-		let entries;
-		try {
-			entries = listSessionEntries({
-				storePath,
-				hydrateSkillPromptRefs: false
-			});
-		} catch {
-			continue;
-		}
-		for (const { sessionKey, entry } of entries) {
-			const sessionId = entry.sessionId?.trim();
-			if (!sessionId) continue;
+		const index = await readLegacySessionIndex(storePath);
+		if ("failure" in index) continue;
+		for (const { sessionKey, entry } of index.entries) {
 			const agentId = resolveLegacyBindingOwnerAgentId({
 				sessionKey,
 				config: params.config,
@@ -109,7 +147,7 @@ async function* iterateIndexedSidecars(surface, params) {
 			});
 			let transcriptPath;
 			try {
-				transcriptPath = resolveSessionFilePath(sessionId, entry, {
+				transcriptPath = resolveSessionFilePath(entry.sessionId, entry, {
 					sessionsDir: path.dirname(storePath),
 					agentId
 				});
@@ -149,55 +187,57 @@ async function collectBindingOwners(sources, surfaces, params) {
 		for (const agentId of surface.agentIds) agents.add(agentId);
 		storeAgentIds.set(storePath, agents);
 	}
+	const failures = [];
 	for (const storePath of storePaths) {
-		let entries;
-		try {
-			entries = listSessionEntries({
-				storePath,
-				hydrateSkillPromptRefs: false
-			});
-		} catch {
+		const canonicalStorePath = await canonicalizePath(storePath);
+		const index = await readLegacySessionIndex(storePath);
+		if ("failure" in index) {
+			failures.push(index.failure);
 			continue;
 		}
 		const sessionsDir = path.dirname(storePath);
-		for (const { sessionKey, entry } of entries) {
-			const sessionId = entry.sessionId?.trim();
-			if (!sessionId) continue;
+		for (const { sessionKey, entry } of index.entries) {
+			const sessionId = entry.sessionId;
 			const agentId = resolveLegacyBindingOwnerAgentId({
 				sessionKey,
 				config: params.config,
 				storeAgentIds: storeAgentIds.get(storePath)
 			});
-			let transcriptPath;
-			let legacyTranscriptPath;
+			let effectiveTranscriptPath;
 			try {
-				legacyTranscriptPath = resolveLegacySessionFileLocator(sessionsDir, entry, sessionId);
-				transcriptPath = await canonicalizePath(resolveSessionFilePath(sessionId, entry, {
+				effectiveTranscriptPath = resolveSessionFilePath(sessionId, entry, {
 					sessionsDir,
 					agentId
-				}));
+				});
 			} catch {
+				failures.push(`session index ${storePath} has an invalid locator for ${sessionKey}`);
 				continue;
 			}
+			const transcriptPath = await canonicalizePath(effectiveTranscriptPath);
 			if (!sourcePaths.has(transcriptPath)) continue;
 			const owner = {
 				agentId,
 				sessionId,
 				sessionKey,
 				storePath,
-				transcriptPath: legacyTranscriptPath,
+				transcriptPath: effectiveTranscriptPath,
+				...entry.lifecycleRevision ? { lifecycleRevision: entry.lifecycleRevision } : {},
 				...entry.agentHarnessId?.trim() ? { agentHarnessId: entry.agentHarnessId.trim() } : {}
 			};
 			const candidates = owners.get(transcriptPath) ?? /* @__PURE__ */ new Map();
-			candidates.set(`${agentId}\0${sessionId}\0${sessionKey}\0${storePath}`, owner);
+			const ownerKey = `${agentId}\0${sessionId}\0${sessionKey}\0${canonicalStorePath}`;
+			const configuredStorePath = resolveStorePath(params.config.session?.store, {
+				agentId,
+				env: params.env
+			});
+			if (!candidates.has(ownerKey) || storePath === configuredStorePath) candidates.set(ownerKey, owner);
 			owners.set(transcriptPath, candidates);
 		}
 	}
-	return new Map([...owners].map(([key, values]) => [key, [...values.values()]]));
-}
-function resolveLegacySessionFileLocator(sessionsDir, entry, sessionId) {
-	const sessionFile = entry.sessionFile?.trim();
-	return path.resolve(sessionsDir, sessionFile || `${sessionId}.jsonl`);
+	return {
+		owners: new Map([...owners].map(([key, values]) => [key, [...values.values()]])),
+		failures
+	};
 }
 function resolveLegacyBindingOwnerAgentId(params) {
 	if (params.sessionKey.trim().toLowerCase().startsWith("agent:")) return resolveSessionAgentIds({
@@ -224,18 +264,19 @@ function copyBindingForSession(stored, sessionId) {
 		...stored.retired ? { retired: true } : {}
 	};
 }
-async function migrateSource(source, owner, params, store) {
+async function migrateSource(source, candidates, params, store) {
 	let importedKeys = 0;
 	const retain = (reason) => ({
 		archived: false,
 		importedKeys,
 		warning: `Left Codex binding sidecar in place because ${reason}: ${source.sidecarPath}`
 	});
+	const owner = candidates.length === 1 ? candidates[0] : void 0;
 	try {
 		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, readCodexAppServerThreadBinding }, { legacyCodexConversationBindingId }] = await Promise.all([import("./session-binding-Dc03iwRF.js").then((n) => n.s), import("./conversation-binding-data-BHRpYbX3.js").then((n) => n.t)]);
+			const [{ bindingStoreKey, createStoredCodexAppServerBinding, normalizeStoredCodexAppServerBindingFingerprints, readStoredCodexAppServerBinding }, { legacyCodexConversationBindingId }] = await Promise.all([import("./session-binding-C1ZXdP-x.js").then((n) => n.c), import("./conversation-binding-data-BHRpYbX3.js").then((n) => n.t)]);
 			const agentId = owner?.agentId ?? (source.agentIds.size === 1 ? [...source.agentIds][0] : void 0);
 			const baseStored = createStoredCodexAppServerBinding(raw, {
 				now: stat.mtime.toISOString(),
@@ -245,6 +286,7 @@ async function migrateSource(source, owner, 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 && owner.agentHarnessId !== CODEX_AGENT_HARNESS_ID) return retain(`its session is owned by agent harness ${owner.agentHarnessId}`);
 			const sourceSessionFile = typeof raw.sessionFile === "string" && raw.sessionFile.trim() ? raw.sessionFile : source.transcriptPath;
 			const ownerSessionFile = typeof raw.sessionFile === "string" && raw.sessionFile.trim() ? raw.sessionFile : owner?.transcriptPath;
@@ -252,67 +294,137 @@ async function migrateSource(source, owner, params, store) {
 				kind: "conversation",
 				bindingId: legacyCodexConversationBindingId(sessionFile)
 			}));
+			const normalizeStoredRow = async (key, current) => {
+				const parsed = readStoredCodexAppServerBinding(current);
+				if (!parsed) return { warning: `canonical plugin state is invalid at ${key}` };
+				const normalized = normalizeStoredCodexAppServerBindingFingerprints(parsed);
+				if (!normalized) return { warning: `canonical plugin state is invalid at ${key}` };
+				if (isDeepStrictEqual(parsed, normalized)) return { value: parsed };
+				if (parsed.lease && parsed.lease.expiresAt > Date.now()) return { warning: `canonical plugin state is leased at ${key}` };
+				const update = store.update;
+				if (!update) return { warning: `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;
+				});
+				const persisted = readStoredCodexAppServerBinding(await store.lookup(key));
+				if (!persisted || !isDeepStrictEqual(persisted, normalized)) return { warning: `canonical plugin state changed at ${key}` };
+				importedKeys++;
+				return { value: normalized };
+			};
 			let currentConversation;
-			for (const key of conversationKeys) currentConversation ??= await store.lookup(key);
+			for (const key of conversationKeys) {
+				const current = await store.lookup(key);
+				if (current === void 0) continue;
+				const result = await normalizeStoredRow(key, current);
+				if (result.warning || !result.value) return retain(result.warning ?? `canonical plugin state is invalid at ${key}`);
+				currentConversation ??= result.value;
+			}
 			const stored = currentConversation ?? baseStored;
-			if (stored.state !== "active" && stored.state !== "cleared") return retain(`canonical plugin state changed at ${conversationKeys[0]}`);
 			const sessionKey = owner ? bindingStoreKey({
 				kind: "session",
 				agentId: owner.agentId,
 				sessionId: owner.sessionId,
 				sessionKey: owner.sessionKey
 			}) : void 0;
-			const entries = [...conversationKeys.map((key) => ({
+			const conversationEntries = conversationKeys.map((key) => ({
 				key,
 				value: stored
-			})), ...owner && sessionKey ? [{
+			}));
+			const sessionEntry = owner && sessionKey ? {
 				key: sessionKey,
 				value: copyBindingForSession(stored, owner.sessionId)
-			}] : []];
-			const hasExpected = (value, expected) => expected.state === "cleared" ? value?.state === "cleared" && value.sessionId === expected.sessionId && value.retired === expected.retired : value?.state === "active" && value.sessionId === expected.sessionId && isDeepStrictEqual(readCodexAppServerThreadBinding(value.binding), expected.binding);
+			} : void 0;
+			const entries = [...conversationEntries, ...sessionEntry ? [sessionEntry] : []];
+			const hasExpected = (value, target) => {
+				const parsed = readStoredCodexAppServerBinding(value);
+				if (!parsed) return false;
+				return target.state === "cleared" ? parsed.state === "cleared" && parsed.sessionId === target.sessionId && parsed.retired === target.retired : parsed.state === "active" && parsed.sessionId === target.sessionId && isDeepStrictEqual(parsed.binding, target.binding);
+			};
 			for (const entry of entries) {
 				const current = await store.lookup(entry.key);
-				if (current !== void 0 && !hasExpected(current, entry.value)) return retain(`canonical plugin state changed at ${entry.key}`);
+				if (current === void 0) continue;
+				const result = await normalizeStoredRow(entry.key, current);
+				if (result.warning || !result.value) return retain(result.warning ?? `canonical plugin state is invalid at ${entry.key}`);
+				if (!hasExpected(result.value, entry.value)) return retain(`canonical 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 (!owner) return {
-				archived: false,
-				importedKeys,
-				warning: `Left Codex binding sidecar in place after importing its conversation binding because its session owner could not be resolved: ${source.sidecarPath}`
-			};
-			const ownershipWarning = await recordSessionOwner(owner);
-			if (ownershipWarning) return retain(ownershipWarning);
-			for (const entry of entries) if (!hasExpected(await store.lookup(entry.key), entry.value)) return retain(`canonical plugin state changed at ${entry.key}`);
-			const archivePath = `${source.sidecarPath}.migrated`;
-			if (await pathExists(archivePath)) return retain(`its archive already exists at ${archivePath}`);
-			await fs.rename(source.sidecarPath, archivePath);
+			if (owner) {
+				const ownershipWarning = await recordSessionOwner(owner);
+				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 {
+								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`);
+					}
+					return retain(ownershipWarning);
+				}
+				for (const entry of entries) if (!hasExpected(await store.lookup(entry.key), entry.value)) return retain(`canonical plugin state changed at ${entry.key}`);
+			}
+			await archiveBindingSidecar(source.sidecarPath);
 			return {
 				archived: true,
 				importedKeys
 			};
 		});
 	} catch (error) {
+		if (error.code === "ENOENT" && !await pathExists(source.sidecarPath)) return {
+			archived: true,
+			importedKeys
+		};
 		return retain(`migration or archiving failed: ${String(error)}`);
 	}
 }
 async function recordSessionOwner(owner) {
+	let observedForeignHarness;
 	const updated = await updateSessionStoreEntry({
 		storePath: owner.storePath,
 		sessionKey: owner.sessionKey,
 		skipMaintenance: true,
 		requireWriteSuccess: true,
 		update: (entry) => {
-			if (entry.sessionId.trim() !== owner.sessionId) return null;
-			return entry.agentHarnessId?.trim() ? null : { agentHarnessId: CODEX_AGENT_HARNESS_ID };
+			const transcriptPath = resolveOwnerTranscriptPath(owner, entry);
+			if (entry.sessionId.trim() !== owner.sessionId || transcriptPath !== owner.transcriptPath || entry.lifecycleRevision !== owner.lifecycleRevision) return null;
+			const harnessId = typeof entry.agentHarnessId === "string" ? entry.agentHarnessId.trim() : void 0;
+			if (entry.agentHarnessId !== void 0 && harnessId === void 0) return null;
+			if (harnessId && harnessId !== CODEX_AGENT_HARNESS_ID) {
+				observedForeignHarness = harnessId;
+				return null;
+			}
+			return { agentHarnessId: CODEX_AGENT_HARNESS_ID };
 		}
 	});
-	if (!updated || updated.sessionId.trim() !== owner.sessionId) return "its session owner changed before Codex ownership could be recorded";
+	if (!updated) return observedForeignHarness ? `its session is owned by agent harness ${observedForeignHarness}` : "its session owner changed before Codex ownership could be recorded";
+	const transcriptPath = resolveOwnerTranscriptPath(owner, updated);
+	if (updated.sessionId.trim() !== owner.sessionId || transcriptPath !== owner.transcriptPath || 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";
 }
+function resolveOwnerTranscriptPath(owner, entry) {
+	try {
+		return resolveSessionFilePath(entry.sessionId, entry, {
+			sessionsDir: path.dirname(owner.storePath),
+			agentId: owner.agentId
+		});
+	} catch {
+		return;
+	}
+}
 async function readDirectoryEntries(directory) {
 	try {
 		return await fs.readdir(directory, { withFileTypes: true });
@@ -333,6 +445,9 @@ async function isRegularFile(filePath) {
 		return false;
 	}
 }
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
 function isPathWithin(root, candidate) {
 	const relative = path.relative(root, candidate);
 	return relative === "" || relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
@@ -352,6 +467,25 @@ async function pathExists(filePath) {
 		return false;
 	}
 }
+async function firstFreeArchivePath(sourcePath) {
+	for (let index = 2;; index++) {
+		const candidate = `${sourcePath}.migrated.${index}`;
+		if (!await pathExists(candidate)) return candidate;
+	}
+}
+async function archiveBindingSidecar(sourcePath) {
+	const archivePath = `${sourcePath}.migrated`;
+	if (await pathExists(archivePath)) {
+		const [sourceBytes, archiveBytes] = await Promise.all([fs.readFile(sourcePath), fs.readFile(archivePath)]);
+		if (sourceBytes.equals(archiveBytes)) {
+			await fs.rm(sourcePath, { force: true });
+			return;
+		}
+		await fs.rename(sourcePath, await firstFreeArchivePath(sourcePath));
+		return;
+	}
+	await fs.rename(sourcePath, archivePath);
+}
 const stateMigrations = [{
 	id: "codex-app-server-sidecars-to-plugin-state",
 	label: "Codex app-server thread bindings",
@@ -367,7 +501,14 @@ const stateMigrations = [{
 			changes,
 			warnings
 		};
-		const owners = await collectBindingOwners(sources, surfaces, params);
+		const ownerCollection = await collectBindingOwners(sources, surfaces, params);
+		if (ownerCollection.failures.length > 0) {
+			warnings.push(`Left ${sources.length} Codex binding sidecar(s) in place because session ownership is indeterminate: ${ownerCollection.failures.join("; ")}`);
+			return {
+				changes,
+				warnings
+			};
+		}
 		const store = params.context.openPluginStateKeyedStore({
 			namespace: CODEX_APP_SERVER_BINDING_NAMESPACE,
 			maxEntries: CODEX_APP_SERVER_BINDING_MAX_ENTRIES,
@@ -376,8 +517,7 @@ const stateMigrations = [{
 		let migrated = 0;
 		let partialImports = 0;
 		for (const source of sources) {
-			const candidates = owners.get(await canonicalizePath(source.transcriptPath)) ?? [];
-			const result = await migrateSource(source, candidates.length === 1 ? candidates[0] : void 0, params, store);
+			const result = await migrateSource(source, ownerCollection.owners.get(await canonicalizePath(source.transcriptPath)) ?? [], params, store);
 			if (result.warning) warnings.push(result.warning);
 			if (result.archived) migrated++;
 			else partialImports += result.importedKeys;

package/dist/harness.js

@@ -32,7 +32,7 @@ function createCodexAppServerAgentHarness(options) {
 			};
 		},
 		runAttempt: async (params) => {
-			const { runCodexAppServerAttempt } = await import("./run-attempt-8SPLiDlT.js");
+			const { runCodexAppServerAttempt } = await import("./run-attempt-FUyOjGCV.js");
 			return runCodexAppServerAttempt(params, {
 				bindingStore: options.bindingStore,
 				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig,
@@ -40,7 +40,7 @@ function createCodexAppServerAgentHarness(options) {
 			});
 		},
 		runSideQuestion: async (params) => {
-			const { runCodexAppServerSideQuestion } = await import("./side-question-DkjXvYv7.js");
+			const { runCodexAppServerSideQuestion } = await import("./side-question-N4OaDer2.js");
 			return runCodexAppServerSideQuestion(params, {
 				bindingStore: options.bindingStore,
 				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig,
@@ -48,14 +48,14 @@ function createCodexAppServerAgentHarness(options) {
 			});
 		},
 		compact: async (params) => {
-			const { maybeCompactCodexAppServerSession } = await import("./compact-CZzbcygx.js");
+			const { maybeCompactCodexAppServerSession } = await import("./compact-4mVBriKT.js");
 			return maybeCompactCodexAppServerSession(params, {
 				bindingStore: options.bindingStore,
 				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig
 			});
 		},
 		compactAfterContextEngine: async (params) => {
-			const { maybeCompactCodexAppServerSession } = await import("./compact-CZzbcygx.js");
+			const { maybeCompactCodexAppServerSession } = await import("./compact-4mVBriKT.js");
 			return maybeCompactCodexAppServerSession(params, {
 				bindingStore: options.bindingStore,
 				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig,
@@ -64,7 +64,7 @@ function createCodexAppServerAgentHarness(options) {
 		},
 		reset: async (params) => {
 			if (params.sessionId) {
-				const { reclaimCurrentCodexSessionGeneration, sessionBindingIdentity } = await import("./session-binding-Dc03iwRF.js").then((n) => n.s);
+				const { reclaimCurrentCodexSessionGeneration, sessionBindingIdentity } = await import("./session-binding-C1ZXdP-x.js").then((n) => n.c);
 				const identity = sessionBindingIdentity({
 					agentId: params.agentId,
 					sessionId: params.sessionId,

package/dist/index.js

@@ -2,16 +2,16 @@ import { createCodexAppServerAgentHarness } from "./harness.js";
 import { r as isJsonObject, t as CODEX_INTERACTIVE_THREAD_SOURCE_KINDS } from "./protocol-2POPqAY4.js";
 import { d as resolveCodexAppServerRuntimeOptions, g as resolveOpenClawExecPolicyForCodexAppServer, i as codexSandboxPolicyForTurn, n as canUseCodexModelBackedApprovalsReviewerForModel, t as CODEX_PLUGINS_MARKETPLACE_NAME, u as readCodexPluginConfig } from "./config-CYEDnLJ2.js";
 import { r as assertCodexThreadStartResponse } from "./protocol-validators-dZQ-UTOa.js";
-import { K as defaultCodexAppInventoryCache, U as ensureCodexPluginActivation, W as pluginReadParams, d as resolveCodexAppServerRequestModelSelection, t as CODEX_NATIVE_PERSONALITY_NONE } from "./thread-lifecycle-BskXnNP-.js";
-import { t as buildCodexProvider } from "./provider-cc_62eQE.js";
+import { G as pluginReadParams, W as ensureCodexPluginActivation, f as resolveCodexAppServerRequestModelSelection, q as defaultCodexAppInventoryCache, t as CODEX_NATIVE_PERSONALITY_NONE } from "./thread-lifecycle-qWE88Dn2.js";
+import { t as buildCodexProvider } from "./provider-zjPfx5Fs.js";
 import { _ as resolveCodexAppServerAuthAccountCacheKey, a as getLeasedSharedCodexAppServerClient, b as resolveCodexAppServerFallbackApiKeyCacheKey, o as releaseLeasedSharedCodexAppServerClient, r as clearSharedCodexAppServerClientIfCurrentAndWait, y as resolveCodexAppServerAuthProfileIdForAgent } from "./shared-client-4ICy3U6d.js";
 import { n as CODEX_APP_SERVER_BINDING_NAMESPACE, t as CODEX_APP_SERVER_BINDING_MAX_ENTRIES } from "./session-binding-meta-B7aEMU7g.js";
-import { i as normalizeCodexAppServerBindingModelProvider, o as sessionBindingIdentity, r as isCodexAppServerNativeAuthProfile } from "./session-binding-Dc03iwRF.js";
-import { t as buildCodexMediaUnderstandingProvider } from "./media-understanding-provider-DgqRvU2_.js";
-import { i as describeControlFailure, n as buildCodexPluginAppCacheKey, r as CODEX_CONTROL_METHODS } from "./plugin-app-cache-key-o-AHbdaf.js";
-import { a as formatCodexDisplayText, t as resolveCodexAppServerForModelProvider } from "./app-server-policy-BUk0GLMy.js";
+import { a as normalizeCodexAppServerBindingModelProvider, i as isCodexAppServerNativeAuthProfile, s as sessionBindingIdentity } from "./session-binding-C1ZXdP-x.js";
+import { t as buildCodexMediaUnderstandingProvider } from "./media-understanding-provider-BHOu9-Gg.js";
+import { i as describeControlFailure, n as buildCodexPluginAppCacheKey, r as CODEX_CONTROL_METHODS } from "./plugin-app-cache-key-BrhVdeEf.js";
+import { a as formatCodexDisplayText, t as resolveCodexAppServerForModelProvider } from "./app-server-policy-C968Kgin.js";
 import { n as resolveCodexNativeExecutionBlock, r as resolveCodexNativeSandboxBlock } from "./sandbox-guard-DA2TQfZW.js";
-import { S as canMutateCodexHost, a as createCodexCliSessionNodeHostCommands, b as trackCodexConversationActiveTurn, c as listCodexCliSessionsOnNode, l as resolveCodexCliSessionForBindingOnNode, o as createCodexCliSessionNodeInvokePolicies, t as codexControlRequest, u as resumeCodexCliSessionOnNode, x as CODEX_NATIVE_EXECUTION_AUTH_ERROR } from "./command-rpc-BjgEPh19.js";
+import { S as canMutateCodexHost, a as createCodexCliSessionNodeHostCommands, b as trackCodexConversationActiveTurn, c as listCodexCliSessionsOnNode, l as resolveCodexCliSessionForBindingOnNode, o as createCodexCliSessionNodeInvokePolicies, t as codexControlRequest, u as resumeCodexCliSessionOnNode, x as CODEX_NATIVE_EXECUTION_AUTH_ERROR } from "./command-rpc-eLM_mtC7.js";
 import { a as readCodexConversationBindingDataRecord, i as readCodexConversationBindingData } from "./conversation-binding-data-BHRpYbX3.js";
 import { n as readCodexNotificationThreadId, r as readCodexNotificationTurnId } from "./notification-correlation-Bo7KB3ks.js";
 import { t as requestCodexAppServerJson } from "./request-BcJyl8KL.js";
@@ -43,7 +43,7 @@ import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 /** Defers schema compilation and auth loading until the first binding operation. */
 function createLazyCodexAppServerBindingStore(state) {
 	let resolved;
-	const store = () => resolved ??= import("./session-binding-Dc03iwRF.js").then((n) => n.s).then(({ createCodexAppServerBindingStore }) => createCodexAppServerBindingStore(state));
+	const store = () => resolved ??= import("./session-binding-C1ZXdP-x.js").then((n) => n.c).then(({ createCodexAppServerBindingStore }) => createCodexAppServerBindingStore(state));
 	return {
 		read: async (identity) => (await store()).read(identity),
 		mutate: async (identity, mutation) => (await store()).mutate(identity, mutation),
@@ -86,7 +86,7 @@ async function handleCodexCommand(ctx, options) {
 	}
 }
 async function loadDefaultCodexSubcommandHandler() {
-	const { handleCodexSubcommand } = await import("./command-handlers-UVniG5Hl.js");
+	const { handleCodexSubcommand } = await import("./command-handlers-Dv-pzAmg.js");
 	return handleCodexSubcommand;
 }
 //#endregion
@@ -914,7 +914,7 @@ async function readJsonObject(filePath) {
 //#endregion
 //#region extensions/codex/src/migration/auth.ts
 const OPENAI_PROVIDER_ID = "openai";
-const OPENAI_CODEX_DEFAULT_MODEL = "openai/gpt-5.5";
+const OPENAI_CODEX_DEFAULT_MODEL = "openai/gpt-5.6-sol";
 const CODEX_IMPORT_DISPLAY_NAME = "Codex import";
 const CODEX_REASON_AUTH_NOT_SELECTED = "auth credential migration not selected";
 const CODEX_REASON_AUTH_PROFILE_EXISTS = "auth profile exists";
@@ -2583,7 +2583,7 @@ function createCodexThreadsTool(options) {
 }
 //#endregion
 //#region extensions/codex/src/web-search-provider.ts
-const loadCodexWebSearchRuntime = createLazyRuntimeModule(() => import("./web-search-provider.runtime-B5F42P7x.js"));
+const loadCodexWebSearchRuntime = createLazyRuntimeModule(() => import("./web-search-provider.runtime-BSlriav6.js"));
 const CodexWebSearchSchema = {
 	type: "object",
 	properties: { query: {
@@ -2726,7 +2726,7 @@ var codex_default = definePluginEntry({
 			if (!previousSessionId || !sessionId || previousSessionId === sessionId) return;
 			const config = resolveCurrentConfig();
 			const sessionKey = ctx.sessionKey?.trim();
-			const { sessionBindingIdentity } = await import("./session-binding-Dc03iwRF.js").then((n) => n.s);
+			const { sessionBindingIdentity } = await import("./session-binding-C1ZXdP-x.js").then((n) => n.c);
 			const identity = sessionBindingIdentity({
 				sessionId,
 				...sessionKey ? { sessionKey } : {},
@@ -2740,7 +2740,7 @@ var codex_default = definePluginEntry({
 			if (!event.reason || !ENDED_SESSION_REASONS.has(event.reason)) return;
 			const sessionKey = event.sessionKey ?? ctx.sessionKey;
 			const config = resolveCurrentConfig();
-			const { sessionBindingIdentity } = await import("./session-binding-Dc03iwRF.js").then((n) => n.s);
+			const { sessionBindingIdentity } = await import("./session-binding-C1ZXdP-x.js").then((n) => n.c);
 			await bindingStore.retireSessionGeneration(sessionBindingIdentity({
 				sessionId: event.sessionId,
 				...sessionKey ? { sessionKey } : {},

package/dist/{media-understanding-provider-DgqRvU2_.js → media-understanding-provider-BHOu9-Gg.js}

@@ -4,7 +4,7 @@ import { _ as readCodexNotificationItem } from "./attempt-notifications-BGsEIIDI
 import { d as resolveCodexAppServerRuntimeOptions } from "./config-CYEDnLJ2.js";
 import { i as assertCodexTurnStartResponse, l as readCodexTurnCompletedNotification, o as readCodexErrorNotification, r as assertCodexThreadStartResponse } from "./protocol-validators-dZQ-UTOa.js";
 import { i as readModelListResult } from "./models-DDmO1zwd.js";
-import { V as mergeCodexThreadConfigs, r as buildCodexRuntimeThreadConfig } from "./thread-lifecycle-BskXnNP-.js";
+import { H as mergeCodexThreadConfigs, r as buildCodexRuntimeThreadConfig } from "./thread-lifecycle-qWE88Dn2.js";
 import { validateJsonSchemaValue } from "openclaw/plugin-sdk/json-schema-runtime";
 import fs from "node:fs/promises";
 import path from "node:path";

package/dist/media-understanding-provider.js

@@ -1,2 +1,2 @@
-import { t as buildCodexMediaUnderstandingProvider } from "./media-understanding-provider-DgqRvU2_.js";
+import { t as buildCodexMediaUnderstandingProvider } from "./media-understanding-provider-BHOu9-Gg.js";
 export { buildCodexMediaUnderstandingProvider };

package/dist/{plugin-app-cache-key-o-AHbdaf.js → plugin-app-cache-key-BrhVdeEf.js}

@@ -1,4 +1,4 @@
-import { G as buildCodexAppInventoryCacheKey } from "./thread-lifecycle-BskXnNP-.js";
+import { K as buildCodexAppInventoryCacheKey } from "./thread-lifecycle-qWE88Dn2.js";
 import { u as CodexAppServerRpcError, x as resolveCodexAppServerHomeDir } from "./shared-client-4ICy3U6d.js";
 import { createRequire } from "node:module";
 import { createHash } from "node:crypto";