@openclaw/codex 2026.9.7 → 2026.10.1-beta.1

package/dist/.setup/session-binding-record-BZB8RgcF.mjs

@@ -0,0 +1,179 @@
+import { a as matchesCodexNativeSubagentSubmissionOwner, h as codexNativeSubagentHistoryConnectionFingerprint, r as readNativePendingAssignments, s as readCodexNativeSubagentSubmissions, t as matchesNativeAssignmentLifecycle } from "./native-subagent-pending-assignments-BDqhOdJp.mjs";
+import { a as readStoredCodexAppServerBinding, t as legacyAppPolicyEntrySchema } from "./session-binding-record-codec-z4ZpDn6E.mjs";
+import { t as __exportAll } from "./session-binding-sidecars-BrdV95Fg.mjs";
+import { asOptionalRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { createHash } from "node:crypto";
+import { isDeepStrictEqual } from "node:util";
+import { AgentHarnessPreflightError } from "openclaw/plugin-sdk/agent-harness-registration";
+import { resolveSessionAgentIdsStrict } from "openclaw/plugin-sdk/agent-scope-runtime";
+//#region extensions/codex/src/app-server/session-binding-record.ts
+/** Generation-aware binding reads and ownership checks over the canonical persisted codec. */
+var session_binding_record_exports = /* @__PURE__ */ __exportAll({
+	CodexSupervisionBindingReplacementError: () => CodexSupervisionBindingReplacementError,
+	assertCodexBindingMayBeReplaced: () => assertCodexBindingMayBeReplaced,
+	bindingStoreKey: () => bindingStoreKey,
+	matchesCodexNativeSubagentSubmissionBinding: () => matchesCodexNativeSubagentSubmissionBinding,
+	ownsStoredSessionGeneration: () => ownsStoredSessionGeneration,
+	preserveCodexNativeSubagentSubmissions: () => preserveCodexNativeSubagentSubmissions,
+	preserveNativePendingAssignments: () => preserveNativePendingAssignments,
+	preserveNativeTaskImport: () => preserveNativeTaskImport,
+	readCurrentCodexAppServerBinding: () => readCurrentCodexAppServerBinding,
+	readCurrentCodexAppServerBindings: () => readCurrentCodexAppServerBindings,
+	readCurrentCodexNativeSubagentSubmissions: () => readCurrentCodexNativeSubagentSubmissions,
+	readCurrentNativePendingAssignments: () => readCurrentNativePendingAssignments,
+	readPluginAppPolicyContext: () => readPluginAppPolicyContext,
+	readStoredCodexAppServerBinding: () => readStoredCodexAppServerBinding,
+	sessionBindingIdentity: () => sessionBindingIdentity
+});
+/** Resolves the same agent scope OpenClaw uses for transcript/session ownership. */
+function sessionBindingIdentity(params) {
+	const { sessionAgentId } = resolveSessionAgentIdsStrict(params);
+	const sessionKey = params.sessionKey?.trim();
+	return {
+		kind: "session",
+		agentId: sessionAgentId,
+		sessionId: params.sessionId,
+		...sessionKey ? { sessionKey } : {}
+	};
+}
+/** Stable plugin-state key for one current binding owner. */
+function bindingStoreKey(identity) {
+	if (identity.kind === "session") {
+		const rawAgentId = identity.agentId.trim();
+		const sessionId = identity.sessionId.trim();
+		if (!rawAgentId) throw new Error("Codex app-server binding requires an agent id");
+		if (!sessionId) throw new Error("Codex app-server binding requires a session id");
+		const agentId = resolveSessionAgentIdsStrict({ agentId: rawAgentId }).sessionAgentId;
+		const sessionKey = identity.sessionKey?.trim();
+		if (sessionKey) return `session-key:${agentId}:${createHash("sha256").update(sessionKey).digest("base64url")}`;
+		return `session:${agentId}:${sessionId}`;
+	}
+	const bindingId = identity.bindingId.trim();
+	if (!bindingId) throw new Error("Codex app-server conversation binding requires a binding id");
+	return `conversation:${bindingId}`;
+}
+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. */
+function readCurrentCodexAppServerBinding(state, identity) {
+	const key = bindingStoreKey(identity);
+	return decodeCurrentCodexAppServerBinding(key, 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}`);
+	return stored?.state === "active" && ownsStoredSessionGeneration(identity, stored) ? stored.binding : void 0;
+}
+/** Acquire fresh rows off-thread; decode lazily to preserve caller failure ordering. */
+async function* readCurrentCodexAppServerBindings(state, identities) {
+	const lookupMany = state.lookupMany?.bind(state);
+	for (let offset = 0; offset < identities.length; offset += 1e4) {
+		const batch = identities.slice(offset, offset + 1e4);
+		let keys;
+		if (lookupMany) try {
+			keys = batch.map(bindingStoreKey);
+		} catch {}
+		if (!keys || !lookupMany) {
+			for (const identity of batch) {
+				const key = bindingStoreKey(identity);
+				yield decodeCurrentCodexAppServerBinding(key, await state.lookup(key), identity);
+			}
+			continue;
+		}
+		const values = await lookupMany(keys);
+		for (let index = 0; index < batch.length; index++) {
+			const value = values[index];
+			if (!value.ok) throw value.error;
+			yield decodeCurrentCodexAppServerBinding(keys[index], value.value, batch[index]);
+		}
+	}
+}
+function matchesCodexNativeSubagentSubmissionBinding(binding, owner) {
+	return binding.threadId === owner.parentThreadId && !binding.pendingSupervisionBranch && codexNativeSubagentHistoryConnectionFingerprint(binding) === owner.connectionFingerprint;
+}
+/** Unknown metadata stays opaque through ordinary binding writes. */
+function preserveCodexNativeSubagentSubmissions(currentBinding, nextBinding, value) {
+	return currentBinding.threadId === nextBinding.threadId && codexNativeSubagentHistoryConnectionFingerprint(currentBinding) === codexNativeSubagentHistoryConnectionFingerprint(nextBinding) && isDeepStrictEqual(currentBinding.pendingSupervisionBranch, nextBinding.pendingSupervisionBranch) ? value : void 0;
+}
+function readCurrentCodexNativeSubagentSubmissions(state, identity, owner) {
+	const stored = 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);
+	return (readNativePendingAssignments(stored?.nativeSubagentAssignments)?.assignments ?? []).filter((entry) => matchesNativeAssignmentLifecycle(entry.owner, owner));
+}
+function readCurrentNativeSubagentBinding(state, identity, owner) {
+	const key = bindingStoreKey(identity);
+	const raw = 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;
+	return stored;
+}
+function preserveNativeTaskImport(current) {
+	return current?.nativeSubagentTaskImport !== void 0 ? { nativeSubagentTaskImport: current.nativeSubagentTaskImport } : {};
+}
+/** Preserve inventory through native rotation, never across a connection-policy change. */
+function preserveNativePendingAssignments(current, next, value) {
+	return codexNativeSubagentHistoryConnectionFingerprint(current) === codexNativeSubagentHistoryConnectionFingerprint(next) && isDeepStrictEqual(current.pendingSupervisionBranch, next.pendingSupervisionBranch) ? value : void 0;
+}
+var CodexSupervisionBindingReplacementError = class extends Error {
+	constructor(threadId, operation) {
+		super(`Refusing to replace supervised Codex thread ${threadId} while ${operation}; its native user-home connection and model ownership must be preserved`);
+		this.name = "CodexSupervisionBindingReplacementError";
+	}
+};
+function assertCodexBindingMayBeReplaced(binding, operation, expected) {
+	if (expected) throw new AgentHarnessPreflightError(`Codex native model ownership prevents ${operation}. Continue or compact the original session in its native runtime, or create a new chat with a concrete model; the original binding was preserved.`);
+	if (binding?.connectionScope === "supervision") throw new CodexSupervisionBindingReplacementError(binding.threadId, operation);
+}
+function readPluginAppPolicyContext(value) {
+	const record = asOptionalRecord(value);
+	if (!record || typeof record.fingerprint !== "string") return;
+	const apps = asOptionalRecord(record.apps);
+	if (!apps) return;
+	const parsedApps = {};
+	for (const [appId, rawEntry] of Object.entries(apps)) {
+		const entry = asOptionalRecord(rawEntry);
+		if (!entry || "appId" in entry) return;
+		const parsed = legacyAppPolicyEntrySchema.safeParse(entry);
+		if (!parsed.success) return;
+		const validated = parsed.data;
+		const { destructiveApprovalMode } = validated;
+		const policy = {
+			allowDestructiveActions: validated.allowDestructiveActions,
+			...validated.allowOpenWorld !== void 0 ? { allowOpenWorld: validated.allowOpenWorld } : {},
+			...destructiveApprovalMode ? { destructiveApprovalMode } : {},
+			mcpServerNames: validated.mcpServerNames
+		};
+		if (validated.source === "account") parsedApps[appId] = {
+			source: "account",
+			appName: validated.appName,
+			...policy
+		};
+		else parsedApps[appId] = {
+			configKey: validated.configKey,
+			marketplaceName: validated.marketplaceName,
+			pluginName: validated.pluginName,
+			...policy
+		};
+	}
+	const parsedPluginAppIds = {};
+	const pluginAppIds = record.pluginAppIds === void 0 ? {} : asOptionalRecord(record.pluginAppIds);
+	if (!pluginAppIds) return;
+	for (const [configKey, appIds] of Object.entries(pluginAppIds)) {
+		if (!Array.isArray(appIds) || appIds.some((appId) => typeof appId !== "string")) return;
+		parsedPluginAppIds[configKey] = appIds;
+	}
+	return {
+		fingerprint: record.fingerprint,
+		apps: parsedApps,
+		pluginAppIds: parsedPluginAppIds
+	};
+}
+//#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 };

package/dist/.setup/session-binding-record-codec-z4ZpDn6E.mjs

@@ -0,0 +1,216 @@
+import { n as CODEX_PLUGIN_MARKETPLACE_NAME_PATTERN, t as normalizeCodexServiceTier } from "./service-tier-normalization-Cei89SW6.mjs";
+import { z } from "zod";
+//#region extensions/codex/src/app-server/session-binding-record-codec.ts
+/** Canonical persisted binding codec; safe to load before worker transaction admission. */
+const optionalStringSchema = z.string().optional().catch(void 0);
+const optionalBooleanSchema = z.boolean().optional().catch(void 0);
+const optionalNonBlankStringSchema = z.string().refine((value) => Boolean(value.trim())).optional().catch(void 0);
+const optionalTimestampSchema = z.string().refine((value) => Number.isFinite(Date.parse(value))).optional().catch(void 0);
+const pendingSupervisionBranchSchema = z.object({
+	sourceThreadId: z.string().trim().min(1),
+	connectionFingerprint: z.string().trim().min(1).optional(),
+	lastTurnId: z.string().trim().min(1).optional(),
+	cleanupThreadIds: z.array(z.string().trim().min(1)).max(2).optional()
+}).strict().superRefine((pending, context) => {
+	const cleanupThreadIds = pending.cleanupThreadIds ?? [];
+	if (new Set(cleanupThreadIds).size !== cleanupThreadIds.length) context.addIssue({
+		code: "custom",
+		message: "pending supervision cleanup thread ids must be unique"
+	});
+	if (cleanupThreadIds.includes(pending.sourceThreadId)) context.addIssue({
+		code: "custom",
+		message: "pending supervision cleanup cannot target its source"
+	});
+});
+const contextEngineProjectionSchema = z.object({
+	schemaVersion: z.literal(1),
+	mode: z.literal("thread_bootstrap"),
+	epoch: z.string().refine((value) => Boolean(value.trim())),
+	fingerprint: optionalStringSchema
+}).strict();
+const contextEngineSchema = z.object({
+	schemaVersion: z.literal(1),
+	engineId: z.string(),
+	policyFingerprint: z.string(),
+	projection: contextEngineProjectionSchema.optional().catch(void 0)
+}).strict();
+const destructiveApprovalModeSchema = z.enum([
+	"allow",
+	"deny",
+	"auto",
+	"ask"
+]).optional();
+const accountAppPolicyEntrySchema = z.object({
+	source: z.literal("account"),
+	appName: z.string(),
+	allowDestructiveActions: z.boolean(),
+	allowOpenWorld: z.boolean().optional(),
+	destructiveApprovalMode: destructiveApprovalModeSchema.catch(void 0),
+	mcpServerNames: z.array(z.string())
+}).strict();
+const pluginAppPolicyEntrySchema = z.object({
+	source: z.literal("plugin").optional(),
+	configKey: z.string(),
+	marketplaceName: z.string().regex(CODEX_PLUGIN_MARKETPLACE_NAME_PATTERN),
+	pluginName: z.string(),
+	allowDestructiveActions: z.boolean(),
+	allowOpenWorld: z.boolean().optional(),
+	destructiveApprovalMode: destructiveApprovalModeSchema.catch(void 0),
+	mcpServerNames: z.array(z.string())
+}).strict();
+const pluginAppPolicyContextSchema = z.object({
+	fingerprint: z.string(),
+	apps: z.record(z.string(), z.union([accountAppPolicyEntrySchema, pluginAppPolicyEntrySchema])),
+	pluginAppIds: z.record(z.string(), z.array(z.string())).default({})
+}).strict();
+const legacyAppPolicyEntrySchema = z.union([accountAppPolicyEntrySchema.extend({ destructiveApprovalMode: destructiveApprovalModeSchema }).strip(), pluginAppPolicyEntrySchema.extend({ destructiveApprovalMode: destructiveApprovalModeSchema }).strip()]);
+const threadBindingSchema = z.object({
+	threadId: z.string().refine((value) => Boolean(value.trim())),
+	clientId: optionalStringSchema,
+	cwd: z.string(),
+	rolloutPath: optionalNonBlankStringSchema,
+	connectionScope: z.literal("supervision").optional(),
+	supervisionSourceThreadId: z.string().trim().min(1).optional(),
+	authProfileId: optionalStringSchema,
+	agentWorkspaceDeveloperInstructions: optionalStringSchema,
+	model: optionalStringSchema,
+	preserveNativeModel: z.literal(true).optional().catch(void 0),
+	pendingSupervisionBranch: pendingSupervisionBranchSchema.optional(),
+	pendingResumeConfiguration: z.literal(true).optional(),
+	modelProvider: z.string().transform((value) => value.trim()).pipe(z.string().min(1)).optional().catch(void 0),
+	approvalPolicy: z.preprocess((value) => value === "on-failure" ? "on-request" : value, z.enum([
+		"never",
+		"on-request",
+		"untrusted"
+	]).optional()).catch(void 0),
+	sandbox: z.enum([
+		"read-only",
+		"workspace-write",
+		"danger-full-access"
+	]).optional().catch(void 0),
+	serviceTier: z.preprocess(normalizeCodexServiceTier, z.custom((value) => typeof value === "string").optional()).optional().catch(void 0),
+	networkProxyProfileName: optionalStringSchema,
+	networkProxyConfigFingerprint: optionalStringSchema,
+	dynamicToolsFingerprint: optionalStringSchema,
+	dynamicToolsContainDeferred: optionalBooleanSchema,
+	webSearchThreadConfigFingerprint: optionalStringSchema,
+	nativeSkillIsolationFingerprint: optionalStringSchema,
+	userMcpServersFingerprint: optionalStringSchema,
+	mcpServersFingerprint: optionalStringSchema,
+	configuredMcpOwnershipVersion: z.literal(1).optional().catch(void 0),
+	ringZeroConfigFingerprint: optionalStringSchema,
+	ringZeroClientInstanceId: optionalStringSchema,
+	/** Durable fact preventing a later unrestricted turn from widening this thread. */
+	nativeToolPolicyRestricted: z.literal(true).optional().catch(void 0),
+	nativeHookRelayGeneration: optionalNonBlankStringSchema,
+	appServerRuntimeFingerprint: optionalStringSchema,
+	pluginAppsFingerprint: optionalStringSchema,
+	pluginAppsInputFingerprint: optionalStringSchema,
+	pluginAppPolicyContext: pluginAppPolicyContextSchema.optional().catch(void 0),
+	contextEngine: contextEngineSchema.optional().catch(void 0),
+	environmentSelectionFingerprint: optionalStringSchema,
+	conversationStartId: optionalStringSchema,
+	conversationSourceTransferComplete: z.literal(true).optional().catch(void 0),
+	historyCoveredThrough: optionalTimestampSchema,
+	continuityCalibration: z.object({
+		promptChars: z.number().int().positive(),
+		inputTokens: z.number().int().positive()
+	}).optional().catch(void 0)
+}).superRefine((binding, context) => {
+	if (binding.connectionScope === "supervision") {
+		if (!binding.supervisionSourceThreadId) context.addIssue({
+			code: "custom",
+			message: "supervision connection ownership requires its native source thread id"
+		});
+		if (binding.preserveNativeModel !== true) context.addIssue({
+			code: "custom",
+			message: "supervision connection ownership requires native model ownership"
+		});
+		if (binding.conversationSourceTransferComplete !== true) context.addIssue({
+			code: "custom",
+			message: "supervision connection ownership requires a completed source transfer"
+		});
+		if (!binding.pendingSupervisionBranch && (!binding.model?.trim() || !binding.modelProvider)) context.addIssue({
+			code: "custom",
+			message: "materialized supervision bindings require a native model and provider"
+		});
+	}
+	if (binding.supervisionSourceThreadId && binding.connectionScope !== "supervision") context.addIssue({
+		code: "custom",
+		message: "a supervision source thread id requires supervision connection ownership"
+	});
+	if (!binding.pendingSupervisionBranch) return;
+	if (binding.threadId !== binding.pendingSupervisionBranch.sourceThreadId) context.addIssue({
+		code: "custom",
+		message: "pending supervision source must match the provisional thread binding"
+	});
+	if (binding.supervisionSourceThreadId !== binding.pendingSupervisionBranch.sourceThreadId) context.addIssue({
+		code: "custom",
+		message: "pending supervision source must match its durable source identity"
+	});
+	if (binding.preserveNativeModel !== true) context.addIssue({
+		code: "custom",
+		message: "pending supervision bindings must defer model selection to Codex App Server"
+	});
+	if (binding.connectionScope !== "supervision") context.addIssue({
+		code: "custom",
+		message: "pending supervision bindings require supervision connection ownership"
+	});
+});
+function matchesPendingSupervisionBranch(binding, expected) {
+	const pending = binding?.pendingSupervisionBranch;
+	const cleanup = pending?.cleanupThreadIds ?? [];
+	const expectedCleanup = expected.cleanupThreadIds ?? [];
+	return binding?.threadId === expected.sourceThreadId && pending?.sourceThreadId === expected.sourceThreadId && pending.connectionFingerprint === expected.connectionFingerprint && pending.lastTurnId === expected.lastTurnId && cleanup.length === expectedCleanup.length && cleanup.every((threadId, index) => threadId === expectedCleanup[index]);
+}
+const bindingLeaseSchema = z.object({
+	token: z.string().refine((value) => Boolean(value.trim())),
+	expiresAt: z.number().finite()
+});
+const storedSessionIdSchema = z.string().transform((value) => value.trim()).pipe(z.string().min(1)).optional().catch(void 0);
+const storedBindingSchema = z.discriminatedUnion("state", [z.object({
+	version: z.literal(1),
+	state: z.literal("active"),
+	binding: threadBindingSchema,
+	sessionId: storedSessionIdSchema,
+	lease: bindingLeaseSchema.optional().catch(void 0),
+	nativeSubagentSubmissions: z.unknown().optional(),
+	nativeSubagentAssignments: z.unknown().optional(),
+	nativeSubagentTaskImport: z.unknown().optional()
+}), z.object({
+	version: z.literal(1),
+	state: z.literal("cleared"),
+	sessionId: storedSessionIdSchema,
+	lease: bindingLeaseSchema.optional().catch(void 0),
+	retired: z.literal(true).optional().catch(void 0),
+	nativeSubagentTaskImport: z.unknown().optional()
+})]);
+function readStoredCodexAppServerBinding(value) {
+	const result = storedBindingSchema.safeParse(value);
+	if (!result.success) return;
+	return stripUndefinedValue(result.data);
+}
+function validateBindingForWrite(binding) {
+	const validated = readCodexAppServerThreadBinding(binding);
+	if (!validated) throw new Error("Invalid Codex app-server thread binding");
+	return stripUndefinedBinding(validated);
+}
+/** Parses stored or shipped sidecar data into the current domain value. */
+function readCodexAppServerThreadBinding(value) {
+	const result = threadBindingSchema.safeParse(value);
+	if (!result.success) return;
+	return result.data;
+}
+function stripUndefinedBinding(binding) {
+	return stripUndefinedValue(binding);
+}
+function stripUndefinedValue(value) {
+	if (Array.isArray(value)) return value.map(stripUndefinedValue);
+	if (!value || typeof value !== "object") return value;
+	return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0).map(([key, entry]) => [key, stripUndefinedValue(entry)]));
+}
+function readCodexBindingTimestamp(value) {
+	return optionalTimestampSchema.parse(value);
+}
+//#endregion
+export { readStoredCodexAppServerBinding as a, readCodexBindingTimestamp as i, matchesPendingSupervisionBranch as n, stripUndefinedBinding as o, readCodexAppServerThreadBinding as r, validateBindingForWrite as s, legacyAppPolicyEntrySchema as t };

package/dist/.setup/{session-binding-sidecars-jo6H8dFr.mjs → session-binding-sidecars-BrdV95Fg.mjs}

@@ -1,4 +1,4 @@
-import { n as CODEX_APP_SERVER_BINDING_NAMESPACE, t as CODEX_APP_SERVER_BINDING_MAX_ENTRIES } from "./session-binding-meta-B7aEMU7g.mjs";
+import { i as CODEX_APP_SERVER_BINDING_NAMESPACE, r as CODEX_APP_SERVER_BINDING_MAX_ENTRIES } from "./session-binding-meta-Lkm5Lpf4.mjs";
 import "node:module";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { isDeepStrictEqual } from "node:util";
@@ -137,6 +137,12 @@ function createLegacyWebhookListenerDoctorContract(params) {
 	};
 	const prefix = `channels.${params.channelKey}`;
 	return {
+		historicalWebhookListener: {
+			channelId: params.channelKey,
+			port: params.defaultPort,
+			preserveAuthoredActivation: params.preserveAuthoredActivation,
+			...params.defaultHost === void 0 ? {} : { host: params.defaultHost }
+		},
 		legacyConfigRules: [{
 			path: ["channels", params.channelKey],
 			message: `${prefix} webhook listeners moved to Gateway routes. Run "openclaw doctor --fix" to preserve explicitly configured listener settings as legacyWebhook.`,
@@ -478,7 +484,7 @@ 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-DGCYAfvD.mjs").then((n) => n.s), import("./conversation-binding-data-C746z5Pn.mjs").then((n) => n.t)]);
+			const [{ bindingStoreKey, createStoredCodexAppServerBinding, normalizeStoredCodexAppServerBindingFingerprints, readStoredCodexAppServerBinding }, { legacyCodexConversationBindingId }] = await Promise.all([import("./session-binding-Ce7BqiPN.mjs").then((n) => n.i), import("./conversation-binding-data-DJ4ix-W5.mjs").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(),

package/dist/.setup/{session-catalog-adoption-BU_pHWG7.mjs → session-catalog-adoption-CPIP4S_y.mjs}

@@ -1,8 +1,8 @@
-import { T as requireBoundThread, d as boundedCatalogString, o as CatalogParamsError } from "./session-catalog-parsing-CPGaPYr-.mjs";
-import { v as sessionBindingIdentity } from "./session-binding-record-Oe9L-CNY.mjs";
+import { T as requireBoundThread, d as boundedCatalogString, o as CatalogParamsError } from "./session-catalog-parsing-B-qWJh2x.mjs";
+import { m as sessionBindingIdentity } from "./session-binding-record-BZB8RgcF.mjs";
 import { n as codexUpstreamBaseline, t as codexLastTerminalTurnId } from "./session-upstream-marker-D15C9NHp.mjs";
-import { i as reclaimCurrentCodexSessionGeneration } from "./session-binding-DGCYAfvD.mjs";
-import { adoptionSessionKeyRest, catalogSessionActions } from "./session-catalog-node-adoption-DgXvSGu0.mjs";
+import { n as reclaimCurrentCodexSessionGeneration } from "./session-binding-Ce7BqiPN.mjs";
+import { adoptionSessionKeyRest, catalogSessionActions } from "./session-catalog-node-adoption-7-WEQTB1.mjs";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { listSessionCatalogEntries, sessionCatalogAdoptedSessionKey, sessionCatalogAdoptedSourceKey } from "openclaw/plugin-sdk/session-catalog";
 //#region extensions/codex/src/session-catalog-adoption.ts
@@ -21,6 +21,7 @@ function adoptionSessionKey(threadId, sourceHomeId) {
 function isAdoptionSessionKeyForThread(sessionKey, threadId, sourceHomeId) {
 	return adoptionSessionKeyRest(sessionKey) === adoptionSessionKey(threadId, sourceHomeId);
 }
+const adoptionCandidatesByRevision = /* @__PURE__ */ new WeakMap();
 function readCodexSupervisionMarker(entry) {
 	const codex = isRecord(entry.pluginExtensions?.codex) ? entry.pluginExtensions.codex : void 0;
 	const marker = codex && isRecord(codex.supervision) ? codex.supervision : void 0;
@@ -33,12 +34,6 @@ function readCodexSupervisionMarker(entry) {
 	};
 }
 async function listAdoptedSessionEntries(params) {
-	const entries = listSessionCatalogEntries({
-		...params.agentId ? { agentId: params.agentId } : {},
-		config: params.config ?? {},
-		runtime: params.runtime,
-		sessionEntries: params.sessionEntries
-	});
 	const candidateForEntry = ({ agentId, entry, sessionKey }) => {
 		const sessionKeyRest = adoptionSessionKeyRest(sessionKey);
 		const marker = readCodexSupervisionMarker(entry);
@@ -59,15 +54,27 @@ async function listAdoptedSessionEntries(params) {
 		};
 	};
 	function* candidates() {
-		for (const entry of entries) {
+		for (const entry of listSessionCatalogEntries({
+			...params.agentId ? { agentId: params.agentId } : {},
+			config: params.config ?? {},
+			runtime: params.runtime,
+			sessionEntries: params.sessionEntries
+		})) {
 			const candidate = candidateForEntry(entry);
 			if (candidate) yield candidate;
 		}
 	}
-	const collect = (selected, readBinding = (identity) => params.bindingStore.read(identity)) => {
+	const collect = async (selected, readBinding = async (identity) => {
+		const bindings = params.bindingStore.readMany([identity]);
+		try {
+			return (await bindings.next()).value;
+		} finally {
+			await bindings.return(void 0);
+		}
+	}) => {
 		const adopted = /* @__PURE__ */ new Map();
 		for (const { agentId, sessionKey, sessionKeyRest, sessionId, marker, identity } of selected) {
-			const binding = readBinding(identity);
+			const binding = await readBinding(identity);
 			const sourceThreadId = binding?.supervisionSourceThreadId?.trim();
 			const boundThreadId = binding?.threadId.trim();
 			if (binding?.connectionScope !== "supervision" || !sourceThreadId || !boundThreadId || sessionKeyRest !== adoptionSessionKey(sourceThreadId, marker.sourceHomeId)) continue;
@@ -82,18 +89,27 @@ async function listAdoptedSessionEntries(params) {
 		}
 		return adopted;
 	};
-	if (!params.bindingStore.readMany) return collect(candidates());
+	const revision = params.sessionEntries?.revision;
+	const cached = revision ? adoptionCandidatesByRevision.get(revision) : void 0;
 	let prepared;
 	try {
-		prepared = [...candidates()];
+		if (cached && cached.config === params.config && cached.agentId === params.agentId) prepared = cached.candidates;
+		else {
+			prepared = [...candidates()];
+			if (revision) adoptionCandidatesByRevision.set(revision, {
+				config: params.config,
+				agentId: params.agentId,
+				candidates: prepared
+			});
+		}
 	} catch {
 		return collect(candidates());
 	}
 	const bindings = params.bindingStore.readMany(prepared.map(({ identity }) => identity));
 	try {
-		return collect(prepared, () => bindings.next().value);
+		return await collect(prepared, async () => (await bindings.next()).value);
 	} finally {
-		bindings.return(void 0);
+		await bindings.return(void 0);
 	}
 }
 async function findAdoptedSessionEntry(params) {
@@ -152,7 +168,7 @@ async function createOrReuseAdoptedSession(params) {
 			sourceThreadId: params.sourceThread.id,
 			...params.sourceHomeId ? { sourceHomeId: params.sourceHomeId } : {}
 		};
-		const { createImportedCodexSession } = await import("./session-history-import-WhX-X33a.mjs");
+		const { createImportedCodexSession } = await import("./session-history-import-NWKPa4ZO.mjs");
 		const created = await createImportedCodexSession({
 			runtime: params.api.runtime,
 			bindingStore: params.bindingStore,

package/dist/.setup/{session-catalog-archive-spHfihri.mjs → session-catalog-archive-DcgwvSbF.mjs}

@@ -1,9 +1,9 @@
-import { o as CatalogParamsError } from "./session-catalog-parsing-CPGaPYr-.mjs";
-import { v as sessionBindingIdentity } from "./session-binding-record-Oe9L-CNY.mjs";
+import { o as CatalogParamsError } from "./session-catalog-parsing-B-qWJh2x.mjs";
+import { m as sessionBindingIdentity } from "./session-binding-record-BZB8RgcF.mjs";
 import { t as assertCodexArchiveDescendantsUnowned } from "./thread-archive-guard-C9frICzX.mjs";
-import "./session-binding-DGCYAfvD.mjs";
-import { catalogSessionActions } from "./session-catalog-node-adoption-DgXvSGu0.mjs";
-import { isAdoptionSessionKeyForThread, requireIdleThread } from "./session-catalog-adoption-BU_pHWG7.mjs";
+import "./session-binding-Ce7BqiPN.mjs";
+import { catalogSessionActions } from "./session-catalog-node-adoption-7-WEQTB1.mjs";
+import { isAdoptionSessionKeyForThread, requireIdleThread } from "./session-catalog-adoption-CPIP4S_y.mjs";
 import { listAgentIds } from "openclaw/plugin-sdk/agent-scope-runtime";
 import { sessionCatalogAdoptedSourceKey } from "openclaw/plugin-sdk/session-catalog";
 //#region extensions/codex/src/session-catalog-archive.ts
@@ -26,31 +26,26 @@ function assertNoPendingSupervisionBranch(params) {
 }
 /** Archives one inactive Gateway-local Codex thread after a fresh status read. */
 async function archiveLocalCodexSession(params) {
-	return await catalogSessionActions.enqueue(sessionCatalogAdoptedSourceKey(params.hostId ?? "gateway:local", params.threadId), async () => {
-		return await params.bindingStore.withThreadArchiveFence(async () => {
-			const run = async (control) => {
-				assertNoPendingSupervisionBranch(params);
-				await control.requireEligibleThread(params.threadId);
-				const thread = await control.readThread(params.threadId, false);
-				if (thread.id !== params.threadId) throw new Error("Codex app-server returned a different thread than requested");
-				requireIdleThread(thread, "archive");
-				if (await params.bindingStore.hasOtherThreadOwner(params.threadId)) throw new CatalogParamsError("Codex session cannot be archived while it is attached to an OpenClaw session");
-				await assertCodexArchiveDescendantsUnowned({
-					bindingStore: params.bindingStore,
-					threadId: params.threadId,
-					listPage: (request) => control.listDescendantPage(request),
-					assertDescendantIdle: async (descendantThreadId) => {
-						const descendant = await control.readThread(descendantThreadId, false);
-						if (descendant.id !== descendantThreadId) throw new Error("Codex app-server returned a different descendant than requested");
-						requireIdleThread(descendant, "archive");
-					}
-				});
-				await control.archiveThread(params.threadId);
-				return { archived: true };
-			};
-			return await params.control.withPinnedConnection(run);
+	return await catalogSessionActions.enqueue(sessionCatalogAdoptedSourceKey(params.hostId ?? "gateway:local", params.threadId), () => params.bindingStore.withThreadArchiveFence(() => params.control.withPinnedConnection(async (control) => {
+		assertNoPendingSupervisionBranch(params);
+		await control.requireEligibleThread(params.threadId);
+		const thread = await control.readThread(params.threadId, false);
+		if (thread.id !== params.threadId) throw new Error("Codex app-server returned a different thread than requested");
+		requireIdleThread(thread, "archive");
+		if (await params.bindingStore.hasOtherThreadOwner(params.threadId)) throw new CatalogParamsError("Codex session cannot be archived while it is attached to an OpenClaw session");
+		await assertCodexArchiveDescendantsUnowned({
+			bindingStore: params.bindingStore,
+			threadId: params.threadId,
+			listPage: (request) => control.listDescendantPage(request),
+			assertDescendantIdle: async (descendantThreadId) => {
+				const descendant = await control.readThread(descendantThreadId, false);
+				if (descendant.id !== descendantThreadId) throw new Error("Codex app-server returned a different descendant than requested");
+				requireIdleThread(descendant, "archive");
+			}
 		});
-	});
+		await control.archiveThread(params.threadId);
+		return { archived: true };
+	})));
 }
 //#endregion
 export { archiveLocalCodexSession };

package/dist/.setup/{session-catalog-events-DePDzzjc.mjs → session-catalog-events-KIXOoSnQ.mjs}

@@ -1,10 +1,10 @@
-import { c as MAX_CWD_LENGTH, d as boundedCatalogString } from "./session-catalog-parsing-CPGaPYr-.mjs";
-import { n as defineCodexBuildState } from "./build-state-Da1_z0kd.mjs";
-import { r as inferCodexAppServerConnectionClass } from "./config-security-CE-FcGw9.mjs";
+import { c as MAX_CWD_LENGTH, d as boundedCatalogString } from "./session-catalog-parsing-B-qWJh2x.mjs";
+import { n as defineCodexBuildState } from "./build-state-CIi3Ckqu.mjs";
+import { r as inferCodexAppServerConnectionClass } from "./config-security-KAPScztc.mjs";
 import { n as resolveCodexAppServerLocalHomeDir } from "./auth-start-options-BPIPeEX8.mjs";
 import { n as codexCatalogHomeIdFromCanonicalPath } from "./session-catalog-home-id-vlih0B_g.mjs";
-import { t as buildCodexAppServerConnectionFingerprint } from "./plugin-app-cache-key-BL9B5H0L.mjs";
-import { d as observeCodexCatalogEphemeralThreads, r as projectCodexCatalogNativeThread, s as codexCatalogSourceForClient } from "./session-catalog-native-projection-DjhwGL6x.mjs";
+import { t as buildCodexAppServerConnectionFingerprint } from "./plugin-app-cache-key-BW8rd98k.mjs";
+import { d as observeCodexCatalogEphemeralThreads, r as projectCodexCatalogNativeThread, s as codexCatalogSourceForClient } from "./session-catalog-native-projection-CTBd4EUm.mjs";
 import { createHash } from "node:crypto";
 import { embeddedAgentLog } from "openclaw/plugin-sdk/agent-harness-registration";
 import path from "node:path";